# Copyright 2020 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/rust/rustc_artifact.gni")

# Defines a Rust library that outputs a shared .wasm library file.
#
# Parameters
#
#   output_name (required)
#   name (required, deprecated)
#     Name of the crate as defined in its manifest file. If not specified, it is
#     assumed to be the same as the target name. All dashes will be replaced
#     with underscores in the library name: <name_underscored>
#
#     Note: This is required for now, see https://fxbug.dev/42179244.
#
#   edition
#     Edition of the Rust language to be used. See
#     https://doc.rust-lang.org/edition-guide/editions/index.html for more info on rust editions.
#
#   configs (optional)
#     A list of config labels applying to this target.
#
#   enforce_source_listing (optional)
#     When true, enforces that any source files used by the Rust compiler are
#     listed in `sources`. Defaults to true.
#
#   sources (optional)
#     List of source files which this crate is allowed to compile. Only
#     allowed when `enforce_source_listing = true`.
#     The Rust compiler discovers source files by following `mod` declarations
#     starting at the `source_root`. The discovered source files must match this
#     list.
#
#   inputs (optional)
#     List of additional non-source files read by the compiler. These are typically
#     configuration or test-data files included in the build with the `include_str!`
#     macro. Only allowed when `enforce_source_listing = true`.
#
#   deps (optional)
#     List of rust_library GN targets on which this crate depends.
#     Third party crates can be included through paths like
#     "//third_party/rust_crates:<cratename>",
#
#   source_root (optional)
#     Location of the crate root (e.g. `src/main.rs` or `src/lib.rs`).
#     This defaults to `./src/main.rs` for binaries and `./src/lib.rs` for libraries,
#     and should only be changed when absolutely necessary
#     (such as in the case of generated code).
#
#   features (optional)
#     A list of conditional compilation flags to enable. This can be used to set features for crates
#     built in-tree which are also published to crates.io. This would be passed to rustc as
#     '--cfg feature="XXX"'
#
#   rustenv (optional)
#     A list of environment variables that will be set when running the rust
#     compiler. These can be accessed at compile time with
#     [`std::env!`](https://doc.rust-lang.org/stable/std/macro.env.html)
#
#   output_dir (optional)
#     Directory that the resulting library should be placed in.
#     See: `gn help output_dir`
#
#   disable_rbe (optional)
#     Set to true to force this target to build locally, overriding the global
#     `rust_rbe_enable`.
#
#   disable_clippy (optional)
#     Don't run clippy on this target.
#
#   original_target_name (optional)
#     The name of the target as it appears in the BUILD file. Enables tooling
#     to find the template invocation in a BUILD file where this target was defined.
#
# Example of usage:
#   if (current_toolchain == unknown_wasm32_toolchain) {
#     rustc_wasm_library("foo-bar") {
#       deps = [
#         "//garnet/public/rust/bar",
#         "//third_party/rust_crates:argh",
#         "//third_party/rust_crates:serde",
#         "//third_party/rust_crates:slab",
#       ]
#       sources = [ "src/lib.rs" ]
#     }
#   }
#
# Example of using the outputs of the above:
#
#   test_package("foo-bar-tests") {
#     deps = [
#       ":foo-bar_test",
#     ]
#
#    tests = [
#      {
#        name = "foo_bar_lib_test($unknown_wasm32_toolchain)"
#      }
#    ]
#
template("rustc_wasm_library") {
  assert(!(defined(invoker.output_name) && defined(invoker.name)),
         "Only one of output_name and name may be specified.")
  assert(defined(invoker.output_name) || defined(invoker.name),
         "output_name must be specified for WASM libraries.")
  package_name = target_name
  if (defined(invoker.output_name)) {
    package_name = invoker.output_name
  } else if (defined(invoker.name)) {
    package_name = invoker.name
  }
  crate_name = string_replace(package_name, "-", "_")
  if (defined(invoker.original_target_name)) {
    _original_target_name = invoker.original_target_name
  } else {
    _original_target_name = target_name
  }

  if (defined(invoker.source_root)) {
    source_root = invoker.source_root
  } else {
    source_root = "src/lib.rs"
  }

  rustc_artifact(target_name) {
    target_type = "shared_library"
    crate_root = source_root
    clippy_crate_type = "cdylib"
    crate_name = crate_name
    original_target_name = _original_target_name
    pass_through = {
      forward_variables_from(invoker, [ "output_dir" ])
      output_name = crate_name
      crate_type = "cdylib"
    }

    assert(
        current_toolchain == unknown_wasm32_toolchain,
        "This library can only be compiled using toolchain ($unknown_wasm32_toolchain).")

    configs = []
    configs = invoker.configs

    deps = []
    if (defined(invoker.deps)) {
      deps += invoker.deps
    }

    forward_variables_from(invoker,
                           [
                             "disable_clippy",
                             "edition",
                             "enforce_source_listing",
                             "features",
                             "inputs",
                             "rustenv",
                             "sources",
                             "testonly",
                             "visibility",
                           ])
  }
}