# Copyright 2018 The Fuchsia Authors. 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/config/clang/clang.gni")
import("//build/fidl/toolchain.gni")

declare_args() {
  # Sets a custom base directory for `rustc` and `cargo`.
  # This can be used to test custom Rust toolchains.
  rustc_prefix = "//buildtools/${host_platform}/rust/bin"

  # Sets the default LTO type for rustc bulids.
  rust_lto = "unset"
}

template("rustc_third_party_artifact") {
  # Dummy build target to match the one in rustc_artifact
  build_target_name = "${target_name}_build"
  action(build_target_name) {
    script = "//build/rust/write_3p_crate_dep_info.py"
    forward_variables_from(invoker, [ "crate_name" ])

    out_info_path = "${target_out_dir}/${target_name}_info.json"

    args = [
      # This is a slight lie to the end user-- the crate name that
      # users provide and that appears in Cargo.toml is the package name,
      # which may be different than the crate name (the thing given to
      # --extern). One example of this is the rust-crypto crate,
      # whose real crate name is crypto, but which is published under
      # the package name rust-crypto.
      "--package-name",
      crate_name,
      "--output",
      rebase_path(out_info_path),
    ]
    outputs = [
      out_info_path,
    ]
  }

  group(target_name) {
    public_deps = [
      ":${build_target_name}",
    ]
  }
}

# Defines a Rust artifact to be built directly with rustc (rather than using cargo)
#
# Only for internal use, supporting rustc_library and rustc_binary.
#
# The arguments are the same as for rustc_library and rustc_binary, with the exception
# of `type`, which must be one of bin/lib/staticlib/proc-macro. This is used to determine
# the kind of artifact that is produced by rustc.
template("rustc_artifact") {
  assert(defined(invoker.type),
         "Must specify an artifact type (bin/lib/staticlib/proc-macro)")
  type = invoker.type

  # bin: executable binary application
  # lib: intermediate artifact to be used in other Rust programs
  # staticlib: a statically-linked system library, generally used for linking Rust into C
  # proc-macro: a procedural macro (such as a custom-derive)
  assert(
      type == "bin" || type == "lib" || type == "staticlib" ||
          type == "proc-macro",
      "Artifact type must be one of: \"bin\", \"lib\", \"staticlib\", or \"proc-macro\"")
  if (type == "lib") {
    # For now, lib == rlib, but this could change in future versions of rustc.
    # If/when this changes, we will likely want to transition manually rather
    # than being automatically changed as a result of a toolchain upgrade.
    type = "rlib"
  }

  if (defined(invoker.name)) {
    package_name = invoker.name
  } else {
    package_name = target_name
  }

  crate_name = exec_script(
      "//build/rust/package_name_to_crate_name.py",
      [
        "--package-name",
        package_name,
      ],
      "trim string"
  )

  if (defined(invoker.version)) {
    version = invoker.version
  } else {
    version = "0.1.0"
  }

  assert(
      current_os == "mac" || current_os == "linux" || current_os == "fuchsia",
      "current_os was neither mac, linux, nor fuchsia")
  if (current_os == "mac") {
    target_triple = "x86_64-apple-darwin"
    assert(current_cpu == "x64")
  } else if (current_os == "linux") {
    assert(current_cpu == "x64")
    target_triple = "x86_64-unknown-linux-gnu"
  } else if (current_os == "fuchsia") {
    assert(current_cpu == "x64" || current_cpu == "arm64")
    if (current_cpu == "x64") {
      target_triple = "x86_64-unknown-fuchsia"
    } else if (current_cpu == "arm64") {
      target_triple = "aarch64-unknown-fuchsia"
    }
  }

  group_deps = []

  if (is_debug) {
    opt_level = "0"
  } else {
    opt_level = "z"
  }

  if (type == "bin") {
    if (defined(invoker.with_lto)) {
      with_lto = invoker.with_lto
    } else if (rust_lto != "unset") {
      with_lto = rust_lto
    } else if (is_debug) {
      with_lto = "none"
    } else {
      # TODO(tkilbourn): turn this on after gathering more data on impact to build
      # speed.
      with_lto = "none"
    }
  } else {
    with_lto = "none"
  }
  assert(
      with_lto == "none" || with_lto == "thin" || with_lto == "fat",
      "with_lto was neither none, thin, or fat")

  # Determine the prefix and extension for the output file based on the crate type
  if (type == "bin") {
    prefix = ""
    extension = ""
    root_file = "src/main.rs"
  } else if (type == "rlib") {
    prefix = "lib"
    extension = ".rlib"
    root_file = "src/lib.rs"
  } else if (type == "staticlib") {
    prefix = "staticlib"
    extension = ".a"
    root_file = "src/lib.rs"
  } else if (type == "proc-macro") {
    prefix = "macro"
    extension = ".so"
    root_file = "src/lib.rs"
  }

  third_party_build = "//third_party/rust-crates/rustc_deps:build-third-party"
  third_party_deps_data = "${root_out_dir}/rust_third_party/deps_data.json"
  first_party_crate_root = "${root_out_dir}/rust_crates"
  output_file = "${first_party_crate_root}/${prefix}${crate_name}${extension}"
  output_depfile = "${first_party_crate_root}/${prefix}${crate_name}.d"
  test_output_file = "${root_out_dir}/${crate_name}_${invoker.type}_test_rustc"

  build_target_name = "${target_name}_build"
  group_deps += [ ":${build_target_name}" ]

  with_unit_tests = defined(invoker.with_unit_tests) && invoker.with_unit_tests

  # Iterate through the deps collecting a list of the outputs
  # of their build targets, which will be passed to rustc as
  # `--extern` crates.
  dep_info_paths = []
  if (defined(invoker.deps)) {
    foreach(dep, invoker.deps) {
      dep_target_name = get_label_info(dep, "name")
      dep_dir = get_label_info(dep, "dir")
      dep_build_target = "${dep_dir}:${dep_target_name}_build"
      dep_out_dir = get_label_info(dep_build_target, "target_out_dir")
      dep_info_path = "${dep_out_dir}/${dep_target_name}_build_info.json"
      dep_info_paths += [
        "--dep-data",
        rebase_path(dep_info_path),
      ]
    }
  }

  if (defined(invoker.source_root)) {
    root_file = invoker.source_root
  }
  root_file = rebase_path(root_file)

  cargo_toml_dir = "$target_gen_dir/$target_name"

  # Declare the action target that performs the build itself
  action(build_target_name) {
    script = "//build/rust/build_rustc_target.py"

    forward_variables_from(invoker,
                           [
                             "deps",
                             "testonly",
                           ])
    if (!defined(deps)) {
      deps = []
    }
    deps += [ third_party_build ]
    inputs = [
      root_file,
    ]
    depfile = output_depfile

    if (defined(invoker.non_rust_deps)) {
      public_deps = invoker.non_rust_deps
    }

    out_info_path = "${target_out_dir}/${target_name}_info.json"

    args = [
      "--rustc",
      rebase_path("$rustc_prefix/rustc"),
      "--crate-root",
      rebase_path(root_file),
      "--cargo-toml-dir",
      rebase_path(cargo_toml_dir),
      "--crate-type",
      type,
      "--crate-name",
      crate_name,
      "--package-name",
      package_name,
      "--opt-level",
      opt_level,
      "--depfile",
      rebase_path(output_depfile),
      "--root-out-dir",
      rebase_path(root_out_dir),
      "--output-file",
      rebase_path(output_file),
      "--test-output-file",
      rebase_path(test_output_file),
      "--target",
      target_triple,
      "--cmake-dir",
      rebase_path("//buildtools/cmake/bin"),
      "--shared-libs-root",
      rebase_path(
          get_label_info("//default($shlib_toolchain)", "root_out_dir")),
      "--first-party-crate-root",
      rebase_path(first_party_crate_root),
      "--third-party-deps-data",
      rebase_path(third_party_deps_data),
      "--out-info",
      rebase_path(out_info_path),
      "--version",
      version,
    ]
    if (with_lto != "none") {
      args += [ "--lto", with_lto ]
    }
    if (with_unit_tests) {
      args += [ "--with-unit-tests" ]
    }

    if (is_fuchsia) {
      deps += [
        "//garnet/public/sdk:zircon_sysroot_export",

        # These libraries are required by libstd.
        "//zircon/public/lib/backtrace",
        "//zircon/public/lib/fdio",
        "//zircon/public/lib/launchpad",
      ]
      args += [
        "--clang_prefix",
        rebase_path(clang_prefix, "", root_out_dir),
        "--sysroot",
        rebase_path("$root_out_dir/sdks/zircon_sysroot/sysroot"),
      ]
    }
    args += dep_info_paths
    outputs = [
      output_file,
    ]
    if (with_unit_tests) {
      outputs += [ test_output_file ]
    }
  }

  # Copy binaries and staticlibs out of rust_crates/* into the root dir
  # TODO(cramertj) remove and replace with writing directly to the root
  # dir once all existing build rules have moved off of using rust_crates/*
  if (type == "bin" || type == "staticlib") {
    copy_target_name = "${target_name}_copy"
    group_deps += [ ":${copy_target_name}" ]
    copy(copy_target_name) {
      deps = [
        ":${build_target_name}",
      ]
      sources = [
        output_file,
      ]
      outputs = [
        "${root_out_dir}/${prefix}${crate_name}${extension}",
      ]
    }
  }

  cargo_toml_target_name = "${target_name}_cargo"
  group_deps += [ ":${cargo_toml_target_name}" ]
  action(cargo_toml_target_name) {
    script = "//build/rust/write_cargo_toml.py"
    forward_variables_from(invoker,
                           [
                             "deps",
                             "testonly",
                           ])
    if (!defined(deps)) {
      deps = []
    }
    deps += [ third_party_build ]
    if (defined(invoker.non_rust_deps)) {
      public_deps = invoker.non_rust_deps
    }
    args = [
      "--out-dir",
      rebase_path(cargo_toml_dir),
      "--source-root",
      root_file,
      "--package-name",
      package_name,
      "--crate-name",
      crate_name,
      "--crate-type",
      type,
      "--version",
      version,
      "--third-party-deps-data",
      rebase_path(third_party_deps_data),
    ]

    # list of paths to info about crate dependencies
    args += dep_info_paths
    outputs = [
      "${cargo_toml_dir}/Cargo.toml",
    ]
  }

  group(target_name) {
    forward_variables_from(invoker, [ "testonly" ])
    public_deps = group_deps
  }
}