# Copyright 2018-2019 the Deno authors. All rights reserved. MIT license.
declare_args() {
  # Absolute path of rust build files.
  rust_build = "//build_extra/rust/"

  # Wrapper executable for rustc invocations. This can be used for a caching
  # utility, e.g. sccache.
  rustc_wrapper = ""

  # treat the warnings in rust files as errors
  rust_treat_warnings_as_errors = true
}

if (is_linux) {
  executable_suffix = ""
  shared_lib_prefix = "lib"
  shared_lib_suffix = ".so"
} else if (is_mac) {
  executable_suffix = ""
  shared_lib_prefix = "lib"
  shared_lib_suffix = ".dylib"
} else if (is_win) {
  executable_suffix = ".exe"
  shared_lib_prefix = ""
  shared_lib_suffix = ".dll"
} else {
  assert(false, "Unsupported platform")
}

# To simplify transitive dependency management with gn, we build all rust
# crates into the same directory. We need to be careful not to have crates
# with the same name.
out_dir = "$root_out_dir/rust_crates"

# The official way of building Rust executables is to to let rustc do the
# linking. However, we'd prefer to leave it in the hands of gn/ninja:
#   * It allows us to use source sets.
#   * It allows us to use the bundled lld that Chromium and V8 use.
#   * We have more control over build flags.
#   * To sidestep rustc weirdness (e.g. on Windows, it always links with the
#     release C runtime library, even for debug builds).
#
# The `get_rustc_info` tool outputs the linker flags that are needed to
# successfully link rustc object code into an executable.
# We generate two sets of ldflags:
#   `ldflags_bin` : Used for rust_executable targets.
#   `ldflags_test`: Used for rust_test targets; includes the test harness.
#
# The tool works by compiling and linking something with rustc, and analyzing
# the arguments it passes to the system linker. That's what dummy.rs is for.
_rustc_info = exec_script("get_rustc_info.py", [], "json")

template("_rust_crate") {
  config_name = "${target_name}_config"
  action_name = "${target_name}_rustc"

  forward_variables_from(invoker,
                         [
                           "cfg",
                           "crate_name",
                           "crate_type",
                           "crate_version",
                           "deps",
                           "edition",
                           "inputs",
                           "features",
                           "is_test",
                           "libs",
                           "source_root",
                           "testonly",
                           "treat_warnings_as_errors",
                         ])

  if (!defined(crate_name)) {
    crate_name = target_name
  }
  if (!defined(crate_type)) {
    crate_type = "rlib"
  }
  if (!defined(deps)) {
    deps = []
  }
  if (!defined(edition)) {
    edition = "2018"
  }
  if (!defined(is_test)) {
    is_test = false
  }
  if (!defined(libs)) {
    libs = []
  }
  if (!defined(treat_warnings_as_errors)) {
    # Use global setting if not explicitly specified for this target.
    treat_warnings_as_errors = rust_treat_warnings_as_errors
  }

  if (defined(crate_version)) {
    # In our build setup, all crates are built in the same directory. To avoid
    # file name conflicts between when multiple versions of the same crate are
    # built, add a unique suffix to output file names.
    # Unfortunately the version number as such can't be used directly:
    # everything after the first dot (.) is thrown away by rust, so in case of
    # foo-0.2 vs foo-0.3 only the first '0' would be used, and conflicts would
    # still occur. Therefore we use a hash of the version number instead.
    crate_suffix = exec_script("//tools/sha256sum.py",
                               [
                                 "--input=$crate_version",
                                 "--format=-%.8s",
                               ],
                               "trim string")
  } else {
    # Of most crates we use only one version; no need for all this difficulty.
    crate_suffix = ""
  }

  if (crate_type == "bin") {
    out_file = "$crate_name$crate_suffix.o"
    emit_type = "obj"
  } else if (crate_type == "proc-macro") {
    out_file = "$shared_lib_prefix$crate_name$crate_suffix$shared_lib_suffix"
    emit_type = "link"
  } else if (crate_type == "rlib") {
    out_file = "lib$crate_name$crate_suffix.rlib"
    emit_type = "link"
  }
  out_path = "$out_dir/$out_file"

  # Merge `invoker.extern` and `invoker.extern_rlib` into a single list.
  extern = []
  if (defined(invoker.extern)) {
    extern += invoker.extern
  }
  if (defined(invoker.extern_rlib)) {
    foreach(extern_crate_name, invoker.extern_rlib) {
      extern += [
        {
          label = "$rust_build:$extern_crate_name"
          crate_name = extern_crate_name
          crate_type = "rlib"
        },
      ]
    }
  }

  # Add output file info to every entry in the 'extern' list.
  extern_outputs = []
  foreach(info, extern) {
    extern_outputs += [
      {
        label = info.label
        crate_name = info.crate_name
        crate_type = info.crate_type

        if (!defined(info.crate_version)) {
          crate_suffix = ""
        } else {
          crate_version = info.crate_version
          crate_suffix = exec_script("//tools/sha256sum.py",
                                     [
                                       "--input=$crate_version",
                                       "--format=-%.8s",
                                     ],
                                     "trim string")
        }

        if (crate_type == "rlib") {
          out_file = "lib$crate_name$crate_suffix.rlib"
        } else if (info.crate_type == "proc_macro") {
          out_file =
              "$shared_lib_prefix$crate_name$crate_suffix$shared_lib_suffix"
        }
        out_path = "$out_dir/$out_file"
      },
    ]
  }

  config(config_name) {
    foreach(info, extern_outputs) {
      if (info.crate_type == "rlib") {
        libs += [ info.out_path ]
      }
    }
    lib_dirs = [ out_dir ]
  }

  source_set(target_name) {
    public_deps = [
      ":$action_name",
    ]
    libs += [ out_path ]
    all_dependent_configs = [ ":$config_name" ]
  }

  action(action_name) {
    script = "//build_extra/rust/run.py"
    sources = [
      source_root,
    ]
    outputs = [
      out_path,
    ]
    depfile = "$out_dir/$crate_name$crate_suffix.d"

    if (rustc_wrapper != "") {
      args = [ rustc_wrapper ]
    } else {
      args = []
    }

    args += [
      "rustc",
      rebase_path(source_root, root_build_dir),
      "--crate-name=$crate_name",
      "--crate-type=$crate_type",
      "--emit=$emit_type,dep-info",
      "--edition=$edition",
      "--out-dir=" + rebase_path(out_dir, root_build_dir),

      # This is to disambiguate multiple versions of the same crate.
      "-Cextra-filename=$crate_suffix",

      # Appending the rustc version to the crate metadata ensures that they are
      # rebuilt when rustc is upgraded, by changing the command line.
      "-Cmetadata=\"${crate_suffix}_${_rustc_info.version}\"",

      # This is needed for transitive dependencies.
      "-L",
      "dependency=" + rebase_path(out_dir, root_build_dir),

      # Use colorful output even if stdout is redirected and not a tty.
      "--color=always",
    ]

    if (defined(crate_version)) {
      args += [
        # This is used to set env variables for Cargo build compatibility
        "--cargo-pkg-version=$crate_version",
      ]
    }

    if (is_win) {
      # Proc-macro crates need to be linked by rustc itself, because rustc
      # doesn't expose all the information necessary to produce the correct
      # linker invocation ourselves. However gn's setup creates an environment
      # where link.exe doesn't always work, so we direct rustc to use lld-link,
      # and explicitly load the proper environment that makes it work in run.py.
      args += [
        "-Clinker-flavor=lld-link",
        "-Clinker=" + rebase_path(
                "//third_party/llvm-build/Release+Asserts/bin/lld-link.exe",
                root_build_dir),
      ]
    }

    if (is_debug) {
      args += [ "-g" ]
    }
    if (is_official_build) {
      args += [
        "-C",
        "opt-level=3",
      ]
    }
    if (is_test) {
      args += [ "--test" ]
    }
    if (treat_warnings_as_errors) {
      args += [ "-Dwarnings" ]
    }
    if (defined(invoker.args)) {
      args += invoker.args
    }

    if (defined(cfg)) {
      foreach(c, cfg) {
        args += [
          "--cfg",
          c,
        ]
      }
    }

    if (defined(features)) {
      foreach(f, features) {
        args += [
          "--cfg",
          "feature=\"" + f + "\"",
        ]
      }
    }

    # Build the list of '--extern' arguments from the 'extern_outputs' array.
    foreach(info, extern_outputs) {
      args += [
        "--extern",
        info.crate_name + "=" + rebase_path(info.out_path, root_build_dir),
      ]
      sources += [ info.out_path ]
      deps += [ info.label ]
    }
  }
}

template("rust_rlib") {
  _rust_crate(target_name) {
    forward_variables_from(invoker, "*")
    crate_type = "rlib"
  }
}

template("rust_proc_macro") {
  _rust_crate(target_name) {
    forward_variables_from(invoker, "*")
    crate_type = "proc-macro"
  }
}

template("rust_executable") {
  bin_name = target_name + "_bin"
  bin_label = ":" + bin_name

  _rust_crate(bin_name) {
    crate_type = "bin"
    forward_variables_from(invoker, "*")
  }

  executable(target_name) {
    forward_variables_from(invoker, "*")

    if (defined(is_test) && is_test) {
      ldflags = _rustc_info.ldflags_test
    } else {
      ldflags = _rustc_info.ldflags_bin
    }

    if (!defined(deps)) {
      deps = []
    }

    deps += [ bin_label ]

    if (defined(extern)) {
      foreach(info, extern) {
        if (info.crate_type == "rlib") {
          deps += [ info.label ]
        }
      }
    }

    if (defined(extern_rlib)) {
      foreach(extern_crate_name, extern_rlib) {
        deps += [ "$rust_build:$extern_crate_name" ]
      }
    }
  }
}

template("rust_test") {
  rust_executable(target_name) {
    forward_variables_from(invoker, "*")
    is_test = true
    testonly = true
  }
}