| """Repository rules for defining Rust dependencies and toolchains""" |
| |
| load("@bazel_tools//tools/build_defs/repo:http.bzl", "http_archive") |
| load("@bazel_tools//tools/build_defs/repo:utils.bzl", "maybe") |
| load("//rust/platform:triple.bzl", "get_host_triple", "triple") |
| load("//rust/platform:triple_mappings.bzl", "triple_to_constraint_set") |
| load("//rust/private:common.bzl", "rust_common") |
| load( |
| "//rust/private:repository_utils.bzl", |
| "BUILD_for_rust_analyzer_proc_macro_srv", |
| "BUILD_for_rust_analyzer_toolchain", |
| "BUILD_for_rust_toolchain", |
| "BUILD_for_rustfmt_toolchain", |
| "BUILD_for_toolchain", |
| "DEFAULT_EXTRA_TARGET_TRIPLES", |
| "DEFAULT_NIGHTLY_VERSION", |
| "DEFAULT_STATIC_RUST_URL_TEMPLATES", |
| "TINYJSON_KWARGS", |
| "check_version_valid", |
| "includes_rust_analyzer_proc_macro_srv", |
| "load_cargo", |
| "load_clippy", |
| "load_llvm_tools", |
| "load_rust_compiler", |
| "load_rust_src", |
| "load_rust_stdlib", |
| "load_rustc_dev_nightly", |
| "load_rustfmt", |
| "select_rust_version", |
| "toolchain_repository_hub", |
| _load_arbitrary_tool = "load_arbitrary_tool", |
| ) |
| |
| # Re-export `load_arbitrary_tool` as it's historically been used in external repositories. |
| load_arbitrary_tool = _load_arbitrary_tool |
| |
| # Note: Code in `.github/workflows/crate_universe.yaml` looks for this line, if you remove it or change its format, you will also need to update that code. |
| DEFAULT_TOOLCHAIN_TRIPLES = { |
| "aarch64-apple-darwin": "rust_darwin_aarch64", |
| "aarch64-pc-windows-msvc": "rust_windows_aarch64", |
| "aarch64-unknown-linux-gnu": "rust_linux_aarch64", |
| "s390x-unknown-linux-gnu": "rust_linux_s390x", |
| "x86_64-apple-darwin": "rust_darwin_x86_64", |
| "x86_64-pc-windows-msvc": "rust_windows_x86_64", |
| "x86_64-unknown-freebsd": "rust_freebsd_x86_64", |
| "x86_64-unknown-linux-gnu": "rust_linux_x86_64", |
| } |
| |
| def rules_rust_dependencies(): |
| """Dependencies used in the implementation of `rules_rust`.""" |
| |
| maybe( |
| http_archive, |
| name = "platforms", |
| urls = [ |
| "https://mirror.bazel.build/github.com/bazelbuild/platforms/releases/download/0.0.8/platforms-0.0.8.tar.gz", |
| "https://github.com/bazelbuild/platforms/releases/download/0.0.8/platforms-0.0.8.tar.gz", |
| ], |
| sha256 = "8150406605389ececb6da07cbcb509d5637a3ab9a24bc69b1101531367d89d74", |
| ) |
| maybe( |
| http_archive, |
| name = "rules_cc", |
| urls = ["https://github.com/bazelbuild/rules_cc/releases/download/0.0.9/rules_cc-0.0.9.tar.gz"], |
| sha256 = "2037875b9a4456dce4a79d112a8ae885bbc4aad968e6587dca6e64f3a0900cdf", |
| strip_prefix = "rules_cc-0.0.9", |
| ) |
| maybe( |
| http_archive, |
| name = "rules_license", |
| urls = [ |
| "https://mirror.bazel.build/github.com/bazelbuild/rules_license/releases/download/0.0.8/rules_license-0.0.8.tar.gz", |
| "https://github.com/bazelbuild/rules_license/releases/download/0.0.8/rules_license-0.0.8.tar.gz", |
| ], |
| sha256 = "241b06f3097fd186ff468832150d6cc142247dc42a32aaefb56d0099895fd229", |
| ) |
| |
| maybe( |
| http_archive, |
| name = "bazel_skylib", |
| sha256 = "cd55a062e763b9349921f0f5db8c3933288dc8ba4f76dd9416aac68acee3cb94", |
| urls = [ |
| "https://mirror.bazel.build/github.com/bazelbuild/bazel-skylib/releases/download/1.5.0/bazel-skylib-1.5.0.tar.gz", |
| "https://github.com/bazelbuild/bazel-skylib/releases/download/1.5.0/bazel-skylib-1.5.0.tar.gz", |
| ], |
| ) |
| |
| # Make the iOS simulator constraint available, which is referenced in abi_to_constraints() |
| # rules_rust does not require this dependency; it is just imported as a convenience for users. |
| maybe( |
| http_archive, |
| name = "build_bazel_apple_support", |
| sha256 = "1c4031e72b456a048d8177f59a5581808c07585fa9e255c6f5fefb8752af7e40", |
| url = "https://github.com/bazelbuild/apple_support/releases/download/1.13.0/apple_support.1.13.0.tar.gz", |
| ) |
| |
| # process_wrapper needs a low-dependency way to process json. |
| maybe( |
| http_archive, |
| **TINYJSON_KWARGS |
| ) |
| |
| _RUST_TOOLCHAIN_VERSIONS = [ |
| rust_common.default_version, |
| DEFAULT_NIGHTLY_VERSION, |
| ] |
| |
| # buildifier: disable=unnamed-macro |
| def rust_register_toolchains( |
| dev_components = False, |
| edition = None, |
| allocator_library = None, |
| global_allocator_library = None, |
| register_toolchains = True, |
| rustfmt_version = None, |
| rust_analyzer_version = None, |
| sha256s = None, |
| extra_target_triples = DEFAULT_EXTRA_TARGET_TRIPLES, |
| extra_rustc_flags = None, |
| extra_exec_rustc_flags = None, |
| urls = DEFAULT_STATIC_RUST_URL_TEMPLATES, |
| versions = _RUST_TOOLCHAIN_VERSIONS): |
| """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: |
| ```python |
| { |
| "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. |
| |
| Args: |
| dev_components (bool, optional): Whether to download the rustc-dev components (defaults to False). Requires version to be "nightly". |
| edition (str, optional): The rust edition to be used by default (2015, 2018, or 2021). If absent, every target is required to specify its `edition` attribute. |
| allocator_library (str, optional): Target that provides allocator functions when rust_library targets are embedded in a cc_binary. |
| global_allocator_library (str, optional): Target that provides allocator functions when global allocator is used with cc_common.link. |
| register_toolchains (bool): If true, repositories will be generated to produce and register `rust_toolchain` targets. |
| rustfmt_version (str, optional): The version of rustfmt. If none is supplied and only a single version in `versions` is given, then this defaults to that version, otherwise will default to the default nightly version. |
| rust_analyzer_version (str, optional): The version of Rustc to pair with rust-analyzer. |
| sha256s (str, optional): A dict associating tool subdirectories to sha256 hashes. |
| extra_target_triples (list, optional): Additional rust-style targets that rust toolchains should support. |
| extra_rustc_flags (dict, list, optional): Dictionary of target triples to list of extra flags to pass to rustc in non-exec configuration. |
| extra_exec_rustc_flags (list, optional): Extra flags to pass to rustc in exec configuration. |
| urls (list, optional): 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). |
| versions (list, optional): 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"]`. |
| """ |
| if not rustfmt_version: |
| if len(versions) == 1: |
| rustfmt_version = versions[0] |
| else: |
| rustfmt_version = DEFAULT_NIGHTLY_VERSION |
| |
| if dev_components: |
| has_nightly = False |
| for ver in versions: |
| if ver.startswith("nightly"): |
| has_nightly = True |
| break |
| if not has_nightly: |
| fail("rustc-dev components were requested but no \"nightly\" is being registered. Please update `versions` to include a nightly version.") |
| |
| if not rust_analyzer_version: |
| rust_analyzer_version = select_rust_version(versions) |
| |
| rust_analyzer_repo_name = "rust_analyzer_{}".format(rust_analyzer_version.replace("/", "-")) |
| |
| toolchain_names = [] |
| toolchain_labels = {} |
| toolchain_types = {} |
| exec_compatible_with_by_toolchain = {} |
| target_compatible_with_by_toolchain = {} |
| |
| maybe( |
| rust_analyzer_toolchain_repository, |
| name = rust_analyzer_repo_name, |
| version = rust_analyzer_version, |
| urls = urls, |
| sha256s = sha256s, |
| ) |
| |
| toolchain_names.append(rust_analyzer_repo_name) |
| toolchain_labels[rust_analyzer_repo_name] = "@{}_tools//:rust_analyzer_toolchain".format( |
| rust_analyzer_repo_name, |
| ) |
| exec_compatible_with_by_toolchain[rust_analyzer_repo_name] = [] |
| target_compatible_with_by_toolchain[rust_analyzer_repo_name] = [] |
| toolchain_types[rust_analyzer_repo_name] = "@rules_rust//rust/rust_analyzer:toolchain_type" |
| |
| if register_toolchains: |
| native.register_toolchains("@{}//:toolchain".format( |
| rust_analyzer_repo_name, |
| )) |
| |
| for exec_triple, name in DEFAULT_TOOLCHAIN_TRIPLES.items(): |
| maybe( |
| rust_repository_set, |
| name = name, |
| dev_components = dev_components, |
| edition = edition, |
| exec_triple = exec_triple, |
| extra_target_triples = extra_target_triples, |
| allocator_library = allocator_library, |
| global_allocator_library = global_allocator_library, |
| register_toolchain = register_toolchains, |
| rustfmt_version = rustfmt_version, |
| extra_rustc_flags = extra_rustc_flags, |
| extra_exec_rustc_flags = extra_exec_rustc_flags, |
| sha256s = sha256s, |
| urls = urls, |
| versions = versions, |
| ) |
| |
| rustfmt_repo_name = "rustfmt_{}__{}".format(rustfmt_version.replace("/", "-"), exec_triple) |
| |
| maybe( |
| rustfmt_toolchain_repository, |
| name = rustfmt_repo_name, |
| version = rustfmt_version, |
| urls = urls, |
| sha256s = sha256s, |
| exec_triple = exec_triple, |
| ) |
| |
| if register_toolchains: |
| native.register_toolchains("@{}//:toolchain".format( |
| rustfmt_repo_name, |
| )) |
| |
| for toolchain in _get_toolchain_repositories(name, exec_triple, extra_target_triples, versions, fallback_target_compatible_with = None): |
| toolchain_names.append(toolchain.name) |
| toolchain_labels[toolchain.name] = "@{}//:{}".format(toolchain.name + "_tools", "rust_toolchain") |
| exec_compatible_with_by_toolchain[toolchain.name] = triple_to_constraint_set(exec_triple) |
| target_compatible_with_by_toolchain[toolchain.name] = toolchain.target_constraints |
| toolchain_types[toolchain.name] = "@rules_rust//rust:toolchain" |
| |
| toolchain_names.append(rustfmt_repo_name) |
| toolchain_labels[rustfmt_repo_name] = "@{}_tools//:rustfmt_toolchain".format(rustfmt_repo_name) |
| exec_compatible_with_by_toolchain[rustfmt_repo_name] = triple_to_constraint_set(exec_triple) |
| target_compatible_with_by_toolchain[rustfmt_repo_name] = [] |
| toolchain_types[rustfmt_repo_name] = "@rules_rust//rust/rustfmt:toolchain_type" |
| |
| toolchain_repository_hub( |
| name = "rust_toolchains", |
| toolchain_names = toolchain_names, |
| toolchain_labels = toolchain_labels, |
| toolchain_types = toolchain_types, |
| exec_compatible_with = exec_compatible_with_by_toolchain, |
| target_compatible_with = target_compatible_with_by_toolchain, |
| ) |
| |
| # buildifier: disable=unnamed-macro |
| def rust_repositories(**kwargs): |
| """**Deprecated**: Use [rules_rust_dependencies](#rules_rust_dependencies) \ |
| and [rust_register_toolchains](#rust_register_toolchains) directly. |
| |
| Args: |
| **kwargs (dict): Keyword arguments for the `rust_register_toolchains` macro. |
| """ |
| rules_rust_dependencies() |
| |
| rust_register_toolchains(**kwargs) |
| |
| _RUST_TOOLCHAIN_REPOSITORY_ATTRS = { |
| "allocator_library": attr.string( |
| doc = "Target that provides allocator functions when rust_library targets are embedded in a cc_binary.", |
| default = "@rules_rust//ffi/cc/allocator_library", |
| ), |
| "auth": attr.string_dict( |
| doc = ( |
| "Auth object compatible with repository_ctx.download to use when downloading files. " + |
| "See [repository_ctx.download](https://docs.bazel.build/versions/main/skylark/lib/repository_ctx.html#download) for more details." |
| ), |
| ), |
| "auth_patterns": attr.string_list( |
| doc = "A list of patterns to match against urls for which the auth object should be used.", |
| ), |
| "dev_components": attr.bool( |
| doc = "Whether to download the rustc-dev components (defaults to False). Requires version to be \"nightly\".", |
| default = False, |
| ), |
| "edition": attr.string( |
| doc = ( |
| "The rust edition to be used by default (2015, 2018, or 2021). " + |
| "If absent, every rule is required to specify its `edition` attribute." |
| ), |
| ), |
| "exec_triple": attr.string( |
| doc = "The Rust-style target that this compiler runs on", |
| mandatory = True, |
| ), |
| "extra_exec_rustc_flags": attr.string_list( |
| doc = "Extra flags to pass to rustc in exec configuration", |
| ), |
| "extra_rustc_flags": attr.string_list( |
| doc = "Extra flags to pass to rustc in non-exec configuration", |
| ), |
| "global_allocator_library": attr.string( |
| doc = "Target that provides allocator functions when a global allocator is used with cc_common.link.", |
| default = "@rules_rust//ffi/cc/global_allocator_library", |
| ), |
| "netrc": attr.string( |
| doc = ".netrc file to use for authentication; mirrors the eponymous attribute from http_archive", |
| ), |
| "opt_level": attr.string_dict( |
| doc = "Rustc optimization levels. For more details see the documentation for `rust_toolchain.opt_level`.", |
| ), |
| "rustfmt_version": attr.string( |
| doc = "The version of the tool among \"nightly\", \"beta\", or an exact version.", |
| ), |
| "sha256s": attr.string_dict( |
| doc = "A dict associating tool subdirectories to sha256 hashes. See [rust_register_toolchains](#rust_register_toolchains) for more details.", |
| ), |
| "target_triple": attr.string( |
| doc = "The Rust-style target that this compiler builds for.", |
| mandatory = True, |
| ), |
| "urls": attr.string_list( |
| doc = "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).", |
| default = DEFAULT_STATIC_RUST_URL_TEMPLATES, |
| ), |
| "version": attr.string( |
| doc = "The version of the tool among \"nightly\", \"beta\", or an exact version.", |
| mandatory = True, |
| ), |
| } |
| |
| def _rust_toolchain_tools_repository_impl(ctx): |
| """The implementation of the rust toolchain tools repository rule.""" |
| sha256s = dict(ctx.attr.sha256s) |
| iso_date = None |
| version = ctx.attr.version |
| version_array = version.split("/") |
| if len(version_array) > 1: |
| version = version_array[0] |
| iso_date = version_array[1] |
| |
| check_version_valid(ctx.attr.version, iso_date) |
| |
| exec_triple = triple(ctx.attr.exec_triple) |
| |
| rustc_content, rustc_sha256 = load_rust_compiler( |
| ctx = ctx, |
| iso_date = iso_date, |
| target_triple = exec_triple, |
| version = version, |
| ) |
| clippy_content, clippy_sha256 = load_clippy( |
| ctx = ctx, |
| iso_date = iso_date, |
| target_triple = exec_triple, |
| version = version, |
| ) |
| cargo_content, cargo_sha256 = load_cargo( |
| ctx = ctx, |
| iso_date = iso_date, |
| target_triple = exec_triple, |
| version = version, |
| ) |
| |
| build_components = [ |
| rustc_content, |
| clippy_content, |
| cargo_content, |
| ] |
| sha256s.update(rustc_sha256 | clippy_sha256 | cargo_sha256) |
| |
| if ctx.attr.rustfmt_version: |
| rustfmt_version = ctx.attr.rustfmt_version |
| rustfmt_iso_date = None |
| if rustfmt_version in ("nightly", "beta"): |
| if iso_date: |
| rustfmt_iso_date = iso_date |
| else: |
| fail("`rustfmt_version` does not include an iso_date. The following reposiotry should either set `iso_date` or update `rustfmt_version` to include an iso_date suffix: {}".format( |
| ctx.name, |
| )) |
| elif rustfmt_version.startswith(("nightly", "beta")): |
| rustfmt_version, _, rustfmt_iso_date = rustfmt_version.partition("/") |
| rustfmt_content, rustfmt_sha256 = load_rustfmt( |
| ctx = ctx, |
| target_triple = triple(ctx.attr.exec_triple), |
| version = rustfmt_version, |
| iso_date = rustfmt_iso_date, |
| ) |
| build_components.append(rustfmt_content) |
| sha256s.update(rustfmt_sha256) |
| |
| # Rust 1.45.0 and nightly builds after 2020-05-22 need the llvm-tools gzip to get the libLLVM dylib |
| include_llvm_tools = version >= "1.45.0" or (version == "nightly" and iso_date > "2020-05-22") |
| if include_llvm_tools: |
| llvm_tools_content, llvm_tools_sha256 = load_llvm_tools( |
| ctx = ctx, |
| target_triple = exec_triple, |
| version = version, |
| iso_date = iso_date, |
| ) |
| build_components.append(llvm_tools_content) |
| sha256s.update(llvm_tools_sha256) |
| |
| target_triple = triple(ctx.attr.target_triple) |
| rust_stdlib_content, rust_stdlib_sha256 = load_rust_stdlib( |
| ctx = ctx, |
| target_triple = target_triple, |
| version = version, |
| iso_date = iso_date, |
| ) |
| build_components.append(rust_stdlib_content) |
| sha256s.update(rust_stdlib_sha256) |
| |
| stdlib_linkflags = None |
| if "BAZEL_RUST_STDLIB_LINKFLAGS" in ctx.os.environ: |
| stdlib_linkflags = ctx.os.environ["BAZEL_RUST_STDLIB_LINKFLAGS"].split(":") |
| |
| build_components.append(BUILD_for_rust_toolchain( |
| name = "rust_toolchain", |
| exec_triple = exec_triple, |
| allocator_library = ctx.attr.allocator_library, |
| global_allocator_library = ctx.attr.global_allocator_library, |
| target_triple = target_triple, |
| stdlib_linkflags = stdlib_linkflags, |
| default_edition = ctx.attr.edition, |
| include_rustfmt = not (not ctx.attr.rustfmt_version), |
| include_llvm_tools = include_llvm_tools, |
| extra_rustc_flags = ctx.attr.extra_rustc_flags, |
| extra_exec_rustc_flags = ctx.attr.extra_exec_rustc_flags, |
| opt_level = ctx.attr.opt_level if ctx.attr.opt_level else None, |
| )) |
| |
| # Not all target triples are expected to have dev components |
| if ctx.attr.dev_components: |
| rustc_dev_sha256 = load_rustc_dev_nightly( |
| ctx = ctx, |
| target_triple = target_triple, |
| version = version, |
| iso_date = iso_date, |
| ) |
| sha256s.update(rustc_dev_sha256) |
| |
| ctx.file("WORKSPACE.bazel", "") |
| ctx.file("BUILD.bazel", "\n".join(build_components)) |
| |
| repro = {"name": ctx.name} |
| for key in _RUST_TOOLCHAIN_REPOSITORY_ATTRS: |
| repro[key] = getattr(ctx.attr, key) |
| repro["sha256s"] = sha256s |
| |
| return repro |
| |
| rust_toolchain_tools_repository = repository_rule( |
| doc = ( |
| "Composes a single workspace containing the toolchain components for compiling on a given " + |
| "platform to a series of target platforms.\n" + |
| "\n" + |
| "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." |
| ), |
| attrs = _RUST_TOOLCHAIN_REPOSITORY_ATTRS, |
| implementation = _rust_toolchain_tools_repository_impl, |
| ) |
| |
| def _toolchain_repository_proxy_impl(repository_ctx): |
| repository_ctx.file("WORKSPACE.bazel", """workspace(name = "{}")""".format( |
| repository_ctx.name, |
| )) |
| |
| repository_ctx.file("BUILD.bazel", BUILD_for_toolchain( |
| name = "toolchain", |
| toolchain = repository_ctx.attr.toolchain, |
| target_settings = repository_ctx.attr.target_settings, |
| toolchain_type = repository_ctx.attr.toolchain_type, |
| target_compatible_with = repository_ctx.attr.target_compatible_with, |
| exec_compatible_with = repository_ctx.attr.exec_compatible_with, |
| )) |
| |
| toolchain_repository_proxy = repository_rule( |
| doc = ( |
| "Generates a toolchain-bearing repository that declares the toolchains from some other " + |
| "rust_toolchain_repository." |
| ), |
| attrs = { |
| "exec_compatible_with": attr.string_list( |
| doc = "A list of constraints for the execution platform for this toolchain.", |
| ), |
| "target_compatible_with": attr.string_list( |
| doc = "A list of constraints for the target platform for this toolchain.", |
| ), |
| "target_settings": attr.string_list( |
| doc = "A list of config_settings that must be satisfied by the target configuration in order for this toolchain to be selected during toolchain resolution.", |
| ), |
| "toolchain": attr.string( |
| doc = "The name of the toolchain implementation target.", |
| mandatory = True, |
| ), |
| "toolchain_type": attr.string( |
| doc = "The toolchain type of the toolchain to declare", |
| mandatory = True, |
| ), |
| }, |
| implementation = _toolchain_repository_proxy_impl, |
| ) |
| |
| # For legacy support |
| rust_toolchain_repository_proxy = toolchain_repository_proxy |
| |
| # N.B. A "proxy repository" is needed to allow for registering the toolchain (with constraints) |
| # without actually downloading the toolchain. |
| def rust_toolchain_repository( |
| name, |
| version, |
| exec_triple, |
| target_triple, |
| exec_compatible_with = None, |
| target_compatible_with = None, |
| target_settings = [], |
| channel = None, |
| allocator_library = None, |
| global_allocator_library = None, |
| rustfmt_version = None, |
| edition = None, |
| dev_components = False, |
| extra_rustc_flags = None, |
| extra_exec_rustc_flags = None, |
| opt_level = None, |
| sha256s = None, |
| urls = DEFAULT_STATIC_RUST_URL_TEMPLATES, |
| auth = None, |
| netrc = None, |
| auth_patterns = None): |
| """Assembles a remote repository for the given toolchain params, produces a proxy repository \ |
| to contain the toolchain declaration, and registers the toolchains. |
| |
| Args: |
| name (str): The name of the generated repository |
| version (str): The version of the tool among "nightly", "beta", or an exact version. |
| exec_triple (str): The Rust-style target that this compiler runs on. |
| target_triple (str): The Rust-style target to build for. |
| channel (str, optional): The channel of the Rust toolchain. |
| exec_compatible_with (list, optional): A list of constraints for the execution platform for this toolchain. |
| target_compatible_with (list, optional): A list of constraints for the target platform for this toolchain. |
| target_settings (list, optional): A list of config_settings that must be satisfied by the target configuration in order for this toolchain to be selected during toolchain resolution. |
| allocator_library (str, optional): Target that provides allocator functions when rust_library targets are embedded in a cc_binary. |
| global_allocator_library (str, optional): Target that provides allocator functions when a global allocator is used with cc_common.link. |
| rustfmt_version (str, optional): The version of rustfmt to be associated with the |
| toolchain. |
| edition (str, optional): The rust edition to be used by default (2015, 2018, or 2021). If absent, every rule is required to specify its `edition` attribute. |
| dev_components (bool, optional): Whether to download the rustc-dev components. |
| Requires version to be "nightly". Defaults to False. |
| extra_rustc_flags (list, optional): Extra flags to pass to rustc in non-exec configuration. |
| extra_exec_rustc_flags (list, optional): Extra flags to pass to rustc in exec configuration. |
| opt_level (dict, optional): Optimization level config for this toolchain. |
| sha256s (str, optional): A dict associating tool subdirectories to sha256 hashes. See |
| [rust_register_toolchains](#rust_register_toolchains) for more details. |
| urls (list, optional): 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'] |
| auth (dict): Auth object compatible with repository_ctx.download to use when downloading files. |
| See [repository_ctx.download](https://docs.bazel.build/versions/main/skylark/lib/repository_ctx.html#download) for more details. |
| netrc (str, optional): .netrc file to use for authentication; mirrors the eponymous attribute from http_archive |
| auth_patterns (list, optional): A list of patterns to match against urls for which the auth object should be used. |
| |
| Returns: |
| str: The name of the registerable toolchain created by this rule. |
| """ |
| if exec_compatible_with == None: |
| exec_compatible_with = triple_to_constraint_set(exec_triple) |
| |
| if target_compatible_with == None: |
| target_compatible_with = triple_to_constraint_set(target_triple) |
| |
| tools_repo_name = "{}_tools".format(name) |
| |
| rust_toolchain_tools_repository( |
| name = tools_repo_name, |
| exec_triple = exec_triple, |
| allocator_library = allocator_library, |
| global_allocator_library = global_allocator_library, |
| target_triple = target_triple, |
| version = version, |
| rustfmt_version = rustfmt_version, |
| edition = edition, |
| dev_components = dev_components, |
| extra_rustc_flags = extra_rustc_flags, |
| extra_exec_rustc_flags = extra_exec_rustc_flags, |
| opt_level = opt_level, |
| sha256s = sha256s, |
| urls = urls, |
| auth = auth, |
| netrc = netrc, |
| auth_patterns = auth_patterns, |
| ) |
| |
| channel_target_settings = ["@rules_rust//rust/toolchain/channel:{}".format(channel)] if channel else [] |
| |
| toolchain_repository_proxy( |
| name = name, |
| toolchain = "@{}//:rust_toolchain".format(tools_repo_name), |
| target_settings = channel_target_settings + target_settings, |
| toolchain_type = "@rules_rust//rust:toolchain", |
| exec_compatible_with = exec_compatible_with, |
| target_compatible_with = target_compatible_with, |
| ) |
| |
| return "@{name}//:toolchain".format( |
| name = name, |
| ) |
| |
| _RUST_ANALYZER_TOOLCHAIN_TOOLS_REPOSITORY_ATTRS = { |
| "auth": attr.string_dict( |
| doc = ( |
| "Auth object compatible with repository_ctx.download to use when downloading files. " + |
| "See [repository_ctx.download](https://docs.bazel.build/versions/main/skylark/lib/repository_ctx.html#download) for more details." |
| ), |
| ), |
| "auth_patterns": attr.string_list( |
| doc = "A list of patterns to match against urls for which the auth object should be used.", |
| ), |
| "netrc": attr.string( |
| doc = ".netrc file to use for authentication; mirrors the eponymous attribute from http_archive", |
| ), |
| "sha256s": attr.string_dict( |
| doc = "A dict associating tool subdirectories to sha256 hashes. See [rust_register_toolchains](#rust_register_toolchains) for more details.", |
| ), |
| "urls": attr.string_list( |
| doc = "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).", |
| default = DEFAULT_STATIC_RUST_URL_TEMPLATES, |
| ), |
| "version": attr.string( |
| doc = "The version of the tool among \"nightly\", \"beta\" with an iso date, or an exact version.", |
| mandatory = True, |
| ), |
| } |
| |
| def _rust_analyzer_toolchain_tools_repository_impl(repository_ctx): |
| sha256s = dict(repository_ctx.attr.sha256s) |
| |
| iso_date = None |
| version = repository_ctx.attr.version |
| version_array = version.split("/") |
| if len(version_array) > 1: |
| version = version_array[0] |
| iso_date = version_array[1] |
| |
| sha256s.update(load_rust_src( |
| ctx = repository_ctx, |
| iso_date = iso_date, |
| version = version, |
| )) |
| |
| repository_ctx.file("WORKSPACE.bazel", """workspace(name = "{}")""".format( |
| repository_ctx.name, |
| )) |
| |
| host_triple = get_host_triple(repository_ctx) |
| rustc_content, rustc_sha256 = load_rust_compiler( |
| ctx = repository_ctx, |
| iso_date = iso_date, |
| target_triple = host_triple, |
| version = version, |
| ) |
| build_contents = [rustc_content] |
| sha256s.update(rustc_sha256) |
| rustc = "//:rustc" |
| |
| proc_macro_srv = None |
| if includes_rust_analyzer_proc_macro_srv(version, iso_date): |
| build_contents.append(BUILD_for_rust_analyzer_proc_macro_srv(host_triple)) |
| proc_macro_srv = "//:rust_analyzer_proc_macro_srv" |
| |
| build_contents.append(BUILD_for_rust_analyzer_toolchain( |
| name = "rust_analyzer_toolchain", |
| rustc = rustc, |
| proc_macro_srv = proc_macro_srv, |
| )) |
| |
| repository_ctx.file("BUILD.bazel", "\n".join(build_contents)) |
| repository_ctx.file("WORKSPACE.bazel", """workspace(name = "{}")""".format( |
| repository_ctx.name, |
| )) |
| |
| repro = {"name": repository_ctx.name} |
| for key in _RUST_ANALYZER_TOOLCHAIN_TOOLS_REPOSITORY_ATTRS: |
| repro[key] = getattr(repository_ctx.attr, key) |
| repro["sha256s"] = sha256s |
| |
| return repro |
| |
| rust_analyzer_toolchain_tools_repository = repository_rule( |
| doc = "A repository rule for defining a rust_analyzer_toolchain with a `rust-src` artifact.", |
| implementation = _rust_analyzer_toolchain_tools_repository_impl, |
| attrs = _RUST_ANALYZER_TOOLCHAIN_TOOLS_REPOSITORY_ATTRS, |
| ) |
| |
| def rust_analyzer_toolchain_repository( |
| name, |
| version, |
| exec_compatible_with = [], |
| target_compatible_with = [], |
| sha256s = None, |
| urls = None, |
| auth = None, |
| netrc = None, |
| auth_patterns = None): |
| """Assemble a remote rust_analyzer_toolchain target based on the given params. |
| |
| Args: |
| name (str): The name of the toolchain proxy repository contianing the registerable toolchain. |
| version (str): The version of the tool among "nightly", "beta', or an exact version. |
| exec_compatible_with (list, optional): A list of constraints for the execution platform for this toolchain. |
| target_compatible_with (list, optional): A list of constraints for the target platform for this toolchain. |
| sha256s (str, optional): A dict associating tool subdirectories to sha256 hashes. See |
| [rust_register_toolchains](#rust_register_toolchains) for more details. |
| urls (list, optional): 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'] |
| auth (dict): Auth object compatible with repository_ctx.download to use when downloading files. |
| See [repository_ctx.download](https://docs.bazel.build/versions/main/skylark/lib/repository_ctx.html#download) for more details. |
| netrc (str, optional): .netrc file to use for authentication; mirrors the eponymous attribute from http_archive |
| auth_patterns (dict, optional): Override mapping of hostnames to authorization patterns; mirrors the eponymous attribute from http_archive |
| |
| Returns: |
| str: The name of a registerable rust_analyzer_toolchain. |
| """ |
| rust_analyzer_toolchain_tools_repository( |
| name = name + "_tools", |
| version = version, |
| sha256s = sha256s, |
| urls = urls, |
| auth = auth, |
| netrc = netrc, |
| auth_patterns = auth_patterns, |
| ) |
| |
| toolchain_repository_proxy( |
| name = name, |
| toolchain = "@{}//:{}".format(name + "_tools", "rust_analyzer_toolchain"), |
| toolchain_type = "@rules_rust//rust/rust_analyzer:toolchain_type", |
| exec_compatible_with = exec_compatible_with, |
| target_compatible_with = target_compatible_with, |
| ) |
| |
| return "@{}//:toolchain".format( |
| name, |
| ) |
| |
| _RUSTFMT_TOOLCHAIN_TOOLS_ATTRS = { |
| "auth": attr.string_dict( |
| doc = ( |
| "Auth object compatible with repository_ctx.download to use when downloading files. " + |
| "See [repository_ctx.download](https://docs.bazel.build/versions/main/skylark/lib/repository_ctx.html#download) for more details." |
| ), |
| ), |
| "auth_patterns": attr.string_dict( |
| doc = "Override mapping of hostnames to authorization patterns; mirrors the eponymous attribute from http_archive", |
| ), |
| "exec_triple": attr.string( |
| doc = "The Rust-style triple Rustfmt is expected to run on.", |
| mandatory = True, |
| ), |
| "netrc": attr.string( |
| doc = ".netrc file to use for authentication; mirrors the eponymous attribute from http_archive", |
| ), |
| "sha256s": attr.string_dict( |
| doc = "A dict associating tool subdirectories to sha256 hashes. See [rust_register_toolchains](#rust_register_toolchains) for more details.", |
| ), |
| "urls": attr.string_list( |
| doc = "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).", |
| default = DEFAULT_STATIC_RUST_URL_TEMPLATES, |
| ), |
| "version": attr.string( |
| doc = "The version of the tool among \"nightly\", \"beta\" with an iso date, or an exact version.", |
| mandatory = True, |
| ), |
| } |
| |
| def _rustfmt_toolchain_tools_repository_impl(repository_ctx): |
| sha256s = dict(repository_ctx.attr.sha256s) |
| repository_ctx.file("WORKSPACE.bazel", """workspace(name = "{}")""".format( |
| repository_ctx.name, |
| )) |
| |
| iso_date = None |
| version = repository_ctx.attr.version |
| version_array = version.split("/") |
| if len(version_array) > 1: |
| version = version_array[0] |
| iso_date = version_array[1] |
| |
| rustfmt = "//:rustfmt_bin" |
| rustc = "//:rustc" |
| rustc_lib = "//:rustc_lib" |
| |
| exec_triple = triple(repository_ctx.attr.exec_triple) |
| |
| rustc_content, rustc_sha256 = load_rust_compiler( |
| ctx = repository_ctx, |
| iso_date = iso_date, |
| target_triple = exec_triple, |
| version = version, |
| ) |
| rustfmt_content, rustfmt_sha256 = load_rustfmt( |
| ctx = repository_ctx, |
| iso_date = iso_date, |
| target_triple = exec_triple, |
| version = version, |
| ) |
| |
| build_contents = [ |
| rustc_content, |
| rustfmt_content, |
| BUILD_for_rustfmt_toolchain( |
| name = "rustfmt_toolchain", |
| rustfmt = rustfmt, |
| rustc = rustc, |
| rustc_lib = rustc_lib, |
| ), |
| ] |
| sha256s.update(rustc_sha256 | rustfmt_sha256) |
| |
| repository_ctx.file("BUILD.bazel", "\n".join(build_contents)) |
| repository_ctx.file("WORKSPACE.bazel", """workspace(name = "{}")""".format( |
| repository_ctx.name, |
| )) |
| |
| repro = {"name": repository_ctx.name} |
| for key in _RUSTFMT_TOOLCHAIN_TOOLS_ATTRS: |
| repro[key] = getattr(repository_ctx.attr, key) |
| repro["sha256s"] = sha256s |
| |
| return repro |
| |
| rustfmt_toolchain_tools_repository = repository_rule( |
| doc = "A repository rule for defining a rustfmt_toolchain.", |
| attrs = _RUSTFMT_TOOLCHAIN_TOOLS_ATTRS, |
| implementation = _rustfmt_toolchain_tools_repository_impl, |
| ) |
| |
| def rustfmt_toolchain_repository( |
| name, |
| version, |
| exec_triple, |
| exec_compatible_with = None, |
| target_compatible_with = None, |
| channel = None, |
| sha256s = None, |
| urls = None, |
| auth = None, |
| netrc = None, |
| auth_patterns = None): |
| """Assemble a remote rustfmt_toolchain target based on the given params. |
| |
| Args: |
| name (str): The name of the toolchain proxy repository contianing the registerable toolchain. |
| version (str): The version of the tool among "nightly", "beta', or an exact version. |
| exec_triple (str): The platform triple Rustfmt is expected to run on. |
| exec_compatible_with (list, optional): A list of constraints for the execution platform for this toolchain. |
| target_compatible_with (list, optional): A list of constraints for the target platform for this toolchain. |
| channel (str, optional): The channel value to with which to constrain the toolchain. |
| sha256s (str, optional): A dict associating tool subdirectories to sha256 hashes. See |
| [rust_register_toolchains](#rust_register_toolchains) for more details. |
| urls (list, optional): 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'] |
| auth (dict): Auth object compatible with repository_ctx.download to use when downloading files. |
| See [repository_ctx.download](https://docs.bazel.build/versions/main/skylark/lib/repository_ctx.html#download) for more details. |
| netrc (str, optional): .netrc file to use for authentication; mirrors the eponymous attribute from http_archive |
| auth_patterns (dict, optional): Override mapping of hostnames to authorization patterns; mirrors the eponymous attribute from http_archive |
| |
| Returns: |
| str: The name of a registerable rustfmt_toolchain. |
| """ |
| if exec_compatible_with == None: |
| exec_compatible_with = triple_to_constraint_set(exec_triple) |
| |
| rustfmt_toolchain_tools_repository( |
| name = name + "_tools", |
| version = version, |
| sha256s = sha256s, |
| urls = urls, |
| auth = auth, |
| netrc = netrc, |
| auth_patterns = auth_patterns, |
| exec_triple = exec_triple, |
| ) |
| |
| toolchain_repository_proxy( |
| name = name, |
| toolchain = "@{}//:{}".format(name + "_tools", "rustfmt_toolchain"), |
| toolchain_type = "@rules_rust//rust/rustfmt:toolchain_type", |
| target_settings = ["@rules_rust//rust/toolchain/channel:{}".format(channel)] if channel else None, |
| exec_compatible_with = exec_compatible_with, |
| target_compatible_with = target_compatible_with, |
| ) |
| |
| return "@{}//:toolchain".format( |
| name, |
| ) |
| |
| def _rust_toolchain_set_repository_impl(repository_ctx): |
| repository_ctx.file("WORKSPACE.bazel", """workspace(name = "{}")""".format( |
| repository_ctx.name, |
| )) |
| |
| repository_ctx.file("BUILD.bazel", """exports_files(["defs.bzl"])""") |
| repository_ctx.file("defs.bzl", "ALL_TOOLCHAINS = {}\n".format( |
| json.encode_indent(repository_ctx.attr.toolchains, indent = " " * 4), |
| )) |
| |
| rust_toolchain_set_repository = repository_rule( |
| doc = ( |
| "Generates a toolchain-bearing repository that declares the toolchains from some other " + |
| "rust_toolchain_repository." |
| ), |
| attrs = { |
| "toolchains": attr.string_list( |
| doc = "The list of all toolchains created by the current `rust_toolchain_set`", |
| mandatory = True, |
| ), |
| }, |
| implementation = _rust_toolchain_set_repository_impl, |
| ) |
| |
| def _get_toolchain_repositories(name, exec_triple, extra_target_triples, versions, fallback_target_compatible_with): |
| extra_target_triples_list = extra_target_triples.keys() if type(extra_target_triples) == "dict" else extra_target_triples |
| |
| toolchain_repos = [] |
| |
| for target_triple in depset([exec_triple] + extra_target_triples_list).to_list(): |
| # Parse all provided versions while checking for duplicates |
| channels = {} |
| for version in versions: |
| if version.startswith(("beta", "nightly")): |
| channel, _, _ = version.partition("/") |
| else: |
| channel = "stable" |
| |
| if channel in channels: |
| fail("Duplicate {} channels provided for {}: {}".format(channel, name, versions)) |
| |
| channels.update({channel: struct( |
| name = channel, |
| version = version, |
| )}) |
| |
| if type(extra_target_triples) == "dict" and target_triple in extra_target_triples: |
| target_constraints = extra_target_triples[target_triple] |
| elif fallback_target_compatible_with != None: |
| target_constraints = fallback_target_compatible_with |
| else: |
| target_constraints = triple_to_constraint_set(target_triple) |
| |
| # Define toolchains for each requested version |
| for channel in channels.values(): |
| toolchain_repos.append(struct( |
| name = "{}__{}__{}".format(name, target_triple, channel.name), |
| target_triple = target_triple, |
| channel = channel, |
| target_constraints = target_constraints, |
| )) |
| |
| return toolchain_repos |
| |
| def rust_repository_set( |
| name, |
| versions, |
| exec_triple, |
| target_settings = [], |
| allocator_library = None, |
| global_allocator_library = None, |
| extra_target_triples = {}, |
| rustfmt_version = None, |
| edition = None, |
| dev_components = False, |
| extra_rustc_flags = None, |
| extra_exec_rustc_flags = None, |
| opt_level = None, |
| sha256s = None, |
| urls = DEFAULT_STATIC_RUST_URL_TEMPLATES, |
| auth = None, |
| netrc = None, |
| auth_patterns = None, |
| register_toolchain = True, |
| exec_compatible_with = None, |
| default_target_compatible_with = None): |
| """Assembles a remote repository for the given toolchain params, produces a proxy repository \ |
| to contain the toolchain declaration, and registers the toolchains. |
| |
| Args: |
| name (str): The name of the generated repository |
| versions (list, optional): 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"]`. |
| exec_triple (str): The Rust-style target that this compiler runs on |
| target_settings (list, optional): 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 (str, optional): Target that provides allocator functions when rust_library targets are |
| embedded in a cc_binary. |
| global_allocator_library (str, optional): Target that provides allocator functions a global allocator is used with cc_common.link. |
| extra_target_triples (list or map, optional): 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 (str, optional): The version of rustfmt to be associated with the |
| toolchain. |
| edition (str, optional): The rust edition to be used by default (2015, 2018, or 2021). If absent, every rule is |
| required to specify its `edition` attribute. |
| dev_components (bool, optional): Whether to download the rustc-dev components. |
| Requires version to be "nightly". |
| extra_rustc_flags (dict, list, optional): Dictionary of target triples to list of extra flags to pass to rustc in non-exec configuration. |
| extra_exec_rustc_flags (list, optional): Extra flags to pass to rustc in exec configuration. |
| opt_level (dict, dict, optional): Dictionary of target triples to optimiztion config. |
| sha256s (str, optional): A dict associating tool subdirectories to sha256 hashes. See |
| [rust_register_toolchains](#rust_register_toolchains) for more details. |
| urls (list, optional): 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). |
| auth (dict): Auth object compatible with repository_ctx.download to use when downloading files. |
| See [repository_ctx.download](https://docs.bazel.build/versions/main/skylark/lib/repository_ctx.html#download) for more details. |
| netrc (str, optional): .netrc file to use for authentication; mirrors the eponymous attribute from http_archive |
| auth_patterns (dict, optional): Override mapping of hostnames to authorization patterns; mirrors the eponymous attribute from http_archive |
| |
| register_toolchain (bool): If True, the generated `rust_toolchain` target will become a registered toolchain. |
| exec_compatible_with (list, optional): A list of constraints for the execution platform for this toolchain. |
| default_target_compatible_with (list, optional): A list of constraints for the target platform for this toolchain when the exec platform is the same as the target platform. |
| """ |
| |
| all_toolchain_names = [] |
| for toolchain in _get_toolchain_repositories(name, exec_triple, extra_target_triples, versions, default_target_compatible_with): |
| # Infer toolchain-specific rustc flags depending on the type (list, dict, optional) of extra_rustc_flags |
| if extra_rustc_flags == None: |
| toolchain_extra_rustc_flags = [] |
| elif type(extra_rustc_flags) == "list": |
| toolchain_extra_rustc_flags = extra_rustc_flags |
| elif type(extra_rustc_flags) == "dict": |
| toolchain_extra_rustc_flags = extra_rustc_flags.get(toolchain.target_triple) |
| else: |
| fail("extra_rustc_flags should be a list or a dict") |
| |
| all_toolchain_names.append(rust_toolchain_repository( |
| name = toolchain.name, |
| allocator_library = allocator_library, |
| global_allocator_library = global_allocator_library, |
| auth = auth, |
| netrc = netrc, |
| auth_patterns = auth_patterns, |
| channel = toolchain.channel.name, |
| dev_components = dev_components, |
| edition = edition, |
| exec_triple = exec_triple, |
| extra_exec_rustc_flags = extra_exec_rustc_flags, |
| extra_rustc_flags = toolchain_extra_rustc_flags, |
| opt_level = opt_level.get(toolchain.target_triple) if opt_level != None else None, |
| target_settings = target_settings, |
| rustfmt_version = rustfmt_version, |
| sha256s = sha256s, |
| target_triple = toolchain.target_triple, |
| urls = urls, |
| version = toolchain.channel.version, |
| exec_compatible_with = exec_compatible_with, |
| target_compatible_with = toolchain.target_constraints, |
| )) |
| |
| # This repository exists to allow `rust_repository_set` to work with the `maybe` wrapper. |
| rust_toolchain_set_repository( |
| name = name, |
| toolchains = all_toolchain_names, |
| ) |
| |
| # Register toolchains |
| if register_toolchain: |
| native.register_toolchains(*all_toolchain_names) |
| native.register_toolchains(str(Label("//rust/private/dummy_cc_toolchain:dummy_cc_wasm32_toolchain"))) |
| native.register_toolchains(str(Label("//rust/private/dummy_cc_toolchain:dummy_cc_wasm64_toolchain"))) |
