# Copyright (c) 2016, the Dart project authors.  Please see the AUTHORS file
# for details. All rights reserved. Use of this source code is governed by a
# BSD-style license that can be found in the LICENSE file.

import("../../build/dart/dart_action.gni")
import("../application_snapshot.gni")
import("../create_timestamp.gni")

patched_sdk_dir = "$target_gen_dir/patched_sdk"
sdk_summary = "$target_gen_dir/ddc_sdk.sum"
sdk_dill = "$target_gen_dir/kernel/ddc_sdk.dill"
sdk_libraries_json = "$target_gen_dir/libraries.json"

application_snapshot("dartdevc") {
  main_dart = "../../pkg/dev_compiler/bin/dartdevc.dart"

  training_args = [
    "--dart-sdk",
    rebase_path("../../sdk"),
    "--dart-sdk-summary",
    rebase_path(sdk_dill),
    "-k",
    "-o",
    "dartdevc.js",
    rebase_path("../../pkg/dev_compiler/bin/dartdevc.dart"),
  ]

  deps = [
    ":dartdevc_sdk",
  ]

  inputs = [ sdk_summary ]
}

sdk_lib_files = exec_script("../../tools/list_dart_files.py",
                            [
                              "absolute",
                              rebase_path("../../sdk/lib"),
                            ],
                            "list lines")

compiler_files = exec_script("../../tools/list_dart_files.py",
                             [
                               "absolute",
                               rebase_path("../../pkg/compiler"),
                             ],
                             "list lines")

dev_compiler_files = exec_script("../../tools/list_dart_files.py",
                                 [
                                   "absolute",
                                   rebase_path("../../pkg/dev_compiler"),
                                 ],
                                 "list lines")

template("dart2js_compile") {
  assert(defined(invoker.main), "Must specify the main file")
  main = invoker.main
  assert(defined(invoker.out), "Must specify the out file")
  out = invoker.out
  abs_main = rebase_path(main)
  abs_output = rebase_path(out)

  dart_action(target_name) {
    deps = [
      "../compiler:compile_dart2js_platform",
    ]

    # dart_action() needs kernel service snapshot to run in Dart 2 mode.
    # This can't be added as a dependency to dart_action() itself as it will
    # create a circular dependency.
    deps += [ "../../utils/kernel-service:kernel-service" ]

    inputs = sdk_lib_files + compiler_files + dev_compiler_files + [
               "$root_out_dir/dart2js_platform.dill",
               "$root_out_dir/dart2js_outline.dill",
             ]
    outputs = [
      out,
    ]

    script = "../../pkg/compiler/lib/src/dart2js.dart"

    packages = "../../.packages"

    args = [
      "$abs_main",
      "-m",
      "-o$abs_output",
    ]
  }
}

dart2js_compile("dartdevc_web") {
  main = rebase_path("../../pkg/dev_compiler/web/main.dart")
  out = "$root_out_dir/dev_compiler/build/web/ddc_web_compiler.js"
}

dart2js_compile("stack_trace_mapper") {
  main = rebase_path("../../pkg/dev_compiler/web/stack_trace_mapper.dart")
  out = "$root_out_dir/dev_compiler/build/web/dart_stack_trace_mapper.js"
}

# Apply dev_compiler's patch files to create the Dart version of the dartdevc
# SDK.
prebuilt_dart_action("dartdevc_patch_sdk") {
  # TODO(rnystrom): Unfork DDC's patch_sdk.dart script with the
  # tools/patch_sdk.dart and then change this to use generate_patch_sdk().
  deps = [
    ":dartdevc_files_stamp",
    ":dartdevc_sdk_patch_stamp",

    # The patch script uses several packages, including analyzer, so consider
    # it dirty if any of those change.
    "../../pkg:pkg_files_stamp",
  ]

  script = "../../pkg/dev_compiler/tool/patch_sdk.dart"

  # The main SDK library sources.
  inputs = sdk_lib_files

  # dev_compiler's additional sources and patch files.
  inputs += exec_script("../../tools/list_dart_files.py",
                        [
                          "absolute",
                          rebase_path("../../sdk/lib/_internal/js_dev_runtime"),
                        ],
                        "list lines")

  # Arbitrarily use the version file as a token file to check against to see if
  # the sources have changed.
  # TODO(rnystrom): List the outputs more precisely?
  outputs = [
    "$patched_sdk_dir/version",
  ]

  args = [
    rebase_path("../../"),
    rebase_path("../../sdk/lib/_internal/js_dev_runtime"),
    rebase_path(patched_sdk_dir),
  ]
}

# Compiles the Dart core libraries and DDC runtime to an analyzer summary and
# JS.
prebuilt_dart_action("dartdevc_sdk") {
  deps = [
    ":dartdevc_files_stamp",
    ":dartdevc_patch_sdk",
    "../../pkg:pkg_files_stamp",
  ]

  script = "../../pkg/dev_compiler/tool/build_sdk.dart"

  inputs = [
    "../../pkg/dev_compiler/tool/build_sdk.dart",

    # Since the entire patched SDK is built in one step, if any file changes,
    # they all will. Instead of listing them all as outputs of
    # dartdevc_patch_sdk (which would require something like a depfile), just
    # use version as the token file whose timestamp we track.
    # TODO(rnystrom): Do something better?
    "$patched_sdk_dir/version",

    # If dev_compiler itself changes, it can affect the generated SDK.
    "$target_gen_dir/dartdevc_files.stamp",

    # Likewise, the packages dev_compiler depends on may affect its output.
    "$root_gen_dir/pkg_files.stamp",
  ]

  outputs = [
    sdk_summary,
    "$target_gen_dir/js/amd/dart_sdk.js",
    "$target_gen_dir/js/amd/dart_sdk.js.map",
    "$target_gen_dir/js/common/dart_sdk.js",
    "$target_gen_dir/js/common/dart_sdk.js.map",
    "$target_gen_dir/js/es6/dart_sdk.js",
    "$target_gen_dir/js/es6/dart_sdk.js.map",
    "$target_gen_dir/js/legacy/dart_sdk.js",
    "$target_gen_dir/js/legacy/dart_sdk.js.map",
  ]

  args = [
    "--dart-sdk",
    rebase_path(patched_sdk_dir),
    "--dart-sdk-summary=build",
    "--summary-out",
    rebase_path(sdk_summary),
    "--source-map",
    "--source-map-comment",
    "--modules=amd",
    "-o",
    rebase_path("$target_gen_dir/js/amd/dart_sdk.js"),
    "--modules=es6",
    "-o",
    rebase_path("$target_gen_dir/js/es6/dart_sdk.js"),
    "--modules=common",
    "-o",
    rebase_path("$target_gen_dir/js/common/dart_sdk.js"),
    "--modules=legacy",
    "-o",
    rebase_path("$target_gen_dir/js/legacy/dart_sdk.js"),
  ]
}

# Builds everything needed to run dartdevc tests using test.dart.
group("dartdevc_test") {
  deps = [
    ":dartdevc",
    ":dartdevc_sdk",
    ":dartdevc_kernel_sdk",
    ":dartdevc_test_pkg",
    "../../sdk:create_sdk",
  ]
}

# Builds everything needed to run dartdevc tests locally using test.dart without
# --use-sdk. This is the same as dartdevc_test, but skips things rely on
# building the Dart VM and create_sdk.
group("dartdevc_test_local") {
  deps = [
    ":dartdevc_sdk",
    ":dartdevc_kernel_sdk",
    ":dartdevc_test_pkg",
  ]
}

create_timestamp_file("dartdevc_files_stamp") {
  path = rebase_path("../../pkg/dev_compiler/lib")
  output = "$target_gen_dir/dartdevc_files.stamp"
}

create_timestamp_file("dartdevc_sdk_patch_stamp") {
  path = rebase_path("../../sdk/lib/_internal/js_dev_runtime")
  output = "$target_gen_dir/dartdevc_sdk_patch_stamp.stamp"
}

# Compiles the packages used by the tests to JS with dartdevc so that they are
# available for loading by the tests.
prebuilt_dart_action("dartdevc_test_pkg") {
  deps = [
    ":dartdevc_files_stamp",
    ":dartdevc_sdk",
    ":dartdevc_kernel_sdk",
    "../../pkg:pkg_files_stamp",
  ]

  inputs = [
    sdk_dill,
    sdk_libraries_json,
    sdk_summary,
    "$target_gen_dir/dartdevc_files.stamp",
    "$root_gen_dir/pkg_files.stamp",
  ]

  outputs = [
    "$target_gen_dir/pkg/async_helper.js",
    "$target_gen_dir/pkg/async_helper.sum",
    "$target_gen_dir/pkg/collection.js",
    "$target_gen_dir/pkg/collection.sum",
    "$target_gen_dir/pkg/expect.js",
    "$target_gen_dir/pkg/expect.sum",
    "$target_gen_dir/pkg/js.js",
    "$target_gen_dir/pkg/js.sum",
    "$target_gen_dir/pkg/matcher.js",
    "$target_gen_dir/pkg/matcher.sum",
    "$target_gen_dir/pkg/meta.js",
    "$target_gen_dir/pkg/meta.sum",
    "$target_gen_dir/pkg/path.js",
    "$target_gen_dir/pkg/path.sum",
    "$target_gen_dir/pkg/stack_trace.js",
    "$target_gen_dir/pkg/stack_trace.sum",

    # TODO(rnystrom): Remove this when unittest is no longer used. Also remove
    # any of the above packages that are only here because unittest uses them.
    "$target_gen_dir/pkg/unittest.js",
    "$target_gen_dir/pkg/unittest.sum",

    "$target_gen_dir/pkg_kernel/async_helper.dill",
    "$target_gen_dir/pkg_kernel/async_helper.js",
    "$target_gen_dir/pkg_kernel/collection.dill",
    "$target_gen_dir/pkg_kernel/collection.js",
    "$target_gen_dir/pkg_kernel/expect.dill",
    "$target_gen_dir/pkg_kernel/expect.js",
    "$target_gen_dir/pkg_kernel/js.dill",
    "$target_gen_dir/pkg_kernel/js.js",
    "$target_gen_dir/pkg_kernel/matcher.dill",
    "$target_gen_dir/pkg_kernel/matcher.js",
    "$target_gen_dir/pkg_kernel/meta.dill",
    "$target_gen_dir/pkg_kernel/meta.js",
    "$target_gen_dir/pkg_kernel/path.dill",
    "$target_gen_dir/pkg_kernel/path.js",
    "$target_gen_dir/pkg_kernel/stack_trace.dill",
    "$target_gen_dir/pkg_kernel/stack_trace.js",

    # TODO(rnystrom): Remove this when unittest is no longer used. Also remove
    # any of the above packages that are only here because unittest uses them.
    "$target_gen_dir/pkg_kernel/unittest.dill",
    "$target_gen_dir/pkg_kernel/unittest.js",
  ]

  script = "../../pkg/dev_compiler/tool/build_pkgs.dart"

  args = [
    "--analyzer-sdk",
    rebase_path(sdk_summary),
    "--kernel-sdk",
    rebase_path(sdk_dill),
    "--output",
    rebase_path("$target_gen_dir"),
  ]
}

# Compiles the DDC SDK's kernel summary and JS code.
prebuilt_dart_action("dartdevc_kernel_sdk") {
  deps = [
    "../../pkg:pkg_files_stamp",
    ":dartdevc_files_stamp",
    ":dartdevc_sdk_patch_stamp",
  ]

  inputs = [
    "../../pkg/dev_compiler/tool/kernel_sdk.dart",
    "$target_gen_dir/dartdevc_files.stamp",
    "$root_gen_dir/pkg_files.stamp",
  ]

  outputs = [
    sdk_dill,
    sdk_libraries_json,
    "$target_gen_dir/kernel/amd/dart_sdk.js",
    "$target_gen_dir/kernel/amd/dart_sdk.js.map",
    "$target_gen_dir/kernel/common/dart_sdk.js",
    "$target_gen_dir/kernel/common/dart_sdk.js.map",
    "$target_gen_dir/kernel/es6/dart_sdk.js",
    "$target_gen_dir/kernel/es6/dart_sdk.js.map",
    "$target_gen_dir/kernel/legacy/dart_sdk.js",
    "$target_gen_dir/kernel/legacy/dart_sdk.js.map",
  ]

  script = "../../pkg/dev_compiler/tool/kernel_sdk.dart"

  args = [
    "--output",
    rebase_path(sdk_dill),
    "--libraries",
    rebase_path("../../sdk/lib/libraries.json"),
  ]
}