Rust rules
- CrateInfo
- DepInfo
- StdLibInfo
- capture_clippy_output
- cargo_bootstrap_repository
- cargo_build_script
- cargo_dep_env
- cargo_env
- error_format
- extra_rustc_flag
- extra_rustc_flags
- fail_when_enabled
- incompatible_flag
- rules_rust_dependencies
- rust_analyzer_aspect
- rust_analyzer_toolchain
- rust_analyzer_toolchain_repository
- rust_binary
- rust_clippy
- rust_clippy_aspect
- rust_doc
- rust_doc_test
- rust_library
- rust_library_group
- rust_proc_macro
- rust_register_toolchains
- rust_repositories
- rust_repository_set
- rust_shared_library
- rust_static_library
- rust_stdlib_filegroup
- rust_test
- rust_test_suite
- rust_toolchain
- rust_toolchain_repository
- rust_toolchain_repository_proxy
- rust_toolchain_tools_repository
- rustfmt_aspect
- rustfmt_test
- rustfmt_toolchain
capture_clippy_output
capture_clippy_output(name)
Control whether to print clippy output or store it to a file, using the configured error_format.
ATTRIBUTES
| Name | Description | Type | Mandatory | Default |
|---|---|---|---|---|
| name | A unique name for this target. | Name | required |
cargo_dep_env
cargo_dep_env(name, src, out_dir)
A rule for generating variables for dependent cargo_build_scripts without a build script. This is useful for using Bazel rules instead of a build script, while also generating configuration information for build scripts which depend on this crate.
ATTRIBUTES
| Name | Description | Type | Mandatory | Default |
|---|---|---|---|---|
| name | A unique name for this target. | Name | required | |
| src | File containing additional environment variables to set for build scripts of direct dependencies. This has the same effect as a cargo_build_script which prints cargo:VAR=VALUE lines, but without requiring a build script.This files should contain a single variable per line, of format NAME=value, and newlines may be included in a value by ending a line with a trailing back-slash (\\). | Label | required | |
| out_dir | Folder containing additional inputs when building all direct dependencies. This has the same effect as a cargo_build_script which prints puts files into $OUT_DIR, but without requiring a build script. | Label | optional | None |
error_format
error_format(name)
Change the --error-format flag from the command line with --@rules_rust//rust/settings:error_format. See rustc documentation for valid values.
ATTRIBUTES
| Name | Description | Type | Mandatory | Default |
|---|---|---|---|---|
| name | A unique name for this target. | Name | required |
extra_rustc_flag
extra_rustc_flag(name)
Add additional rustc_flag from the command line with --@rules_rust//rust/settings:extra_rustc_flag. Multiple uses are accumulated and appended after the extra_rustc_flags.
ATTRIBUTES
| Name | Description | Type | Mandatory | Default |
|---|---|---|---|---|
| name | A unique name for this target. | Name | required |
extra_rustc_flags
extra_rustc_flags(name)
Add additional rustc_flags from the command line with --@rules_rust//rust/settings:extra_rustc_flags. This flag should only be used for flags that need to be applied across the entire build. For options that apply to individual crates, use the rustc_flags attribute on the individual crate's rule instead. NOTE: These flags not applied to the exec configuration (proc-macros, cargo_build_script, etc); use --@rules_rust//rust/settings:extra_exec_rustc_flags to apply flags to the exec configuration.
ATTRIBUTES
| Name | Description | Type | Mandatory | Default |
|---|---|---|---|---|
| name | A unique name for this target. | Name | required |
incompatible_flag
incompatible_flag(name, issue)
A rule defining an incompatible flag.
ATTRIBUTES
| Name | Description | Type | Mandatory | Default |
|---|---|---|---|---|
| name | A unique name for this target. | Name | required | |
| issue | The link to the github issue associated with this flag | String | required |
rust_analyzer_toolchain
rust_analyzer_toolchain(name, proc_macro_srv, rustc, rustc_srcs)
A toolchain for rust-analyzer.
ATTRIBUTES
| Name | Description | Type | Mandatory | Default |
|---|---|---|---|---|
| name | A unique name for this target. | Name | required | |
| proc_macro_srv | The path to a rust_analyzer_proc_macro_srv binary. | Label | optional | None |
| rustc | The path to a rustc binary. | Label | required | |
| rustc_srcs | The source code of rustc. | Label | required |
rust_binary
rust_binary(name, deps, srcs, data, aliases, alwayslink, binary_name, compile_data, crate_features, crate_name, crate_root, crate_type, edition, env, experimental_use_cc_common_link, linker_script, malloc, out_binary, platform, proc_macro_deps, rustc_env, rustc_env_files, rustc_flags, stamp, version)
Builds a Rust binary crate.
Example:
Suppose you have the following directory structure for a Rust project with a
library crate, hello_lib, and a binary crate, hello_world that uses the
hello_lib library:
[workspace]/
WORKSPACE
hello_lib/
BUILD
src/
lib.rs
hello_world/
BUILD
src/
main.rs
hello_lib/src/lib.rs:
#![allow(unused)] fn main() { pub struct Greeter { greeting: String, } impl Greeter { pub fn new(greeting: &str) -> Greeter { Greeter { greeting: greeting.to_string(), } } pub fn greet(&self, thing: &str) { println!("{} {}", &self.greeting, thing); } } }
hello_lib/BUILD:
package(default_visibility = ["//visibility:public"])
load("@rules_rust//rust:defs.bzl", "rust_library")
rust_library(
name = "hello_lib",
srcs = ["src/lib.rs"],
)
hello_world/src/main.rs:
extern crate hello_lib; fn main() { let hello = hello_lib::Greeter::new("Hello"); hello.greet("world"); }
hello_world/BUILD:
load("@rules_rust//rust:defs.bzl", "rust_binary")
rust_binary(
name = "hello_world",
srcs = ["src/main.rs"],
deps = ["//hello_lib"],
)
Build and run hello_world:
$ bazel run //hello_world
INFO: Found 1 target...
Target //examples/rust/hello_world:hello_world up-to-date:
bazel-bin/examples/rust/hello_world/hello_world
INFO: Elapsed time: 1.308s, Critical Path: 1.22s
INFO: Running command line: bazel-bin/examples/rust/hello_world/hello_world
Hello world
On Windows, a PDB file containing debugging information is available under
the key pdb_file in OutputGroupInfo. Similarly on macOS, a dSYM folder
is available under the key dsym_folder in OutputGroupInfo.
ATTRIBUTES
| Name | Description | Type | Mandatory | Default |
|---|---|---|---|---|
| name | A unique name for this target. | Name | required | |
| deps | List of other libraries to be linked to this library target. These can be either other rust_library targets or cc_library targets if linking a native library. | List of labels | optional | [] |
| srcs | List of Rust .rs source files used to build the library.If srcs contains more than one file, then there must be a file either named lib.rs. Otherwise, crate_root must be set to the source file that is the root of the crate to be passed to rustc to build this crate. | List of labels | optional | [] |
| data | List of files used by this rule at compile time and runtime. If including data at compile time with include_str!() and similar, prefer compile_data over data, to prevent the data also being included in the runfiles. | List of labels | optional | [] |
| aliases | Remap crates to a new name or moniker for linkage to this target These are other rust_library targets and will be presented as the new name given. | Dictionary: Label -> String | optional | {} |
| alwayslink | If 1, any binary that depends (directly or indirectly) on this library will link in all the object files even if some contain no symbols referenced by the binary. This attribute is used by the C++ Starlark API when passing CcInfo providers. | Boolean | optional | False |
| binary_name | Override the resulting binary file name. By default, the binary file will be named using the name attribute on this rule, however sometimes that is not deseriable. | String | optional | "" |
| compile_data | List of files used by this rule at compile time. This attribute can be used to specify any data files that are embedded into the library, such as via the include_str! macro. | List of labels | optional | [] |
| crate_features | List of features to enable for this crate. Features are defined in the code using the #[cfg(feature = "foo")] configuration option. The features listed here will be passed to rustc with --cfg feature="${feature_name}" flags. | List of strings | optional | [] |
| crate_name | Crate name to use for this target. This must be a valid Rust identifier, i.e. it may contain only alphanumeric characters and underscores. Defaults to the target name, with any hyphens replaced by underscores. | String | optional | "" |
| crate_root | The file that will be passed to rustc to be used for building this crate.If crate_root is not set, then this rule will look for a lib.rs file (or main.rs for rust_binary) or the single file in srcs if srcs contains only one file. | Label | optional | None |
| crate_type | Crate type that will be passed to rustc to be used for building this crate.This option is a temporary workaround and should be used only when building for WebAssembly targets (//rust/platform:wasi and //rust/platform:wasm). | String | optional | "bin" |
| edition | The rust edition to use for this crate. Defaults to the edition specified in the rust_toolchain. | String | optional | "" |
| env | Specifies additional environment variables to set when the target is executed by bazel run. Values are subject to $(rootpath), $(execpath), location, and "Make variable" substitution.Execpath returns absolute path, and in order to be able to construct the absolute path we need to wrap the test binary in a launcher. Using a launcher comes with complications, such as more complicated debugger attachment. | Dictionary: String -> String | optional | {} |
| experimental_use_cc_common_link | Whether to use cc_common.link to link rust binaries. Possible values: [-1, 0, 1]. -1 means use the value of the toolchain.experimental_use_cc_common_link boolean build setting to determine. 0 means do not use cc_common.link (use rustc instead). 1 means use cc_common.link. | Integer | optional | -1 |
| linker_script | Link script to forward into linker via rustc options. | Label | optional | None |
| malloc | Override the default dependency on malloc.By default, Rust binaries linked with cc_common.link are linked against @bazel_tools//tools/cpp:malloc", which is an empty library and the resulting binary will use libc's malloc. This label must refer to a cc_library rule. | Label | optional | "@bazel_tools//tools/cpp:malloc" |
| out_binary | Force a target, regardless of it's crate_type, to always mark the file as executable. This attribute is only used to support wasm targets but is expected to be removed following a resolution to https://github.com/bazelbuild/rules_rust/issues/771. | Boolean | optional | False |
| platform | Optional platform to transition the binary to. | Label | optional | None |
| proc_macro_deps | List of rust_proc_macro targets used to help build this library target. | List of labels | optional | [] |
| rustc_env | Dictionary of additional "key": "value" environment variables to set for rustc.rust_test()/rust_binary() rules can use $(rootpath //package:target) to pass in the location of a generated file or external tool. Cargo build scripts that wish to expand locations should use cargo_build_script()'s build_script_env argument instead, as build scripts are run in a different environment - see cargo_build_script()'s documentation for more. | Dictionary: String -> String | optional | {} |
| rustc_env_files | Files containing additional environment variables to set for rustc. These files should contain a single variable per line, of format NAME=value, and newlines may be included in a value by ending a line with a trailing back-slash (\\).The order that these files will be processed is unspecified, so multiple definitions of a particular variable are discouraged. Note that the variables here are subject to workspace status stamping should the stamp attribute be enabled. Stamp variables should be wrapped in brackets in order to be resolved. E.g. NAME={WORKSPACE_STATUS_VARIABLE}. | List of labels | optional | [] |
| rustc_flags | List of compiler flags passed to rustc.These strings are subject to Make variable expansion for predefined source/output path variables like $location, $execpath, and $rootpath. This expansion is useful if you wish to pass a generated file of arguments to rustc: @$(location //package:target). | List of strings | optional | [] |
| stamp | Whether to encode build information into the Rustc action. Possible values:- stamp = 1: Always stamp the build information into the Rustc action, even in --nostamp builds. This setting should be avoided, since it potentially kills remote caching for the target and any downstream actions that depend on it.- stamp = 0: Always replace build information by constant values. This gives good build result caching.- stamp = -1: Embedding of build information is controlled by the --[no]stamp flag.Stamped targets are not rebuilt unless their dependencies change. For example if a rust_library is stamped, and a rust_binary depends on that library, the stamped library won't be rebuilt when we change sources of the rust_binary. This is different from how cc_library.linkstamps behaves. | Integer | optional | -1 |
| version | A version to inject in the cargo environment variable. | String | optional | "0.0.0" |
rust_clippy
rust_clippy(name, deps)
Executes the clippy checker on a specific target.
Similar to rust_clippy_aspect, but allows specifying a list of dependencies within the build system.
For example, given the following example targets:
load("@rules_rust//rust:defs.bzl", "rust_library", "rust_test")
rust_library(
name = "hello_lib",
srcs = ["src/lib.rs"],
)
rust_test(
name = "greeting_test",
srcs = ["tests/greeting.rs"],
deps = [":hello_lib"],
)
Rust clippy can be set as a build target with the following:
load("@rules_rust//rust:defs.bzl", "rust_clippy")
rust_clippy(
name = "hello_library_clippy",
testonly = True,
deps = [
":hello_lib",
":greeting_test",
],
)
ATTRIBUTES
| Name | Description | Type | Mandatory | Default |
|---|---|---|---|---|
| name | A unique name for this target. | Name | required | |
| deps | Rust targets to run clippy on. | List of labels | optional | [] |
rust_doc
rust_doc(name, crate, html_after_content, html_before_content, html_in_header, markdown_css, rustc_flags, rustdoc_flags)
Generates code documentation.
Example: Suppose you have the following directory structure for a Rust library crate:
[workspace]/
WORKSPACE
hello_lib/
BUILD
src/
lib.rs
To build rustdoc documentation for the hello_lib crate, define a rust_doc rule that depends on the the hello_lib rust_library target:
package(default_visibility = ["//visibility:public"])
load("@rules_rust//rust:defs.bzl", "rust_library", "rust_doc")
rust_library(
name = "hello_lib",
srcs = ["src/lib.rs"],
)
rust_doc(
name = "hello_lib_doc",
crate = ":hello_lib",
)
Running bazel build //hello_lib:hello_lib_doc will build a zip file containing the documentation for the hello_lib library crate generated by rustdoc.
ATTRIBUTES
| Name | Description | Type | Mandatory | Default |
|---|---|---|---|---|
| name | A unique name for this target. | Name | required | |
| crate | The label of the target to generate code documentation for.rust_doc can generate HTML code documentation for the source files of rust_library or rust_binary targets. | Label | required | |
| html_after_content | File to add in <body>, after content. | Label | optional | None |
| html_before_content | File to add in <body>, before content. | Label | optional | None |
| html_in_header | File to add to <head>. | Label | optional | None |
| markdown_css | CSS files to include via <link> in a rendered Markdown file. | List of labels | optional | [] |
| rustc_flags | Deprecated: use rustdoc_flags instead | List of strings | optional | [] |
| rustdoc_flags | List of flags passed to rustdoc.These strings are subject to Make variable expansion for predefined source/output path variables like $location, $execpath, and $rootpath. This expansion is useful if you wish to pass a generated file of arguments to rustc: @$(location //package:target). | List of strings | optional | [] |
rust_doc_test
rust_doc_test(name, deps, crate, proc_macro_deps)
Runs Rust documentation tests.
Example:
Suppose you have the following directory structure for a Rust library crate:
[workspace]/
WORKSPACE
hello_lib/
BUILD
src/
lib.rs
To run documentation tests for the hello_lib crate, define a rust_doc_test target that depends on the hello_lib rust_library target:
package(default_visibility = ["//visibility:public"])
load("@rules_rust//rust:defs.bzl", "rust_library", "rust_doc_test")
rust_library(
name = "hello_lib",
srcs = ["src/lib.rs"],
)
rust_doc_test(
name = "hello_lib_doc_test",
crate = ":hello_lib",
)
Running bazel test //hello_lib:hello_lib_doc_test will run all documentation tests for the hello_lib library crate.
ATTRIBUTES
| Name | Description | Type | Mandatory | Default |
|---|---|---|---|---|
| name | A unique name for this target. | Name | required | |
| deps | List of other libraries to be linked to this library target. These can be either other rust_library targets or cc_library targets if linking a native library. | List of labels | optional | [] |
| crate | The label of the target to generate code documentation for. rust_doc_test can generate HTML code documentation for the source files of rust_library or rust_binary targets. | Label | required | |
| proc_macro_deps | List of rust_proc_macro targets used to help build this library target. | List of labels | optional | [] |
rust_library
rust_library(name, deps, srcs, data, aliases, alwayslink, compile_data, crate_features, crate_name, crate_root, disable_pipelining, edition, proc_macro_deps, rustc_env, rustc_env_files, rustc_flags, stamp, version)
Builds a Rust library crate.
Example:
Suppose you have the following directory structure for a simple Rust library crate:
[workspace]/
WORKSPACE
hello_lib/
BUILD
src/
greeter.rs
lib.rs
hello_lib/src/greeter.rs:
#![allow(unused)] fn main() { pub struct Greeter { greeting: String, } impl Greeter { pub fn new(greeting: &str) -> Greeter { Greeter { greeting: greeting.to_string(), } } pub fn greet(&self, thing: &str) { println!("{} {}", &self.greeting, thing); } } }
hello_lib/src/lib.rs:
#![allow(unused)] fn main() { pub mod greeter; }
hello_lib/BUILD:
package(default_visibility = ["//visibility:public"])
load("@rules_rust//rust:defs.bzl", "rust_library")
rust_library(
name = "hello_lib",
srcs = [
"src/greeter.rs",
"src/lib.rs",
],
)
Build the library:
$ bazel build //hello_lib
INFO: Found 1 target...
Target //examples/rust/hello_lib:hello_lib up-to-date:
bazel-bin/examples/rust/hello_lib/libhello_lib.rlib
INFO: Elapsed time: 1.245s, Critical Path: 1.01s
ATTRIBUTES
| Name | Description | Type | Mandatory | Default |
|---|---|---|---|---|
| name | A unique name for this target. | Name | required | |
| deps | List of other libraries to be linked to this library target. These can be either other rust_library targets or cc_library targets if linking a native library. | List of labels | optional | [] |
| srcs | List of Rust .rs source files used to build the library.If srcs contains more than one file, then there must be a file either named lib.rs. Otherwise, crate_root must be set to the source file that is the root of the crate to be passed to rustc to build this crate. | List of labels | optional | [] |
| data | List of files used by this rule at compile time and runtime. If including data at compile time with include_str!() and similar, prefer compile_data over data, to prevent the data also being included in the runfiles. | List of labels | optional | [] |
| aliases | Remap crates to a new name or moniker for linkage to this target These are other rust_library targets and will be presented as the new name given. | Dictionary: Label -> String | optional | {} |
| alwayslink | If 1, any binary that depends (directly or indirectly) on this library will link in all the object files even if some contain no symbols referenced by the binary. This attribute is used by the C++ Starlark API when passing CcInfo providers. | Boolean | optional | False |
| compile_data | List of files used by this rule at compile time. This attribute can be used to specify any data files that are embedded into the library, such as via the include_str! macro. | List of labels | optional | [] |
| crate_features | List of features to enable for this crate. Features are defined in the code using the #[cfg(feature = "foo")] configuration option. The features listed here will be passed to rustc with --cfg feature="${feature_name}" flags. | List of strings | optional | [] |
| crate_name | Crate name to use for this target. This must be a valid Rust identifier, i.e. it may contain only alphanumeric characters and underscores. Defaults to the target name, with any hyphens replaced by underscores. | String | optional | "" |
| crate_root | The file that will be passed to rustc to be used for building this crate.If crate_root is not set, then this rule will look for a lib.rs file (or main.rs for rust_binary) or the single file in srcs if srcs contains only one file. | Label | optional | None |
| disable_pipelining | Disables pipelining for this rule if it is globally enabled. This will cause this rule to not produce a .rmeta file and all the dependent crates will instead use the .rlib file. | Boolean | optional | False |
| edition | The rust edition to use for this crate. Defaults to the edition specified in the rust_toolchain. | String | optional | "" |
| proc_macro_deps | List of rust_proc_macro targets used to help build this library target. | List of labels | optional | [] |
| rustc_env | Dictionary of additional "key": "value" environment variables to set for rustc.rust_test()/rust_binary() rules can use $(rootpath //package:target) to pass in the location of a generated file or external tool. Cargo build scripts that wish to expand locations should use cargo_build_script()'s build_script_env argument instead, as build scripts are run in a different environment - see cargo_build_script()'s documentation for more. | Dictionary: String -> String | optional | {} |
| rustc_env_files | Files containing additional environment variables to set for rustc. These files should contain a single variable per line, of format NAME=value, and newlines may be included in a value by ending a line with a trailing back-slash (\\).The order that these files will be processed is unspecified, so multiple definitions of a particular variable are discouraged. Note that the variables here are subject to workspace status stamping should the stamp attribute be enabled. Stamp variables should be wrapped in brackets in order to be resolved. E.g. NAME={WORKSPACE_STATUS_VARIABLE}. | List of labels | optional | [] |
| rustc_flags | List of compiler flags passed to rustc.These strings are subject to Make variable expansion for predefined source/output path variables like $location, $execpath, and $rootpath. This expansion is useful if you wish to pass a generated file of arguments to rustc: @$(location //package:target). | List of strings | optional | [] |
| stamp | Whether to encode build information into the Rustc action. Possible values:- stamp = 1: Always stamp the build information into the Rustc action, even in --nostamp builds. This setting should be avoided, since it potentially kills remote caching for the target and any downstream actions that depend on it.- stamp = 0: Always replace build information by constant values. This gives good build result caching.- stamp = -1: Embedding of build information is controlled by the --[no]stamp flag.Stamped targets are not rebuilt unless their dependencies change. For example if a rust_library is stamped, and a rust_binary depends on that library, the stamped library won't be rebuilt when we change sources of the rust_binary. This is different from how cc_library.linkstamps behaves. | Integer | optional | 0 |
| version | A version to inject in the cargo environment variable. | String | optional | "0.0.0" |
rust_library_group
rust_library_group(name, deps)
Functions as an alias for a set of dependencies.
Specifically, the following are equivalent:
rust_library_group(
name = "crate_group",
deps = [
":crate1",
":crate2",
],
)
rust_library(
name = "foobar",
deps = [":crate_group"],
...
)
and
rust_library(
name = "foobar",
deps = [
":crate1",
":crate2",
],
...
)
ATTRIBUTES
| Name | Description | Type | Mandatory | Default |
|---|---|---|---|---|
| name | A unique name for this target. | Name | required | |
| deps | Other dependencies to forward through this crate group. | List of labels | optional | [] |
rust_proc_macro
rust_proc_macro(name, deps, srcs, data, aliases, alwayslink, compile_data, crate_features, crate_name, crate_root, edition, proc_macro_deps, rustc_env, rustc_env_files, rustc_flags, stamp, version)
Builds a Rust proc-macro crate.
ATTRIBUTES
| Name | Description | Type | Mandatory | Default |
|---|---|---|---|---|
| name | A unique name for this target. | Name | required | |
| deps | List of other libraries to be linked to this library target. These can be either other rust_library targets or cc_library targets if linking a native library. | List of labels | optional | [] |
| srcs | List of Rust .rs source files used to build the library.If srcs contains more than one file, then there must be a file either named lib.rs. Otherwise, crate_root must be set to the source file that is the root of the crate to be passed to rustc to build this crate. | List of labels | optional | [] |
| data | List of files used by this rule at compile time and runtime. If including data at compile time with include_str!() and similar, prefer compile_data over data, to prevent the data also being included in the runfiles. | List of labels | optional | [] |
| aliases | Remap crates to a new name or moniker for linkage to this target These are other rust_library targets and will be presented as the new name given. | Dictionary: Label -> String | optional | {} |
| alwayslink | If 1, any binary that depends (directly or indirectly) on this library will link in all the object files even if some contain no symbols referenced by the binary. This attribute is used by the C++ Starlark API when passing CcInfo providers. | Boolean | optional | False |
| compile_data | List of files used by this rule at compile time. This attribute can be used to specify any data files that are embedded into the library, such as via the include_str! macro. | List of labels | optional | [] |
| crate_features | List of features to enable for this crate. Features are defined in the code using the #[cfg(feature = "foo")] configuration option. The features listed here will be passed to rustc with --cfg feature="${feature_name}" flags. | List of strings | optional | [] |
| crate_name | Crate name to use for this target. This must be a valid Rust identifier, i.e. it may contain only alphanumeric characters and underscores. Defaults to the target name, with any hyphens replaced by underscores. | String | optional | "" |
| crate_root | The file that will be passed to rustc to be used for building this crate.If crate_root is not set, then this rule will look for a lib.rs file (or main.rs for rust_binary) or the single file in srcs if srcs contains only one file. | Label | optional | None |
| edition | The rust edition to use for this crate. Defaults to the edition specified in the rust_toolchain. | String | optional | "" |
| proc_macro_deps | List of rust_proc_macro targets used to help build this library target. | List of labels | optional | [] |
| rustc_env | Dictionary of additional "key": "value" environment variables to set for rustc.rust_test()/rust_binary() rules can use $(rootpath //package:target) to pass in the location of a generated file or external tool. Cargo build scripts that wish to expand locations should use cargo_build_script()'s build_script_env argument instead, as build scripts are run in a different environment - see cargo_build_script()'s documentation for more. | Dictionary: String -> String | optional | {} |
| rustc_env_files | Files containing additional environment variables to set for rustc. These files should contain a single variable per line, of format NAME=value, and newlines may be included in a value by ending a line with a trailing back-slash (\\).The order that these files will be processed is unspecified, so multiple definitions of a particular variable are discouraged. Note that the variables here are subject to workspace status stamping should the stamp attribute be enabled. Stamp variables should be wrapped in brackets in order to be resolved. E.g. NAME={WORKSPACE_STATUS_VARIABLE}. | List of labels | optional | [] |
| rustc_flags | List of compiler flags passed to rustc.These strings are subject to Make variable expansion for predefined source/output path variables like $location, $execpath, and $rootpath. This expansion is useful if you wish to pass a generated file of arguments to rustc: @$(location //package:target). | List of strings | optional | [] |
| stamp | Whether to encode build information into the Rustc action. Possible values:- stamp = 1: Always stamp the build information into the Rustc action, even in --nostamp builds. This setting should be avoided, since it potentially kills remote caching for the target and any downstream actions that depend on it.- stamp = 0: Always replace build information by constant values. This gives good build result caching.- stamp = -1: Embedding of build information is controlled by the --[no]stamp flag.Stamped targets are not rebuilt unless their dependencies change. For example if a rust_library is stamped, and a rust_binary depends on that library, the stamped library won't be rebuilt when we change sources of the rust_binary. This is different from how cc_library.linkstamps behaves. | Integer | optional | 0 |
| version | A version to inject in the cargo environment variable. | String | optional | "0.0.0" |
rust_shared_library
rust_shared_library(name, deps, srcs, data, aliases, alwayslink, compile_data, crate_features, crate_name, crate_root, edition, experimental_use_cc_common_link, malloc, platform, proc_macro_deps, rustc_env, rustc_env_files, rustc_flags, stamp, version)
Builds a Rust shared library.
This shared library will contain all transitively reachable crates and native objects. It is meant to be used when producing an artifact that is then consumed by some other build system (for example to produce a shared library that Python program links against).
This rule provides CcInfo, so it can be used everywhere Bazel expects rules_cc.
When building the whole binary in Bazel, use rust_library instead.
ATTRIBUTES
| Name | Description | Type | Mandatory | Default |
|---|---|---|---|---|
| name | A unique name for this target. | Name | required | |
| deps | List of other libraries to be linked to this library target. These can be either other rust_library targets or cc_library targets if linking a native library. | List of labels | optional | [] |
| srcs | List of Rust .rs source files used to build the library.If srcs contains more than one file, then there must be a file either named lib.rs. Otherwise, crate_root must be set to the source file that is the root of the crate to be passed to rustc to build this crate. | List of labels | optional | [] |
| data | List of files used by this rule at compile time and runtime. If including data at compile time with include_str!() and similar, prefer compile_data over data, to prevent the data also being included in the runfiles. | List of labels | optional | [] |
| aliases | Remap crates to a new name or moniker for linkage to this target These are other rust_library targets and will be presented as the new name given. | Dictionary: Label -> String | optional | {} |
| alwayslink | If 1, any binary that depends (directly or indirectly) on this library will link in all the object files even if some contain no symbols referenced by the binary. This attribute is used by the C++ Starlark API when passing CcInfo providers. | Boolean | optional | False |
| compile_data | List of files used by this rule at compile time. This attribute can be used to specify any data files that are embedded into the library, such as via the include_str! macro. | List of labels | optional | [] |
| crate_features | List of features to enable for this crate. Features are defined in the code using the #[cfg(feature = "foo")] configuration option. The features listed here will be passed to rustc with --cfg feature="${feature_name}" flags. | List of strings | optional | [] |
| crate_name | Crate name to use for this target. This must be a valid Rust identifier, i.e. it may contain only alphanumeric characters and underscores. Defaults to the target name, with any hyphens replaced by underscores. | String | optional | "" |
| crate_root | The file that will be passed to rustc to be used for building this crate.If crate_root is not set, then this rule will look for a lib.rs file (or main.rs for rust_binary) or the single file in srcs if srcs contains only one file. | Label | optional | None |
| edition | The rust edition to use for this crate. Defaults to the edition specified in the rust_toolchain. | String | optional | "" |
| experimental_use_cc_common_link | Whether to use cc_common.link to link rust binaries. Possible values: [-1, 0, 1]. -1 means use the value of the toolchain.experimental_use_cc_common_link boolean build setting to determine. 0 means do not use cc_common.link (use rustc instead). 1 means use cc_common.link. | Integer | optional | -1 |
| malloc | Override the default dependency on malloc.By default, Rust binaries linked with cc_common.link are linked against @bazel_tools//tools/cpp:malloc", which is an empty library and the resulting binary will use libc's malloc. This label must refer to a cc_library rule. | Label | optional | "@bazel_tools//tools/cpp:malloc" |
| platform | Optional platform to transition the shared library to. | Label | optional | None |
| proc_macro_deps | List of rust_proc_macro targets used to help build this library target. | List of labels | optional | [] |
| rustc_env | Dictionary of additional "key": "value" environment variables to set for rustc.rust_test()/rust_binary() rules can use $(rootpath //package:target) to pass in the location of a generated file or external tool. Cargo build scripts that wish to expand locations should use cargo_build_script()'s build_script_env argument instead, as build scripts are run in a different environment - see cargo_build_script()'s documentation for more. | Dictionary: String -> String | optional | {} |
| rustc_env_files | Files containing additional environment variables to set for rustc. These files should contain a single variable per line, of format NAME=value, and newlines may be included in a value by ending a line with a trailing back-slash (\\).The order that these files will be processed is unspecified, so multiple definitions of a particular variable are discouraged. Note that the variables here are subject to workspace status stamping should the stamp attribute be enabled. Stamp variables should be wrapped in brackets in order to be resolved. E.g. NAME={WORKSPACE_STATUS_VARIABLE}. | List of labels | optional | [] |
| rustc_flags | List of compiler flags passed to rustc.These strings are subject to Make variable expansion for predefined source/output path variables like $location, $execpath, and $rootpath. This expansion is useful if you wish to pass a generated file of arguments to rustc: @$(location //package:target). | List of strings | optional | [] |
| stamp | Whether to encode build information into the Rustc action. Possible values:- stamp = 1: Always stamp the build information into the Rustc action, even in --nostamp builds. This setting should be avoided, since it potentially kills remote caching for the target and any downstream actions that depend on it.- stamp = 0: Always replace build information by constant values. This gives good build result caching.- stamp = -1: Embedding of build information is controlled by the --[no]stamp flag.Stamped targets are not rebuilt unless their dependencies change. For example if a rust_library is stamped, and a rust_binary depends on that library, the stamped library won't be rebuilt when we change sources of the rust_binary. This is different from how cc_library.linkstamps behaves. | Integer | optional | 0 |
| version | A version to inject in the cargo environment variable. | String | optional | "0.0.0" |
rust_static_library
rust_static_library(name, deps, srcs, data, aliases, alwayslink, compile_data, crate_features, crate_name, crate_root, edition, platform, proc_macro_deps, rustc_env, rustc_env_files, rustc_flags, stamp, version)
Builds a Rust static library.
This static library will contain all transitively reachable crates and native objects. It is meant to be used when producing an artifact that is then consumed by some other build system (for example to produce an archive that Python program links against).
This rule provides CcInfo, so it can be used everywhere Bazel expects rules_cc.
When building the whole binary in Bazel, use rust_library instead.
ATTRIBUTES
| Name | Description | Type | Mandatory | Default |
|---|---|---|---|---|
| name | A unique name for this target. | Name | required | |
| deps | List of other libraries to be linked to this library target. These can be either other rust_library targets or cc_library targets if linking a native library. | List of labels | optional | [] |
| srcs | List of Rust .rs source files used to build the library.If srcs contains more than one file, then there must be a file either named lib.rs. Otherwise, crate_root must be set to the source file that is the root of the crate to be passed to rustc to build this crate. | List of labels | optional | [] |
| data | List of files used by this rule at compile time and runtime. If including data at compile time with include_str!() and similar, prefer compile_data over data, to prevent the data also being included in the runfiles. | List of labels | optional | [] |
| aliases | Remap crates to a new name or moniker for linkage to this target These are other rust_library targets and will be presented as the new name given. | Dictionary: Label -> String | optional | {} |
| alwayslink | If 1, any binary that depends (directly or indirectly) on this library will link in all the object files even if some contain no symbols referenced by the binary. This attribute is used by the C++ Starlark API when passing CcInfo providers. | Boolean | optional | False |
| compile_data | List of files used by this rule at compile time. This attribute can be used to specify any data files that are embedded into the library, such as via the include_str! macro. | List of labels | optional | [] |
| crate_features | List of features to enable for this crate. Features are defined in the code using the #[cfg(feature = "foo")] configuration option. The features listed here will be passed to rustc with --cfg feature="${feature_name}" flags. | List of strings | optional | [] |
| crate_name | Crate name to use for this target. This must be a valid Rust identifier, i.e. it may contain only alphanumeric characters and underscores. Defaults to the target name, with any hyphens replaced by underscores. | String | optional | "" |
| crate_root | The file that will be passed to rustc to be used for building this crate.If crate_root is not set, then this rule will look for a lib.rs file (or main.rs for rust_binary) or the single file in srcs if srcs contains only one file. | Label | optional | None |
| edition | The rust edition to use for this crate. Defaults to the edition specified in the rust_toolchain. | String | optional | "" |
| platform | Optional platform to transition the static library to. | Label | optional | None |
| proc_macro_deps | List of rust_proc_macro targets used to help build this library target. | List of labels | optional | [] |
| rustc_env | Dictionary of additional "key": "value" environment variables to set for rustc.rust_test()/rust_binary() rules can use $(rootpath //package:target) to pass in the location of a generated file or external tool. Cargo build scripts that wish to expand locations should use cargo_build_script()'s build_script_env argument instead, as build scripts are run in a different environment - see cargo_build_script()'s documentation for more. | Dictionary: String -> String | optional | {} |
| rustc_env_files | Files containing additional environment variables to set for rustc. These files should contain a single variable per line, of format NAME=value, and newlines may be included in a value by ending a line with a trailing back-slash (\\).The order that these files will be processed is unspecified, so multiple definitions of a particular variable are discouraged. Note that the variables here are subject to workspace status stamping should the stamp attribute be enabled. Stamp variables should be wrapped in brackets in order to be resolved. E.g. NAME={WORKSPACE_STATUS_VARIABLE}. | List of labels | optional | [] |
| rustc_flags | List of compiler flags passed to rustc.These strings are subject to Make variable expansion for predefined source/output path variables like $location, $execpath, and $rootpath. This expansion is useful if you wish to pass a generated file of arguments to rustc: @$(location //package:target). | List of strings | optional | [] |
| stamp | Whether to encode build information into the Rustc action. Possible values:- stamp = 1: Always stamp the build information into the Rustc action, even in --nostamp builds. This setting should be avoided, since it potentially kills remote caching for the target and any downstream actions that depend on it.- stamp = 0: Always replace build information by constant values. This gives good build result caching.- stamp = -1: Embedding of build information is controlled by the --[no]stamp flag.Stamped targets are not rebuilt unless their dependencies change. For example if a rust_library is stamped, and a rust_binary depends on that library, the stamped library won't be rebuilt when we change sources of the rust_binary. This is different from how cc_library.linkstamps behaves. | Integer | optional | 0 |
| version | A version to inject in the cargo environment variable. | String | optional | "0.0.0" |
rust_stdlib_filegroup
rust_stdlib_filegroup(name, srcs)
A dedicated filegroup-like rule for Rust stdlib artifacts.
ATTRIBUTES
| Name | Description | Type | Mandatory | Default |
|---|---|---|---|---|
| name | A unique name for this target. | Name | required | |
| srcs | The list of targets/files that are components of the rust-stdlib file group | List of labels | required |
rust_test
rust_test(name, deps, srcs, data, aliases, alwayslink, compile_data, crate, crate_features, crate_name, crate_root, edition, env, env_inherit, experimental_use_cc_common_link, malloc, platform, proc_macro_deps, rustc_env, rustc_env_files, rustc_flags, stamp, use_libtest_harness, version)
Builds a Rust test crate.
Examples:
Suppose you have the following directory structure for a Rust library crate with unit test code in the library sources:
[workspace]/
WORKSPACE
hello_lib/
BUILD
src/
lib.rs
hello_lib/src/lib.rs:
#![allow(unused)] fn main() { pub struct Greeter { greeting: String, } impl Greeter { pub fn new(greeting: &str) -> Greeter { Greeter { greeting: greeting.to_string(), } } pub fn greet(&self, thing: &str) -> String { format!("{} {}", &self.greeting, thing) } } #[cfg(test)] mod test { use super::Greeter; #[test] fn test_greeting() { let hello = Greeter::new("Hi"); assert_eq!("Hi Rust", hello.greet("Rust")); } } }
To build and run the tests, simply add a rust_test rule with no srcs
and only depends on the hello_lib rust_library target via the
crate attribute:
hello_lib/BUILD:
load("@rules_rust//rust:defs.bzl", "rust_library", "rust_test")
rust_library(
name = "hello_lib",
srcs = ["src/lib.rs"],
)
rust_test(
name = "hello_lib_test",
crate = ":hello_lib",
# You may add other deps that are specific to the test configuration
deps = ["//some/dev/dep"],
)
Run the test with bazel test //hello_lib:hello_lib_test.
Example: test directory
Integration tests that live in the tests directory, they are essentially built as separate crates. Suppose you have the following directory structure where greeting.rs is an integration test for the hello_lib library crate:
[workspace]/
WORKSPACE
hello_lib/
BUILD
src/
lib.rs
tests/
greeting.rs
hello_lib/tests/greeting.rs:
#![allow(unused)] fn main() { extern crate hello_lib; use hello_lib; #[test] fn test_greeting() { let hello = greeter::Greeter::new("Hello"); assert_eq!("Hello world", hello.greeting("world")); } }
To build the greeting.rs integration test, simply add a rust_test target
with greeting.rs in srcs and a dependency on the hello_lib target:
hello_lib/BUILD:
load("@rules_rust//rust:defs.bzl", "rust_library", "rust_test")
rust_library(
name = "hello_lib",
srcs = ["src/lib.rs"],
)
rust_test(
name = "greeting_test",
srcs = ["tests/greeting.rs"],
deps = [":hello_lib"],
)
Run the test with bazel test //hello_lib:greeting_test.
ATTRIBUTES
| Name | Description | Type | Mandatory | Default |
|---|---|---|---|---|
| name | A unique name for this target. | Name | required | |
| deps | List of other libraries to be linked to this library target. These can be either other rust_library targets or cc_library targets if linking a native library. | List of labels | optional | [] |
| srcs | List of Rust .rs source files used to build the library.If srcs contains more than one file, then there must be a file either named lib.rs. Otherwise, crate_root must be set to the source file that is the root of the crate to be passed to rustc to build this crate. | List of labels | optional | [] |
| data | List of files used by this rule at compile time and runtime. If including data at compile time with include_str!() and similar, prefer compile_data over data, to prevent the data also being included in the runfiles. | List of labels | optional | [] |
| aliases | Remap crates to a new name or moniker for linkage to this target These are other rust_library targets and will be presented as the new name given. | Dictionary: Label -> String | optional | {} |
| alwayslink | If 1, any binary that depends (directly or indirectly) on this library will link in all the object files even if some contain no symbols referenced by the binary. This attribute is used by the C++ Starlark API when passing CcInfo providers. | Boolean | optional | False |
| compile_data | List of files used by this rule at compile time. This attribute can be used to specify any data files that are embedded into the library, such as via the include_str! macro. | List of labels | optional | [] |
| crate | Target inline tests declared in the given crate These tests are typically those that would be held out under #[cfg(test)] declarations. | Label | optional | None |
| crate_features | List of features to enable for this crate. Features are defined in the code using the #[cfg(feature = "foo")] configuration option. The features listed here will be passed to rustc with --cfg feature="${feature_name}" flags. | List of strings | optional | [] |
| crate_name | Crate name to use for this target. This must be a valid Rust identifier, i.e. it may contain only alphanumeric characters and underscores. Defaults to the target name, with any hyphens replaced by underscores. | String | optional | "" |
| crate_root | The file that will be passed to rustc to be used for building this crate.If crate_root is not set, then this rule will look for a lib.rs file (or main.rs for rust_binary) or the single file in srcs if srcs contains only one file. | Label | optional | None |
| edition | The rust edition to use for this crate. Defaults to the edition specified in the rust_toolchain. | String | optional | "" |
| env | Specifies additional environment variables to set when the test is executed by bazel test. Values are subject to $(rootpath), $(execpath), location, and "Make variable" substitution. | Dictionary: String -> String | optional | {} |
| env_inherit | Specifies additional environment variables to inherit from the external environment when the test is executed by bazel test. | List of strings | optional | [] |
| experimental_use_cc_common_link | Whether to use cc_common.link to link rust binaries. Possible values: [-1, 0, 1]. -1 means use the value of the toolchain.experimental_use_cc_common_link boolean build setting to determine. 0 means do not use cc_common.link (use rustc instead). 1 means use cc_common.link. | Integer | optional | -1 |
| malloc | Override the default dependency on malloc.By default, Rust binaries linked with cc_common.link are linked against @bazel_tools//tools/cpp:malloc", which is an empty library and the resulting binary will use libc's malloc. This label must refer to a cc_library rule. | Label | optional | "@bazel_tools//tools/cpp:malloc" |
| platform | Optional platform to transition the test to. | Label | optional | None |
| proc_macro_deps | List of rust_proc_macro targets used to help build this library target. | List of labels | optional | [] |
| rustc_env | Dictionary of additional "key": "value" environment variables to set for rustc.rust_test()/rust_binary() rules can use $(rootpath //package:target) to pass in the location of a generated file or external tool. Cargo build scripts that wish to expand locations should use cargo_build_script()'s build_script_env argument instead, as build scripts are run in a different environment - see cargo_build_script()'s documentation for more. | Dictionary: String -> String | optional | {} |
| rustc_env_files | Files containing additional environment variables to set for rustc. These files should contain a single variable per line, of format NAME=value, and newlines may be included in a value by ending a line with a trailing back-slash (\\).The order that these files will be processed is unspecified, so multiple definitions of a particular variable are discouraged. Note that the variables here are subject to workspace status stamping should the stamp attribute be enabled. Stamp variables should be wrapped in brackets in order to be resolved. E.g. NAME={WORKSPACE_STATUS_VARIABLE}. | List of labels | optional | [] |
| rustc_flags | List of compiler flags passed to rustc.These strings are subject to Make variable expansion for predefined source/output path variables like $location, $execpath, and $rootpath. This expansion is useful if you wish to pass a generated file of arguments to rustc: @$(location //package:target). | List of strings | optional | [] |
| stamp | Whether to encode build information into the Rustc action. Possible values:- stamp = 1: Always stamp the build information into the Rustc action, even in --nostamp builds. This setting should be avoided, since it potentially kills remote caching for the target and any downstream actions that depend on it.- stamp = 0: Always replace build information by constant values. This gives good build result caching.- stamp = -1: Embedding of build information is controlled by the --[no]stamp flag.Stamped targets are not rebuilt unless their dependencies change. For example if a rust_library is stamped, and a rust_binary depends on that library, the stamped library won't be rebuilt when we change sources of the rust_binary. This is different from how cc_library.linkstamps behaves. | Integer | optional | 0 |
| use_libtest_harness | Whether to use libtest. For targets using this flag, individual tests can be run by using the --test_arg flag. E.g. bazel test //src:rust_test --test_arg=foo::test::test_fn. | Boolean | optional | True |
| version | A version to inject in the cargo environment variable. | String | optional | "0.0.0" |
rust_toolchain
rust_toolchain(name, allocator_library, binary_ext, cargo, cargo_clippy, clippy_driver, debug_info, default_edition, dylib_ext, env, exec_triple, experimental_link_std_dylib, experimental_use_cc_common_link, extra_exec_rustc_flags, extra_rustc_flags, extra_rustc_flags_for_crate_types, global_allocator_library, llvm_cov, llvm_profdata, llvm_tools, opt_level, per_crate_rustc_flags, rust_doc, rust_std, rustc, rustc_lib, rustfmt, staticlib_ext, stdlib_linkflags, strip_level, target_json, target_triple)
Declares a Rust toolchain for use.
This is for declaring a custom toolchain, eg. for configuring a particular version of rust or supporting a new platform.
Example:
Suppose the core rust team has ported the compiler to a new target CPU, called cpuX. This support can be used in Bazel by defining a new toolchain definition and declaration:
load('@rules_rust//rust:toolchain.bzl', 'rust_toolchain')
rust_toolchain(
name = "rust_cpuX_impl",
binary_ext = "",
dylib_ext = ".so",
exec_triple = "cpuX-unknown-linux-gnu",
rust_doc = "@rust_cpuX//:rustdoc",
rust_std = "@rust_cpuX//:rust_std",
rustc = "@rust_cpuX//:rustc",
rustc_lib = "@rust_cpuX//:rustc_lib",
staticlib_ext = ".a",
stdlib_linkflags = ["-lpthread", "-ldl"],
target_triple = "cpuX-unknown-linux-gnu",
)
toolchain(
name = "rust_cpuX",
exec_compatible_with = [
"@platforms//cpu:cpuX",
"@platforms//os:linux",
],
target_compatible_with = [
"@platforms//cpu:cpuX",
"@platforms//os:linux",
],
toolchain = ":rust_cpuX_impl",
)
Then, either add the label of the toolchain rule to register_toolchains in the WORKSPACE, or pass it to the "--extra_toolchains" flag for Bazel, and it will be used.
See @rules_rust//rust:repositories.bzl for examples of defining the @rust_cpuX repository with the actual binaries and libraries.
ATTRIBUTES
| Name | Description | Type | Mandatory | Default |
|---|---|---|---|---|
| name | A unique name for this target. | Name | required | |
| allocator_library | Target that provides allocator functions when rust_library targets are embedded in a cc_binary. | Label | optional | "@rules_rust//ffi/cc/allocator_library" |
| binary_ext | The extension for binaries created from rustc. | String | required | |
| cargo | The location of the cargo binary. Can be a direct source or a filegroup containing one item. | Label | optional | None |
| cargo_clippy | The location of the cargo_clippy binary. Can be a direct source or a filegroup containing one item. | Label | optional | None |
| clippy_driver | The location of the clippy-driver binary. Can be a direct source or a filegroup containing one item. | Label | optional | None |
| debug_info | Rustc debug info levels per opt level | Dictionary: String -> String | optional | {"dbg": "2", "fastbuild": "0", "opt": "0"} |
| default_edition | The edition to use for rust_* rules that don't specify an edition. If absent, every rule is required to specify its edition attribute. | String | optional | "" |
| dylib_ext | The extension for dynamic libraries created from rustc. | String | required | |
| env | Environment variables to set in actions. | Dictionary: String -> String | optional | {} |
| exec_triple | The platform triple for the toolchains execution environment. For more details see: https://docs.bazel.build/versions/master/skylark/rules.html#configurations | String | required | |
| experimental_link_std_dylib | Label to a boolean build setting that controls whether whether to link libstd dynamically. | Label | optional | "@rules_rust//rust/settings:experimental_link_std_dylib" |
| experimental_use_cc_common_link | Label to a boolean build setting that controls whether cc_common.link is used to link rust binaries. | Label | optional | "@rules_rust//rust/settings:experimental_use_cc_common_link" |
| extra_exec_rustc_flags | Extra flags to pass to rustc in exec configuration | List of strings | optional | [] |
| extra_rustc_flags | Extra flags to pass to rustc in non-exec configuration. Subject to location expansion with respect to the srcs of the rust_std attribute. | List of strings | optional | [] |
| extra_rustc_flags_for_crate_types | Extra flags to pass to rustc based on crate type | Dictionary: String -> List of strings | optional | {} |
| global_allocator_library | Target that provides allocator functions for when a global allocator is present. | Label | optional | "@rules_rust//ffi/cc/global_allocator_library" |
| llvm_cov | The location of the llvm-cov binary. Can be a direct source or a filegroup containing one item. If None, rust code is not instrumented for coverage. | Label | optional | None |
| llvm_profdata | The location of the llvm-profdata binary. Can be a direct source or a filegroup containing one item. If llvm_cov is None, this can be None as well and rust code is not instrumented for coverage. | Label | optional | None |
| llvm_tools | LLVM tools that are shipped with the Rust toolchain. | Label | optional | None |
| opt_level | Rustc optimization levels. | Dictionary: String -> String | optional | {"dbg": "0", "fastbuild": "0", "opt": "3"} |
| per_crate_rustc_flags | Extra flags to pass to rustc in non-exec configuration | List of strings | optional | [] |
| rust_doc | The location of the rustdoc binary. Can be a direct source or a filegroup containing one item. | Label | required | |
| rust_std | The Rust standard library. | Label | required | |
| rustc | The location of the rustc binary. Can be a direct source or a filegroup containing one item. | Label | required | |
| rustc_lib | The libraries used by rustc during compilation. | Label | optional | None |
| rustfmt | Deprecated: Instead see rustfmt_toolchain | Label | optional | None |
| staticlib_ext | The extension for static libraries created from rustc. | String | required | |
| stdlib_linkflags | Additional linker flags to use when Rust standard library is linked by a C++ linker (rustc will deal with these automatically). Subject to location expansion with respect to the srcs of the rust_std attribute. | List of strings | required | |
| strip_level | Rustc strip levels. For all potential options, see https://doc.rust-lang.org/rustc/codegen-options/index.html#strip | Dictionary: String -> String | optional | {"dbg": "none", "fastbuild": "none", "opt": "debuginfo"} |
| target_json | Override the target_triple with a custom target specification. For more details see: https://doc.rust-lang.org/rustc/targets/custom.html | String | optional | "" |
| target_triple | The platform triple for the toolchains target environment. For more details see: https://docs.bazel.build/versions/master/skylark/rules.html#configurations | String | optional | "" |
rustfmt_test
rustfmt_test(name, targets)
A test rule for performing rustfmt --check on a set of targets
ATTRIBUTES
| Name | Description | Type | Mandatory | Default |
|---|---|---|---|---|
| name | A unique name for this target. | Name | required | |
| targets | Rust targets to run rustfmt --check on. | List of labels | optional | [] |
rustfmt_toolchain
rustfmt_toolchain(name, rustc, rustc_lib, rustfmt)
A toolchain for rustfmt
ATTRIBUTES
| Name | Description | Type | Mandatory | Default |
|---|---|---|---|---|
| name | A unique name for this target. | Name | required | |
| rustc | The location of the rustc binary. Can be a direct source or a filegroup containing one item. | Label | optional | None |
| rustc_lib | The libraries used by rustc during compilation. | Label | optional | None |
| rustfmt | The location of the rustfmt binary. Can be a direct source or a filegroup containing one item. | Label | required |
CrateInfo
CrateInfo(aliases, compile_data, compile_data_targets, data, deps, edition, is_test, metadata, name, output, owner, proc_macro_deps, root, rustc_env, rustc_env_files, rustc_output, rustc_rmeta_output, srcs, std_dylib, type, wrapped_crate_type)
A provider containing general Crate information.
FIELDS
| Name | Description |
|---|---|
| aliases | Dict[Label, String]: Renamed and aliased crates |
| compile_data | depset[File]: Compile data required by this crate. |
| compile_data_targets | depset[Label]: Compile data targets required by this crate. |
| data | depset[File]: Compile data required by crates that use the current crate as a proc-macro. |
| deps | depset[DepVariantInfo]: This crate's (rust or cc) dependencies' providers. |
| edition | str: The edition of this crate. |
| is_test | bool: If the crate is being compiled in a test context |
| metadata | File: The output from rustc from producing the output file. It is optional. |
| name | str: The name of this crate. |
| output | File: The output File that will be produced, depends on crate type. |
| owner | Label: The label of the target that produced this CrateInfo |
| proc_macro_deps | depset[DepVariantInfo]: This crate's rust proc_macro dependencies' providers. |
| root | File: The source File entrypoint to this crate, eg. lib.rs |
| rustc_env | Dict[String, String]: Additional "key": "value" environment variables to set for rustc. |
| rustc_env_files | [File]: Files containing additional environment variables to set for rustc. |
| rustc_output | File: The output from rustc from producing the output file. It is optional. |
| rustc_rmeta_output | File: The rmeta file produced for this crate. It is optional. |
| srcs | depset[File]: All source Files that are part of the crate. |
| std_dylib | File: libstd.so file |
| type | str: The type of this crate (see rustc --crate-type). |
| wrapped_crate_type | str, optional: The original crate type for targets generated using a previously defined crate (typically tests using the rust_test::crate attribute) |
DepInfo
DepInfo(dep_env, direct_crates, link_search_path_files, transitive_build_infos, transitive_crate_outputs, transitive_crates, transitive_data, transitive_metadata_outputs, transitive_noncrates, transitive_proc_macro_data)
A provider containing information about a Crate's dependencies.
FIELDS
StdLibInfo
StdLibInfo(alloc_files, between_alloc_and_core_files, between_core_and_std_files, core_files, dot_a_files, memchr_files, panic_files, self_contained_files, srcs, std_dylib, std_files, std_rlibs, test_files)
A collection of files either found within the rust-stdlib artifact or generated based on existing files.
FIELDS
cargo_build_script
cargo_build_script(name, edition, crate_name, crate_root, srcs, crate_features, version, deps, link_deps, proc_macro_deps, build_script_env, data, compile_data, tools, links, rundir, rustc_env, rustc_env_files, rustc_flags, visibility, tags, aliases, pkg_name, kwargs)
Compile and execute a rust build script to generate build attributes
This rules take the same arguments as rust_binary.
Example:
Suppose you have a crate with a cargo build script build.rs:
[workspace]/
hello_lib/
BUILD
build.rs
src/
lib.rs
Then you want to use the build script in the following:
hello_lib/BUILD:
package(default_visibility = ["//visibility:public"])
load("@rules_rust//rust:defs.bzl", "rust_binary", "rust_library")
load("@rules_rust//cargo:defs.bzl", "cargo_build_script")
# This will run the build script from the root of the workspace, and
# collect the outputs.
cargo_build_script(
name = "build_script",
srcs = ["build.rs"],
# Optional environment variables passed during build.rs compilation
rustc_env = {
"CARGO_PKG_VERSION": "0.1.2",
},
# Optional environment variables passed during build.rs execution.
# Note that as the build script's working directory is not execroot,
# execpath/location will return an absolute path, instead of a relative
# one.
build_script_env = {
"SOME_TOOL_OR_FILE": "$(execpath @tool//:binary)"
},
# Optional data/tool dependencies
data = ["@tool//:binary"],
)
rust_library(
name = "hello_lib",
srcs = [
"src/lib.rs",
],
deps = [":build_script"],
)
The hello_lib target will be build with the flags and the environment variables declared by the build script in addition to the file generated by it.
PARAMETERS
cargo_env
cargo_env(env)
A helper for generating platform specific environment variables
load("@rules_rust//rust:defs.bzl", "rust_common")
load("@rules_rust//cargo:defs.bzl", "cargo_bootstrap_repository", "cargo_env")
cargo_bootstrap_repository(
name = "bootstrapped_bin",
cargo_lockfile = "//:Cargo.lock",
cargo_toml = "//:Cargo.toml",
srcs = ["//:resolver_srcs"],
version = rust_common.default_version,
binary = "my-crate-binary",
env = {
"x86_64-unknown-linux-gnu": cargo_env({
"FOO": "BAR",
}),
},
env_label = {
"aarch64-unknown-linux-musl": cargo_env({
"DOC": "//:README.md",
}),
}
)
PARAMETERS
RETURNS
str: A json encoded string of the environment variables
rules_rust_dependencies
rules_rust_dependencies()
Dependencies used in the implementation of rules_rust.
rust_analyzer_toolchain_repository
rust_analyzer_toolchain_repository(name, version, exec_compatible_with, target_compatible_with, sha256s, urls, auth, netrc, auth_patterns)
Assemble a remote rust_analyzer_toolchain target based on the given params.
PARAMETERS
| Name | Description | Default Value |
|---|---|---|
| name | The name of the toolchain proxy repository contianing the registerable toolchain. | none |
| version | The version of the tool among "nightly", "beta', or an exact version. | none |
| exec_compatible_with | A list of constraints for the execution platform for this toolchain. | [] |
| target_compatible_with | A list of constraints for the target platform for this toolchain. | [] |
| sha256s | A dict associating tool subdirectories to sha256 hashes. See rust_register_toolchains for more details. | None |
| urls | A list of mirror urls containing the tools from the Rust-lang static file server. These must contain the '{}' used to substitute the tool being fetched (using .format). Defaults to ['https://static.rust-lang.org/dist/{}.tar.xz'] | None |
| auth | Auth object compatible with repository_ctx.download to use when downloading files. See repository_ctx.download for more details. | None |
| netrc | .netrc file to use for authentication; mirrors the eponymous attribute from http_archive | None |
| auth_patterns | Override mapping of hostnames to authorization patterns; mirrors the eponymous attribute from http_archive | None |
RETURNS
str: The name of a registerable rust_analyzer_toolchain.
rust_register_toolchains
rust_register_toolchains(dev_components, edition, allocator_library, global_allocator_library, register_toolchains, rustfmt_version, rust_analyzer_version, sha256s, extra_target_triples, extra_rustc_flags, extra_exec_rustc_flags, urls, versions, aliases, hub_name, compact_windows_names)
Emits a default set of toolchains for Linux, MacOS, and Freebsd
Skip this macro and call the rust_repository_set macros directly if you need a compiler for other hosts or for additional target triples.
The sha256s attribute represents a dict associating tool subdirectories to sha256 hashes. As an example:
{
"rust-1.46.0-x86_64-unknown-linux-gnu": "e3b98bc3440fe92817881933f9564389eccb396f5f431f33d48b979fa2fbdcf5",
"rustfmt-1.4.12-x86_64-unknown-linux-gnu": "1894e76913303d66bf40885a601462844eec15fca9e76a6d13c390d7000d64b0",
"rust-std-1.46.0-x86_64-unknown-linux-gnu": "ac04aef80423f612c0079829b504902de27a6997214eb58ab0765d02f7ec1dbc",
}
This would match for exec_triple = "x86_64-unknown-linux-gnu". If not specified, rules_rust pulls from a non-exhaustive list of known checksums..
See load_arbitrary_tool in @rules_rust//rust:repositories.bzl for more details.
PARAMETERS
rust_repositories
rust_repositories(kwargs)
Deprecated: Use rules_rust_dependencies and rust_register_toolchains directly.
PARAMETERS
rust_repository_set
rust_repository_set(name, versions, exec_triple, target_settings, allocator_library, global_allocator_library, extra_target_triples, rustfmt_version, edition, dev_components, extra_rustc_flags, extra_exec_rustc_flags, opt_level, sha256s, urls, auth, netrc, auth_patterns, register_toolchain, exec_compatible_with, default_target_compatible_with, aliases, compact_windows_names)
Assembles a remote repository for the given toolchain params, produces a proxy repository to contain the toolchain declaration, and registers the toolchains.
PARAMETERS
| Name | Description | Default Value |
|---|---|---|
| name | The name of the generated repository | none |
| versions | A list of toolchain versions to download. This paramter only accepts one versions per channel. E.g. ["1.65.0", "nightly/2022-11-02", "beta/2020-12-30"]. | none |
| exec_triple | The Rust-style target that this compiler runs on | none |
| target_settings | A list of config_settings that must be satisfied by the target configuration in order for this set of toolchains to be selected during toolchain resolution. | [] |
| allocator_library | Target that provides allocator functions when rust_library targets are embedded in a cc_binary. | None |
| global_allocator_library | Target that provides allocator functions a global allocator is used with cc_common.link. | None |
| extra_target_triples | Additional rust-style targets that this set of toolchains should support. If a map, values should be (optional) target_compatible_with lists for that particular target triple. | {} |
| rustfmt_version | The version of rustfmt to be associated with the toolchain. | None |
| edition | The rust edition to be used by default (2015, 2018, or 2021). If absent, every rule is required to specify its edition attribute. | None |
| dev_components | Whether to download the rustc-dev components. Requires version to be "nightly". | False |
| extra_rustc_flags | Dictionary of target triples to list of extra flags to pass to rustc in non-exec configuration. | None |
| extra_exec_rustc_flags | Extra flags to pass to rustc in exec configuration. | None |
| opt_level | Dictionary of target triples to optimiztion config. | None |
| sha256s | A dict associating tool subdirectories to sha256 hashes. See rust_register_toolchains for more details. | None |
| urls | A list of mirror urls containing the tools from the Rust-lang static file server. These must contain the '{}' used to substitute the tool being fetched (using .format). | ["https://static.rust-lang.org/dist/{}.tar.xz"] |
| auth | Auth object compatible with repository_ctx.download to use when downloading files. See repository_ctx.download for more details. | None |
| netrc | .netrc file to use for authentication; mirrors the eponymous attribute from http_archive | None |
| auth_patterns | Override mapping of hostnames to authorization patterns; mirrors the eponymous attribute from http_archive | None |
| register_toolchain | If True, the generated rust_toolchain target will become a registered toolchain. | True |
| exec_compatible_with | A list of constraints for the execution platform for this toolchain. | None |
| default_target_compatible_with | A list of constraints for the target platform for this toolchain when the exec platform is the same as the target platform. | None |
| aliases | Replacement names to use for toolchains created by this macro. | {} |
| compact_windows_names | Whether or not to produce compact repository names for windows toolchains. This is to avoid MAX_PATH issues. | True |
rust_test_suite
rust_test_suite(name, srcs, shared_srcs, kwargs)
A rule for creating a test suite for a set of rust_test targets.
This rule can be used for setting up typical rust integration tests. Given the following directory structure:
[crate]/
BUILD.bazel
src/
lib.rs
main.rs
tests/
integrated_test_a.rs
integrated_test_b.rs
integrated_test_c.rs
patterns/
fibonacci_test.rs
helpers/
mod.rs
The rule can be used to generate rust_test targets for each source file under tests
and a test_suite which encapsulates all tests.
load("//rust:defs.bzl", "rust_binary", "rust_library", "rust_test_suite")
rust_library(
name = "math_lib",
srcs = ["src/lib.rs"],
)
rust_binary(
name = "math_bin",
srcs = ["src/main.rs"],
)
rust_test_suite(
name = "integrated_tests_suite",
srcs = glob(["tests/**"]),
shared_srcs=glob(["tests/helpers/**"]),
deps = [":math_lib"],
)
PARAMETERS
| Name | Description | Default Value |
|---|---|---|
| name | The name of the test_suite. | none |
| srcs | All test sources, typically glob(["tests/**/*.rs"]). | none |
| shared_srcs | Optional argument for sources shared among tests, typically helper functions. | [] |
| kwargs | Additional keyword arguments for the underyling rust_test targets. The tags argument is also passed to the generated test_suite target. | none |
rust_toolchain_repository
rust_toolchain_repository(name, version, exec_triple, target_triple, exec_compatible_with, target_compatible_with, target_settings, channel, allocator_library, global_allocator_library, rustfmt_version, edition, dev_components, extra_rustc_flags, extra_exec_rustc_flags, opt_level, sha256s, urls, auth, netrc, auth_patterns)
Assembles a remote repository for the given toolchain params, produces a proxy repository to contain the toolchain declaration, and registers the toolchains.
PARAMETERS
| Name | Description | Default Value |
|---|---|---|
| name | The name of the generated repository | none |
| version | The version of the tool among "nightly", "beta", or an exact version. | none |
| exec_triple | The Rust-style target that this compiler runs on. | none |
| target_triple | The Rust-style target to build for. | none |
| exec_compatible_with | A list of constraints for the execution platform for this toolchain. | None |
| target_compatible_with | A list of constraints for the target platform for this toolchain. | None |
| target_settings | A list of config_settings that must be satisfied by the target configuration in order for this toolchain to be selected during toolchain resolution. | [] |
| channel | The channel of the Rust toolchain. | None |
| allocator_library | Target that provides allocator functions when rust_library targets are embedded in a cc_binary. | None |
| global_allocator_library | Target that provides allocator functions when a global allocator is used with cc_common.link. | None |
| rustfmt_version | The version of rustfmt to be associated with the toolchain. | None |
| edition | The rust edition to be used by default (2015, 2018, or 2021). If absent, every rule is required to specify its edition attribute. | None |
| dev_components | Whether to download the rustc-dev components. Requires version to be "nightly". Defaults to False. | False |
| extra_rustc_flags | Extra flags to pass to rustc in non-exec configuration. | None |
| extra_exec_rustc_flags | Extra flags to pass to rustc in exec configuration. | None |
| opt_level | Optimization level config for this toolchain. | None |
| sha256s | A dict associating tool subdirectories to sha256 hashes. See rust_register_toolchains for more details. | None |
| urls | A list of mirror urls containing the tools from the Rust-lang static file server. These must contain the '{}' used to substitute the tool being fetched (using .format). Defaults to ['https://static.rust-lang.org/dist/{}.tar.xz'] | ["https://static.rust-lang.org/dist/{}.tar.xz"] |
| auth | Auth object compatible with repository_ctx.download to use when downloading files. See repository_ctx.download for more details. | None |
| netrc | .netrc file to use for authentication; mirrors the eponymous attribute from http_archive | None |
| auth_patterns | A list of patterns to match against urls for which the auth object should be used. | None |
RETURNS
str: The name of the registerable toolchain created by this rule.
rust_analyzer_aspect
rust_analyzer_aspect(name)
Annotates rust rules with RustAnalyzerInfo later used to build a rust-project.json
ASPECT ATTRIBUTES
| Name | Type |
|---|---|
| deps | String |
| proc_macro_deps | String |
| crate | String |
| actual | String |
| proto | String |
ATTRIBUTES
| Name | Description | Type | Mandatory | Default |
|---|---|---|---|---|
| name | A unique name for this target. | Name | required |
rust_clippy_aspect
rust_clippy_aspect(name)
Executes the clippy checker on specified targets.
This aspect applies to existing rust_library, rust_test, and rust_binary rules.
As an example, if the following is defined in examples/hello_lib/BUILD.bazel:
load("@rules_rust//rust:defs.bzl", "rust_library", "rust_test")
rust_library(
name = "hello_lib",
srcs = ["src/lib.rs"],
)
rust_test(
name = "greeting_test",
srcs = ["tests/greeting.rs"],
deps = [":hello_lib"],
)
Then the targets can be analyzed with clippy using the following command:
$ bazel build --aspects=@rules_rust//rust:defs.bzl%rust_clippy_aspect --output_groups=clippy_checks //hello_lib:all
ASPECT ATTRIBUTES
ATTRIBUTES
| Name | Description | Type | Mandatory | Default |
|---|---|---|---|---|
| name | A unique name for this target. | Name | required |
rustfmt_aspect
rustfmt_aspect(name)
This aspect is used to gather information about a crate for use in rustfmt and perform rustfmt checks
Output Groups:
rustfmt_checks: Executesrustfmt --checkon the specified target.
The build setting @rules_rust//rust/settings:rustfmt.toml is used to control the Rustfmt configuration settings
used at runtime.
This aspect is executed on any target which provides the CrateInfo provider. However
users may tag a target with no-rustfmt or no-format to have it skipped. Additionally,
generated source files are also ignored by this aspect.
ASPECT ATTRIBUTES
ATTRIBUTES
| Name | Description | Type | Mandatory | Default |
|---|---|---|---|---|
| name | A unique name for this target. | Name | required |
cargo_bootstrap_repository
cargo_bootstrap_repository(name, srcs, binary, build_mode, cargo_config, cargo_lockfile, cargo_toml, compressed_windows_toolchain_names, env, env_label, repo_mapping, rust_toolchain_cargo_template, rust_toolchain_rustc_template, timeout, version)
A rule for bootstrapping a Rust binary using Cargo
ATTRIBUTES
| Name | Description | Type | Mandatory | Default |
|---|---|---|---|---|
| name | A unique name for this repository. | Name | required | |
| srcs | Souce files of the crate to build. Passing source files here can be used to trigger rebuilds when changes are made | List of labels | optional | [] |
| binary | The binary to build (the --bin parameter for Cargo). If left empty, the repository name will be used. | String | optional | "" |
| build_mode | The build mode the binary should be built with | String | optional | "release" |
| cargo_config | The path of the Cargo configuration (Config.toml) file. | Label | optional | None |
| cargo_lockfile | The lockfile of the crate_universe resolver | Label | required | |
| cargo_toml | The path of the Cargo.toml file. | Label | required | |
| compressed_windows_toolchain_names | Wether or not the toolchain names of windows toolchains are expected to be in a compressed format. | Boolean | optional | True |
| env | A mapping of platform triple to a set of environment variables. See cargo_env for usage details. Additionally, the platform triple * applies to all platforms. | Dictionary: String -> String | optional | {} |
| env_label | A mapping of platform triple to a set of environment variables. This attribute differs from env in that all variables passed here must be fully qualified labels of files. See cargo_env for usage details. Additionally, the platform triple * applies to all platforms. | Dictionary: String -> String | optional | {} |
| repo_mapping | In WORKSPACE context only: a dictionary from local repository name to global repository name. This allows controls over workspace dependency resolution for dependencies of this repository.For example, an entry "@foo": "@bar" declares that, for any time this repository depends on @foo (such as a dependency on @foo//some:target, it should actually resolve that dependency within globally-declared @bar (@bar//some:target).This attribute is not supported in MODULE.bazel context (when invoking a repository rule inside a module extension's implementation function). | Dictionary: String -> String | optional | |
| rust_toolchain_cargo_template | The template to use for finding the host cargo binary. {version} (eg. '1.53.0'), {triple} (eg. 'x86_64-unknown-linux-gnu'), {arch} (eg. 'aarch64'), {vendor} (eg. 'unknown'), {system} (eg. 'darwin'), {channel} (eg. 'stable'), and {tool} (eg. 'rustc.exe') will be replaced in the string if present. | String | optional | "@rust_{system}_{arch}__{triple}__{channel}_tools//:bin/{tool}" |
| rust_toolchain_rustc_template | The template to use for finding the host rustc binary. {version} (eg. '1.53.0'), {triple} (eg. 'x86_64-unknown-linux-gnu'), {arch} (eg. 'aarch64'), {vendor} (eg. 'unknown'), {system} (eg. 'darwin'), {channel} (eg. 'stable'), and {tool} (eg. 'rustc.exe') will be replaced in the string if present. | String | optional | "@rust_{system}_{arch}__{triple}__{channel}_tools//:bin/{tool}" |
| timeout | Maximum duration of the Cargo build command in seconds | Integer | optional | 600 |
| version | The version of Rust the currently registered toolchain is using. Eg. 1.56.0, or nightly/2021-09-08 | String | optional | "1.83.0" |
rust_toolchain_repository_proxy
rust_toolchain_repository_proxy(name, exec_compatible_with, repo_mapping, target_compatible_with, target_settings, toolchain, toolchain_type)
Generates a toolchain-bearing repository that declares the toolchains from some other rust_toolchain_repository.
ATTRIBUTES
| Name | Description | Type | Mandatory | Default |
|---|---|---|---|---|
| name | A unique name for this repository. | Name | required | |
| exec_compatible_with | A list of constraints for the execution platform for this toolchain. | List of strings | optional | [] |
| repo_mapping | In WORKSPACE context only: a dictionary from local repository name to global repository name. This allows controls over workspace dependency resolution for dependencies of this repository.For example, an entry "@foo": "@bar" declares that, for any time this repository depends on @foo (such as a dependency on @foo//some:target, it should actually resolve that dependency within globally-declared @bar (@bar//some:target).This attribute is not supported in MODULE.bazel context (when invoking a repository rule inside a module extension's implementation function). | Dictionary: String -> String | optional | |
| target_compatible_with | A list of constraints for the target platform for this toolchain. | List of strings | optional | [] |
| target_settings | A list of config_settings that must be satisfied by the target configuration in order for this toolchain to be selected during toolchain resolution. | List of strings | optional | [] |
| toolchain | The name of the toolchain implementation target. | String | required | |
| toolchain_type | The toolchain type of the toolchain to declare | String | required |
rust_toolchain_tools_repository
rust_toolchain_tools_repository(name, allocator_library, auth, auth_patterns, dev_components, edition, exec_triple, extra_exec_rustc_flags, extra_rustc_flags, global_allocator_library, netrc, opt_level, repo_mapping, rustfmt_version, sha256s, target_triple, urls, version)
Composes a single workspace containing the toolchain components for compiling on a given platform to a series of target platforms.
A given instance of this rule should be accompanied by a toolchain_repository_proxy invocation to declare its toolchains to Bazel; the indirection allows separating toolchain selection from toolchain fetching.
ATTRIBUTES
| Name | Description | Type | Mandatory | Default |
|---|---|---|---|---|
| name | A unique name for this repository. | Name | required | |
| allocator_library | Target that provides allocator functions when rust_library targets are embedded in a cc_binary. | String | optional | "@rules_rust//ffi/cc/allocator_library" |
| auth | Auth object compatible with repository_ctx.download to use when downloading files. See repository_ctx.download for more details. | Dictionary: String -> String | optional | {} |
| auth_patterns | A list of patterns to match against urls for which the auth object should be used. | List of strings | optional | [] |
| dev_components | Whether to download the rustc-dev components (defaults to False). Requires version to be "nightly". | Boolean | optional | False |
| edition | The rust edition to be used by default (2015, 2018, or 2021). If absent, every rule is required to specify its edition attribute. | String | optional | "" |
| exec_triple | The Rust-style target that this compiler runs on | String | required | |
| extra_exec_rustc_flags | Extra flags to pass to rustc in exec configuration | List of strings | optional | [] |
| extra_rustc_flags | Extra flags to pass to rustc in non-exec configuration | List of strings | optional | [] |
| global_allocator_library | Target that provides allocator functions when a global allocator is used with cc_common.link. | String | optional | "@rules_rust//ffi/cc/global_allocator_library" |
| netrc | .netrc file to use for authentication; mirrors the eponymous attribute from http_archive | String | optional | "" |
| opt_level | Rustc optimization levels. For more details see the documentation for rust_toolchain.opt_level. | Dictionary: String -> String | optional | {} |
| repo_mapping | In WORKSPACE context only: a dictionary from local repository name to global repository name. This allows controls over workspace dependency resolution for dependencies of this repository.For example, an entry "@foo": "@bar" declares that, for any time this repository depends on @foo (such as a dependency on @foo//some:target, it should actually resolve that dependency within globally-declared @bar (@bar//some:target).This attribute is not supported in MODULE.bazel context (when invoking a repository rule inside a module extension's implementation function). | Dictionary: String -> String | optional | |
| rustfmt_version | The version of the tool among "nightly", "beta", or an exact version. | String | optional | "" |
| sha256s | A dict associating tool subdirectories to sha256 hashes. See rust_register_toolchains for more details. | Dictionary: String -> String | optional | {} |
| target_triple | The Rust-style target that this compiler builds for. | String | required | |
| urls | A list of mirror urls containing the tools from the Rust-lang static file server. These must contain the '{}' used to substitute the tool being fetched (using .format). | List of strings | optional | ["https://static.rust-lang.org/dist/{}.tar.xz"] |
| version | The version of the tool among "nightly", "beta", or an exact version. | String | required |