blob: 463f5dda79dd0857767ff6b332348f41ab23b921 [file]
# 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/rust/rustc_artifact.gni")
import("//build/rust/rustc_test.gni")
# Defines a Rust static library
#
# Parameters
#
# output_name (optional)
# Name of the output archive file (without `lib` prefix or `.a` suffix).
#
# crate_name (optional)
# Name of the Rust crate passed to rustc (`--crate-name`). If not
# specified, defaults to `name` if set, or the target name. Synchronized
# from Bazel's `crate_name` by bazel2gn.
# Cannot be specified together with `name`.
#
# name (optional, 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.
#
# version
# Semver version of the crate as seen on crates.io.
#
# 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.
#
# test_configs (optional)
# A list of config labels applying to the test target, in addition to those in `configs`.
#
# test_visibility (optional)
# An override for the visibility setting for the generated test target when there is one.
#
# 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>",
#
# test_deps (optional)
# List of rust_library GN targets on which this crate's tests depend in addition to those in
# `deps`.
#
# non_test_deps (optional)
# List of rust_library GN targets on which this crate depends but not its
# tests. This can be used to replace a dependency between the test and
# library targets. It's an error to provide this when with_unit_tests is
# false.
#
# non_rust_deps (optional)
# List of non-rust_library GN targets on which this crate depends.
# Obsolete. Please use deps instead.
#
# data_deps (optional)
# List of GN targets that are only needed at runtime.
#
# with_unit_tests (optional)
# Builds unit tests associated with the binary. This will create a
# `<name>-bin-unit-test` test file in the output directory.
# Accepts a boolean or one of the following strings:
# "host": only define the test target in host toolchains (is_host).
# "fuchsia": only define the test target in Fuchsia toolchains
# (is_fuchsia).
# "both": define the test target in host and Fuchsia toolchains
# (is_host || is_fuchsia).
# `true` defines the test target in all toolchains.
#
# 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.
#
# quiet_clippy (boolean, optional)
# Passed through to rustc_artifact(), see that template for documentation.
#
# disable_rustdoc (optional)
# Don't add this target to https://fuchsia.dev/go/rustdoc
#
# rustflags (optional)
# Extra rust compiler flags passed directly to rustc.
#
# check_cfgs (optional)
# A list of valid configurations for the target.
# Passed to rustc as '--check-cfg=cfg(###)'.
#
# lint_config (optional)
# Label of a config with target-specific Rust lints, appended on top of the
# lint configs applied to every Rust target.
#
# public (optional)
# List of C/C++ header files exposed to dependents of this static library.
#
# validations (optional)
# List of validation targets to run whenever this target is built.
#
# proc_macro_deps (optional)
# List of Rust procedural macro dependencies, built in `$host_toolchain`.
#
# link_deps (optional)
# List of native (e.g. C/C++) libraries to link against.
#
# assert_no_deps (optional)
# Ensure no deps on these targets.
#
# pool (optional)
# Pool label to use when compiling 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.
#
# dynamic_libstd (optional)
# Specifies that the Rust standard library will be dynamically linked.
# Defaults to true.
#
# Example of usage:
#
# rustc_staticlib("foo") {
# deps = [
# "//garnet/public/rust/bar",
# "//third_party/rust_crates:argh",
# "//third_party/rust_crates:serde",
# "//third_party/rust_crates:slab",
# ]
# with_unit_tests = true
# sources = [ "src/lib.rs" ]
# }
template("rustc_staticlib") {
if (defined(invoker.original_target_name)) {
_original_target_name = invoker.original_target_name
} else {
_original_target_name = target_name
}
not_needed(invoker, [ "version" ])
assert(!(defined(invoker.output_name) && defined(invoker.name)),
"Only one of output_name and name may be specified.")
assert(!(defined(invoker.name) && defined(invoker.crate_name)),
"Only one of name and crate_name may be specified.")
_crate_name = target_name
if (defined(invoker.name)) {
_crate_name = invoker.name
}
if (defined(invoker.crate_name)) {
_crate_name = invoker.crate_name
}
_base_output_name = _crate_name
if (defined(invoker.output_name)) {
_base_output_name = invoker.output_name
}
# Resolve `with_unit_tests`, which may be a boolean or one of "host",
# "fuchsia", or "both". See https://fxbug.dev/515405864.
#
# _with_unit_tests: whether unit tests are requested in any toolchain.
# _generate_unit_tests: whether to define the test target in this toolchain.
_with_unit_tests = false
_generate_unit_tests = false
if (defined(invoker.with_unit_tests)) {
_with_unit_tests_value = invoker.with_unit_tests
if (_with_unit_tests_value == true) {
# Legacy boolean: define the test target in all toolchains.
_with_unit_tests = true
_generate_unit_tests = true
} else if (_with_unit_tests_value == "both") {
_with_unit_tests = true
_generate_unit_tests = is_host || is_fuchsia
} else if (_with_unit_tests_value == "host") {
_with_unit_tests = true
_generate_unit_tests = is_host
} else if (_with_unit_tests_value == "fuchsia") {
_with_unit_tests = true
_generate_unit_tests = is_fuchsia
} else {
assert(_with_unit_tests_value == false,
"with_unit_tests must be a boolean or one of \"host\", " +
"\"fuchsia\", \"both\", got: ${_with_unit_tests_value}")
}
}
# If requested for the current toolchain, generate an additional rust test
# target.
if (_generate_unit_tests) {
rustc_test_internal("${target_name}_test") {
original_target_name = target_name
deps = []
forward_variables_from(invoker,
"*",
[
"assert_no_deps",
"crate_name",
"disable_rustdoc",
"dynamic_libstd",
"name",
"non_test_deps",
"output_name",
"public",
"test_configs",
"test_deps",
"test_disable_rbe",
"validations",
])
if (defined(invoker.test_disable_rbe)) {
disable_rbe = invoker.test_disable_rbe
}
# Use a different visibility for this test target if specified.
if (defined(test_visibility)) {
visibility = []
visibility = test_visibility
}
output_name = _base_output_name + "_staticlib_test"
if (defined(invoker.test_configs)) {
configs += invoker.test_configs
}
if (defined(invoker.test_deps)) {
deps += invoker.test_deps
}
}
} else if (_with_unit_tests) {
# Unit tests are requested, but not for the current toolchain.
not_needed(invoker,
[
"args",
"exclude_toolchain_tags",
"package_deps",
"test_build_only",
"test_configs",
"test_deps",
"test_disable_rbe",
"test_environments",
"test_vars",
"test_visibility",
])
}
group_target = target_name
rustc_target = "_${_base_output_name}_rustc_static"
rustc_target = string_replace(rustc_target, "-", "_")
if (!defined(invoker.source_root)) {
source_root = "src/lib.rs"
} else {
source_root = invoker.source_root
}
rustc_artifact(rustc_target) {
forward_variables_from(invoker,
[
"allow_legacy_edition",
"assert_no_deps",
"check_cfgs",
"disable_clippy",
"disable_rbe",
"disable_rustdoc",
"edition",
"enforce_source_listing",
"features",
"inputs",
"link_deps",
"lint_config",
"output_dir",
"pool",
"proc_macro_deps",
"quiet_clippy",
"rustenv",
"sources",
"testonly",
"validations",
"visibility",
])
target_type = "static_library"
crate_root = source_root
crate_type = "staticlib"
crate_name = _crate_name
output_name = rustc_target
original_target_name = _original_target_name
deps = []
if (defined(invoker.deps)) {
deps += invoker.deps
}
if (defined(invoker.non_test_deps)) {
assert(_with_unit_tests, "use deps if not generating unit tests")
deps += invoker.non_test_deps
}
# TODO(https://fxbug.dev/42120123) remove "non_rust_deps"
if (defined(invoker.non_rust_deps)) {
deps += invoker.non_rust_deps
}
rustflags = []
if (defined(invoker.rustflags)) {
rustflags += invoker.rustflags
}
_dynamic_libstd = true
if (defined(invoker.dynamic_libstd)) {
_dynamic_libstd = invoker.dynamic_libstd
}
if (_dynamic_libstd && is_fuchsia && zircon_toolchain == false) {
rustflags += [
# This nightly flag is needed to support having dylibs in this target's
# dependencies or transitive dependencies.
"-Zstaticlib-allow-rdylib-deps",
# This nightly flag says when both rlib and dylibs are available, prefer
# dylibs. This seems to only affect Rust stdlib for now.
#
# Only set this when targeting Fuchsia, so host binaries still
# statically link Rust stdlib, making them easier to execute, i.e users
# don't need to provide Rust libstd.so.
"-Zstaticlib-prefer-dynamic",
]
# Rust libstd is linked dynamically, so make sure all dependents of this
# target have libstd in ldflags. This is necessary because static
# libraries are later consumed by non-Rust targets.
all_dependent_configs = [ "//build/config/rust:rust-libstd-so-ldflags" ]
# Rust libstd requires fdio.
public_deps = [ "//sdk/lib/fdio" ]
# libstd deps needs to be picked up by distribution entries.
data_deps = [ "//build/toolchain/runtime:shared-rust-libstd-deps" ]
}
configs = []
configs = invoker.configs
metadata = {
if (defined(invoker.disable_rustdoc)) {
disable_rustdoc = [ invoker.disable_rustdoc ]
}
}
}
public_hdrs = []
if (defined(invoker.public)) {
public_hdrs += invoker.public
}
header_target = "_${rustc_target}_staticlib_headers"
source_set(header_target) {
forward_variables_from(invoker, [ "testonly" ])
public = public_hdrs
visibility = [ ":${group_target}" ]
deps = []
if (defined(invoker.non_rust_deps)) {
# TODO(https://fxbug.dev/42120123): This allows propagating non rust dependencies through a
# single level of indirection, but does not handle propagating
# dependencies through an intermediate Rust target.
deps += invoker.non_rust_deps
}
}
group(group_target) {
forward_variables_from(invoker,
[
"assert_no_deps",
"data_deps",
"testonly",
"visibility",
])
public_deps = [
":$header_target",
":$rustc_target",
]
}
}