rust/repositories.bzl - platform/external/bazelbuild-rules_rust - Git at Google

 load(":known_shas.bzl", "FILE_KEY_TO_SHA")
 load("//rust/platform:triple_mappings.bzl", "system_to_binary_ext", "system_to_dylib_ext", "system_to_staticlib_ext", "system_to_stdlib_linkflags", "triple_to_constraint_set", "triple_to_system")
 load("@bazel_tools//tools/build_defs/repo:utils.bzl", "maybe")
 load("@bazel_tools//tools/build_defs/repo:http.bzl", "http_archive")

 DEFAULT_TOOLCHAIN_NAME_PREFIX = "toolchain_for"

 def rust_repositories(version = "1.44.0", iso_date = None, rustfmt_version = "1.4.8", edition = None, dev_components = False):
     """Emits a default set of toolchains for Linux, OSX, 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.

     Args:
       version: The version of Rust. Either "nightly", "beta", or an exact version.
       rustfmt_version: The version of rustfmt. Either "nightly", "beta", or an exact version.
       iso_date: The date of the nightly or beta release (or None, if the version is a specific version).
       edition: The rust edition to be used by default (2015 (default) or 2018)
       dev_components: Whether to download the rustc-dev components (defaults to False). Requires version to be "nightly".
     """

     if dev_components and version != "nightly":
         fail("Rust version must be set to \"nightly\" to enable rustc-dev components")

     maybe(
         http_archive,
         name = "rules_cc",
         url = "https://github.com/bazelbuild/rules_cc/archive/624b5d59dfb45672d4239422fa1e3de1822ee110.zip",
         sha256 = "8c7e8bf24a2bf515713445199a677ee2336e1c487fa1da41037c6026de04bbc3",
         strip_prefix = "rules_cc-624b5d59dfb45672d4239422fa1e3de1822ee110",
         type = "zip",
     )

     rust_repository_set(
         name = "rust_linux_x86_64",
         exec_triple = "x86_64-unknown-linux-gnu",
         extra_target_triples = ["wasm32-unknown-unknown"],
         version = version,
         iso_date = iso_date,
         rustfmt_version = rustfmt_version,
         edition = edition,
         dev_components = dev_components,
     )

     rust_repository_set(
         name = "rust_darwin_x86_64",
         exec_triple = "x86_64-apple-darwin",
         extra_target_triples = ["wasm32-unknown-unknown"],
         version = version,
         iso_date = iso_date,
         rustfmt_version = rustfmt_version,
         edition = edition,
         dev_components = dev_components,
     )

     rust_repository_set(
         name = "rust_freebsd_x86_64",
         exec_triple = "x86_64-unknown-freebsd",
         extra_target_triples = ["wasm32-unknown-unknown"],
         version = version,
         iso_date = iso_date,
         rustfmt_version = rustfmt_version,
         edition = edition,
         dev_components = dev_components,
     )

     rust_repository_set(
         name = "rust_windows_x86_64",
         exec_triple = "x86_64-pc-windows-msvc",
         extra_target_triples = ["wasm32-unknown-unknown"],
         version = version,
         iso_date = iso_date,
         rustfmt_version = rustfmt_version,
     )

 def _check_version_valid(version, iso_date, param_prefix = ""):
     """Verifies that the provided rust version and iso_date make sense."""

     if not version and iso_date:
         fail("{param_prefix}iso_date must be paired with a {param_prefix}version".format(param_prefix = param_prefix))

     if version in ("beta", "nightly") and not iso_date:
         fail("{param_prefix}iso_date must be specified if version is 'beta' or 'nightly'".format(param_prefix = param_prefix))

     if version not in ("beta", "nightly") and iso_date:
         print("{param_prefix}iso_date is ineffective if an exact version is specified".format(param_prefix = param_prefix))

 def serialized_constraint_set_from_triple(target_triple):
     constraint_set = triple_to_constraint_set(target_triple)
     constraint_set_strs = []
     for constraint in constraint_set:
         constraint_set_strs.append("\"{}\"".format(constraint))
     return "[{}]".format(", ".join(constraint_set_strs))

 def BUILD_for_compiler(target_triple):
     """Emits a BUILD file the compiler .tar.gz."""

     system = triple_to_system(target_triple)
     return """
 load("@io_bazel_rules_rust//rust:toolchain.bzl", "rust_toolchain")

 filegroup(
     name = "rustc",
     srcs = ["bin/rustc{binary_ext}"],
     visibility = ["//visibility:public"],
 )

 filegroup(
     name = "rustc_lib",
     srcs = glob(
         [
             "lib/*{dylib_ext}",
             "lib/rustlib/{target_triple}/codegen-backends/*{dylib_ext}",
         ],
         allow_empty = True,
     ),
     visibility = ["//visibility:public"],
 )

 filegroup(
     name = "rustdoc",
     srcs = ["bin/rustdoc{binary_ext}"],
     visibility = ["//visibility:public"],
 )
 """.format(
         binary_ext = system_to_binary_ext(system),
         staticlib_ext = system_to_staticlib_ext(system),
         dylib_ext = system_to_dylib_ext(system),
         target_triple = target_triple,
     )

 def BUILD_for_rustfmt(target_triple):
     """Emits a BUILD file the rustfmt .tar.gz."""

     system = triple_to_system(target_triple)
     return """
 load("@io_bazel_rules_rust//rust:toolchain.bzl", "rust_toolchain")

 filegroup(
     name = "rustfmt_bin",
     srcs = ["bin/rustfmt{binary_ext}"],
     visibility = ["//visibility:public"],
 )

 sh_binary(
     name = "rustfmt",
     srcs = [":rustfmt_bin"],
     visibility = ["//visibility:public"],
 )
 """.format(
         binary_ext = system_to_binary_ext(system),
     )

 def BUILD_for_clippy(target_triple):
     """Emits a BUILD file the clippy's extracted files."""

     system = triple_to_system(target_triple)
     return """
 load("@io_bazel_rules_rust//rust:toolchain.bzl", "rust_toolchain")

 filegroup(
     name = "clippy_driver_bin",
     srcs = ["bin/clippy-driver{binary_ext}"],
     visibility = ["//visibility:public"],
 )
 """.format(binary_ext = system_to_binary_ext(system))

 def BUILD_for_stdlib(target_triple):
     """Emits a BUILD file the stdlib .tar.gz."""

     system = triple_to_system(target_triple)
     return """
 filegroup(
     name = "rust_lib-{target_triple}",
     srcs = glob(
         [
             "lib/rustlib/{target_triple}/lib/*.rlib",
             "lib/rustlib/{target_triple}/lib/*{dylib_ext}",
             "lib/rustlib/{target_triple}/lib/*{staticlib_ext}",
         ],
         # Some patterns (e.g. `lib/*.a`) don't match anything, see https://github.com/bazelbuild/rules_rust/pull/245
         allow_empty = True,
     ),
     visibility = ["//visibility:public"],
 )
 """.format(
         binary_ext = system_to_binary_ext(system),
         staticlib_ext = system_to_staticlib_ext(system),
         dylib_ext = system_to_dylib_ext(system),
         target_triple = target_triple,
     )

 def BUILD_for_rust_toolchain(workspace_name, name, exec_triple, target_triple,
                              stdlib_linkflags=None, default_edition = "2015"):
     """Emits a toolchain declaration to match an existing compiler and stdlib.

     Args:
       workspace_name: The name of the workspace that this toolchain resides in
       name: The name of the toolchain declaration
       exec_triple: The rust-style target that this compiler runs on
       target_triple: The rust-style target triple of the tool
       stdlib_linkflags: Overriden flags needed for linking to rust stdlib, akin to BAZEL_LINKLIBS
     """

     system = triple_to_system(target_triple)
     if stdlib_linkflags == None:
         stdlib_linkflags = ", ".join(['"%s"' % x for x in system_to_stdlib_linkflags(system)])

     return """
 rust_toolchain(
     name = "{toolchain_name}_impl",
     rust_doc = "@{workspace_name}//:rustdoc",
     rust_lib = "@{workspace_name}//:rust_lib-{target_triple}",
     rustc = "@{workspace_name}//:rustc",
     rustfmt = "@{workspace_name}//:rustfmt_bin",
     clippy_driver = "@{workspace_name}//:clippy_driver_bin",
     rustc_lib = "@{workspace_name}//:rustc_lib",
     binary_ext = "{binary_ext}",
     staticlib_ext = "{staticlib_ext}",
     dylib_ext = "{dylib_ext}",
     stdlib_linkflags = [{stdlib_linkflags}],
     os = "{system}",
     default_edition = "{default_edition}",
     exec_triple = "{exec_triple}",
     target_triple = "{target_triple}",
     visibility = ["//visibility:public"],
 )
 """.format(
         toolchain_name = name,
         workspace_name = workspace_name,
         binary_ext = system_to_binary_ext(system),
         staticlib_ext = system_to_staticlib_ext(system),
         dylib_ext = system_to_dylib_ext(system),
         stdlib_linkflags = stdlib_linkflags,
         system = system,
         default_edition = default_edition,
         exec_triple = exec_triple,
         target_triple = target_triple,
     )

 def BUILD_for_toolchain(name, parent_workspace_name, exec_triple, target_triple):
     return """
 toolchain(
     name = "{name}",
     exec_compatible_with = {exec_constraint_sets_serialized},
     target_compatible_with = {target_constraint_sets_serialized},
     toolchain = "@{parent_workspace_name}//:{name}_impl",
     toolchain_type = "@io_bazel_rules_rust//rust:toolchain",
 )
 """.format(
         name = name,
         exec_constraint_sets_serialized = serialized_constraint_set_from_triple(exec_triple),
         target_constraint_sets_serialized = serialized_constraint_set_from_triple(target_triple),
         parent_workspace_name = parent_workspace_name,
     )

 def produce_tool_suburl(tool_name, target_triple, version, iso_date = None):
     """Produces a fully qualified Rust tool name for URL

     Args:
       tool_name: The name of the tool per static.rust-lang.org
       target_triple: The rust-style target triple of the tool
       version: The version of the tool among "nightly", "beta', or an exact version.
       iso_date: The date of the tool (or None, if the version is a specific version).
     """

     if iso_date:
         return "{}/{}-{}-{}".format(iso_date, tool_name, version, target_triple)
     else:
         return "{}-{}-{}".format(tool_name, version, target_triple)

 def produce_tool_path(tool_name, target_triple, version):
     """Produces a qualified Rust tool name

     Args:
       tool_name: The name of the tool per static.rust-lang.org
       target_triple: The rust-style target triple of the tool
       version: The version of the tool among "nightly", "beta', or an exact version.
     """

     return "{}-{}-{}".format(tool_name, version, target_triple)

 def load_arbitrary_tool(ctx, tool_name, tool_subdirectories, version, iso_date, target_triple, sha256 = ""):
     """Loads a Rust tool, downloads, and extracts into the common workspace.

     This function sources the tool from the Rust-lang static file server. The index is available
     at: https://static.rust-lang.org/dist/index.html (or the path specified by
     "${RUST_STATIC_URL}/dist/index.html" if the RUST_STATIC_URL envinronment variable is set).

     Args:
       ctx: A repository_ctx (no attrs required).
       tool_name: The name of the given tool per the archive naming.
       param_prefix: The name of the versioning param if the repository rule supports multiple tools.
       tool_subdirectories: The subdirectories of the tool files (at a level below the root directory of
                            the archive). The root directory of the archive is expected to match
                            $TOOL_NAME-$VERSION-$TARGET_TRIPLE.
                            Example:
                               tool_name
                               |    version
                               |    |      target_triple
                               v    v      v
                               rust-1.39.0-x86_64-unknown-linux-gnu/clippy-preview
                                                                .../rustc
                                                                .../etc
                               tool_subdirectories = ["clippy-preview", "rustc"]
       version: The version of the tool among "nightly", "beta', or an exact version.
       iso_date: The date of the tool (or None, if the version is a specific version).
       target_triple: The rust-style target triple of the tool
     """

     _check_version_valid(version, iso_date, param_prefix = tool_name + "_")

     # N.B. See https://static.rust-lang.org/dist/index.html to find the tool_suburl for a given
     # tool.
     tool_suburl = produce_tool_suburl(tool_name, target_triple, version, iso_date)
     static_rust = ctx.os.environ["STATIC_RUST_URL"] if "STATIC_RUST_URL" in ctx.os.environ else "https://static.rust-lang.org"
     url = "{}/dist/{}.tar.gz".format(static_rust, tool_suburl)

     tool_path = produce_tool_path(tool_name, target_triple, version)
     archive_path = tool_path + ".tar.gz"
     ctx.download(
         url,
         output = archive_path,
         sha256 = FILE_KEY_TO_SHA.get(tool_suburl) or sha256,
     )
     for subdirectory in tool_subdirectories:
         ctx.extract(
             archive_path,
             output = "",
             stripPrefix = "{}/{}".format(tool_path, subdirectory),
         )

 def _load_rustfmt(ctx):
     target_triple = ctx.attr.exec_triple

     if ctx.attr.rustfmt_version in ("beta", "nightly"):
         iso_date = ctx.attr.iso_date
     else:
         iso_date = None

     load_arbitrary_tool(
         ctx,
         iso_date = iso_date,
         target_triple = target_triple,
         tool_name = "rustfmt",
         tool_subdirectories = ["rustfmt-preview"],
         version = ctx.attr.rustfmt_version,
     )

     return BUILD_for_rustfmt(target_triple)

 def _load_rust_compiler(ctx):
     """Loads a rust compiler and yields corresponding BUILD for it

     Args:
       ctx: A repository_ctx.
     Returns:
       The BUILD file contents for this compiler and compiler library
     """

     target_triple = ctx.attr.exec_triple
     load_arbitrary_tool(
         ctx,
         iso_date = ctx.attr.iso_date,
         target_triple = target_triple,
         tool_name = "rust",
         tool_subdirectories = ["rustc", "clippy-preview"],
         version = ctx.attr.version,
     )

     compiler_BUILD = BUILD_for_compiler(target_triple) + BUILD_for_clippy(target_triple)

     return compiler_BUILD

 def _load_rust_stdlib(ctx, target_triple):
     """Loads a rust standard library and yields corresponding BUILD for it

     Args:
       ctx: A repository_ctx.
       target_triple: The rust-style target triple of the tool
     Returns:
       The BUILD file contents for this stdlib, and a toolchain decl to match
     """

     load_arbitrary_tool(
         ctx,
         iso_date = ctx.attr.iso_date,
         target_triple = target_triple,
         tool_name = "rust-std",
         tool_subdirectories = ["rust-std-{}".format(target_triple)],
         version = ctx.attr.version,
     )

     toolchain_prefix = ctx.attr.toolchain_name_prefix or DEFAULT_TOOLCHAIN_NAME_PREFIX
     stdlib_BUILD = BUILD_for_stdlib(target_triple)

     stdlib_linkflags = None
     if 'BAZEL_RUST_STDLIB_LINKFLAGS' in ctx.os.environ:
         stdlib_linkflags = ctx.os.environ['BAZEL_RUST_STDLIB_LINKFLAGS'].split(':')

     toolchain_BUILD = BUILD_for_rust_toolchain(
         name = "{toolchain_prefix}_{target_triple}".format(
             toolchain_prefix = toolchain_prefix,
             target_triple = target_triple,
         ),
         exec_triple = ctx.attr.exec_triple,
         target_triple = target_triple,
         stdlib_linkflags = stdlib_linkflags,
         workspace_name = ctx.attr.name,
         default_edition = ctx.attr.edition,
     )

     return stdlib_BUILD + toolchain_BUILD

 def _load_rustc_dev_nightly(ctx, target_triple):
     """Loads the nightly rustc dev component

     Args:
       ctx: A repository_ctx.
       target_triple: The rust-style target triple of the tool
     """

     load_arbitrary_tool(
         ctx,
         iso_date = ctx.attr.iso_date,
         target_triple = target_triple,
         tool_name = "rustc-dev",
         tool_subdirectories = ["rustc-dev-{}".format(target_triple)],
         version = ctx.attr.version,
     )

     return

 def _load_llvm_tools(ctx, target_triple):
     """Loads the llvm tools

     Args:
       ctx: A repository_ctx.
       target_triple: The rust-style target triple of the tool
     """

     load_arbitrary_tool(
         ctx,
         iso_date = ctx.attr.iso_date,
         target_triple = target_triple,
         tool_name = "llvm-tools",
         tool_subdirectories = ["llvm-tools-preview"],
         version = ctx.attr.version,
     )

     return

 def _rust_toolchain_repository_impl(ctx):
     """The implementation of the rust toolchain repository rule."""

     _check_version_valid(ctx.attr.version, ctx.attr.iso_date)

     BUILD_components = [_load_rust_compiler(ctx)]

     if ctx.attr.rustfmt_version:
         BUILD_components.append(_load_rustfmt(ctx))

     # Nightly Rust builds after 2020-05-22 need the llvm-tools gzip to get the libLLVM dylib
     if ctx.attr.version == "nightly" and ctx.attr.iso_date > "2020-05-22":
             _load_llvm_tools(ctx, ctx.attr.exec_triple)

     for target_triple in [ctx.attr.exec_triple] + ctx.attr.extra_target_triples:
         BUILD_components.append(_load_rust_stdlib(ctx, target_triple))

         # extra_target_triples contains targets such as wasm, which don't have rustc_dev components
         if ctx.attr.dev_components and target_triple not in ctx.attr.extra_target_triples:
             _load_rustc_dev_nightly(ctx, target_triple)

     ctx.file("WORKSPACE", "")
     ctx.file("BUILD", "\n".join(BUILD_components))

 def _rust_toolchain_repository_proxy_impl(ctx):
     BUILD_components = []
     for target_triple in [ctx.attr.exec_triple] + ctx.attr.extra_target_triples:
         BUILD_components.append(BUILD_for_toolchain(
             name = "{toolchain_prefix}_{target_triple}".format(
                 toolchain_prefix = ctx.attr.toolchain_name_prefix,
                 target_triple = target_triple,
             ),
             exec_triple = ctx.attr.exec_triple,
             parent_workspace_name = ctx.attr.parent_workspace_name,
             target_triple = target_triple,
         ))

     ctx.file("WORKSPACE", "")
     ctx.file("BUILD", "\n".join(BUILD_components))

 """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 rust_toolchain_repository_proxy
 invocation to declare its toolchains to Bazel; the indirection allows separating toolchain
 selection from toolchain fetching

 Args:
   name: A unique name for this rule
   version: The version of the tool among "nightly", "beta', or an exact version.
   rustfmt_version: The version of rustfmt to be associated with the toolchain.
   iso_date: The date of the tool (or None, if the version is a specific version).
   exec_triple: The Rust-style target triple for the compilation platform
   extra_target_triples: The Rust-style triples for extra compilation targets
   toolchain_name_prefix: The per-target prefix expected for the rust_toolchain declarations
   edition: The rust edition to be used by default (2015 (default) or 2018)
 """

 rust_toolchain_repository = repository_rule(
     attrs = {
         "version": attr.string(mandatory = True),
         "rustfmt_version": attr.string(),
         "iso_date": attr.string(),
         "exec_triple": attr.string(mandatory = True),
         "extra_target_triples": attr.string_list(),
         "toolchain_name_prefix": attr.string(),
         "edition": attr.string(default = "2015"),
         "dev_components": attr.bool(default = False),
     },
     implementation = _rust_toolchain_repository_impl,
 )

 """Generates a toolchain-bearing repository that declares the toolchains from some other
 rust_toolchain_repository.

 Args:
   name: A unique name for this rule
   parent_workspace_name: The name of the other rust_toolchain_repository
   exec_triple: The Rust-style target triple for the compilation platform
   extra_target_triples: The Rust-style triples for extra compilation targets
   toolchain_name_prefix: The per-target prefix expected for the rust_toolchain declarations in the
                          parent workspace.
 """

 rust_toolchain_repository_proxy = repository_rule(
     attrs = {
         "parent_workspace_name": attr.string(mandatory = True),
         "exec_triple": attr.string(mandatory = True),
         "extra_target_triples": attr.string_list(),
         "toolchain_name_prefix": attr.string(),
     },
     implementation = _rust_toolchain_repository_proxy_impl,
 )

 def rust_repository_set(
         name,
         version,
         exec_triple,
         extra_target_triples = [],
         iso_date = None,
         rustfmt_version = None,
         edition = None,
         dev_components = False):
     """Assembles a remote repository for the given toolchain params, produces a proxy repository
     to contain the toolchain declaration, and registers the toolchains.

     N.B. A "proxy repository" is needed to allow for registering the toolchain (with constraints)
     without actually downloading the toolchain.

     Args:
       name: The name of the generated repository
       version: The version of the tool among "nightly", "beta', or an exact version.
       iso_date: The date of the tool (or None, if the version is a specific version).
       exec_triple: The Rust-style target that this compiler runs on
       extra_target_triples: Additional rust-style targets that this set of toolchains
                             should support.
       rustfmt_version: The version of rustfmt to be associated with the toolchain.
       edition: The rust edition to be used by default (2015 (default) or 2018)
       dev_components: Whether to download the rustc-dev components (defaults to False).
                       Requires version to be "nightly".
     """

     rust_toolchain_repository(
         name = name,
         exec_triple = exec_triple,
         extra_target_triples = extra_target_triples,
         iso_date = iso_date,
         toolchain_name_prefix = DEFAULT_TOOLCHAIN_NAME_PREFIX,
         version = version,
         rustfmt_version = rustfmt_version,
         edition = edition,
         dev_components = dev_components,
     )

     rust_toolchain_repository_proxy(
         name = name + "_toolchains",
         exec_triple = exec_triple,
         extra_target_triples = extra_target_triples,
         parent_workspace_name = name,
         toolchain_name_prefix = DEFAULT_TOOLCHAIN_NAME_PREFIX,
     )

     all_toolchain_names = []
     for target_triple in [exec_triple] + extra_target_triples:
         all_toolchain_names.append("@{name}_toolchains//:{toolchain_name_prefix}_{triple}".format(
             name = name,
             toolchain_name_prefix = DEFAULT_TOOLCHAIN_NAME_PREFIX,
             triple = target_triple,
         ))

     # Register toolchains
     native.register_toolchains(*all_toolchain_names)
     native.register_toolchains("@io_bazel_rules_rust//rust/private/dummy_cc_toolchain:dummy_cc_wasm32_toolchain")
	load(":known_shas.bzl", "FILE_KEY_TO_SHA")
	load("//rust/platform:triple_mappings.bzl", "system_to_binary_ext", "system_to_dylib_ext", "system_to_staticlib_ext", "system_to_stdlib_linkflags", "triple_to_constraint_set", "triple_to_system")
	load("@bazel_tools//tools/build_defs/repo:utils.bzl", "maybe")
	load("@bazel_tools//tools/build_defs/repo:http.bzl", "http_archive")

	DEFAULT_TOOLCHAIN_NAME_PREFIX = "toolchain_for"

	def rust_repositories(version = "1.44.0", iso_date = None, rustfmt_version = "1.4.8", edition = None, dev_components = False):
	"""Emits a default set of toolchains for Linux, OSX, 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.

	Args:
	version: The version of Rust. Either "nightly", "beta", or an exact version.
	rustfmt_version: The version of rustfmt. Either "nightly", "beta", or an exact version.
	iso_date: The date of the nightly or beta release (or None, if the version is a specific version).
	edition: The rust edition to be used by default (2015 (default) or 2018)
	dev_components: Whether to download the rustc-dev components (defaults to False). Requires version to be "nightly".
	"""

	if dev_components and version != "nightly":
	fail("Rust version must be set to \"nightly\" to enable rustc-dev components")

	maybe(
	http_archive,
	name = "rules_cc",
	url = "https://github.com/bazelbuild/rules_cc/archive/624b5d59dfb45672d4239422fa1e3de1822ee110.zip",
	sha256 = "8c7e8bf24a2bf515713445199a677ee2336e1c487fa1da41037c6026de04bbc3",
	strip_prefix = "rules_cc-624b5d59dfb45672d4239422fa1e3de1822ee110",
	type = "zip",
	)

	rust_repository_set(
	name = "rust_linux_x86_64",
	exec_triple = "x86_64-unknown-linux-gnu",
	extra_target_triples = ["wasm32-unknown-unknown"],
	version = version,
	iso_date = iso_date,
	rustfmt_version = rustfmt_version,
	edition = edition,
	dev_components = dev_components,
	)

	rust_repository_set(
	name = "rust_darwin_x86_64",
	exec_triple = "x86_64-apple-darwin",
	extra_target_triples = ["wasm32-unknown-unknown"],
	version = version,
	iso_date = iso_date,
	rustfmt_version = rustfmt_version,
	edition = edition,
	dev_components = dev_components,
	)

	rust_repository_set(
	name = "rust_freebsd_x86_64",
	exec_triple = "x86_64-unknown-freebsd",
	extra_target_triples = ["wasm32-unknown-unknown"],
	version = version,
	iso_date = iso_date,
	rustfmt_version = rustfmt_version,
	edition = edition,
	dev_components = dev_components,
	)

	rust_repository_set(
	name = "rust_windows_x86_64",
	exec_triple = "x86_64-pc-windows-msvc",
	extra_target_triples = ["wasm32-unknown-unknown"],
	version = version,
	iso_date = iso_date,
	rustfmt_version = rustfmt_version,
	)

	def _check_version_valid(version, iso_date, param_prefix = ""):
	"""Verifies that the provided rust version and iso_date make sense."""

	if not version and iso_date:
	fail("{param_prefix}iso_date must be paired with a {param_prefix}version".format(param_prefix = param_prefix))

	if version in ("beta", "nightly") and not iso_date:
	fail("{param_prefix}iso_date must be specified if version is 'beta' or 'nightly'".format(param_prefix = param_prefix))

	if version not in ("beta", "nightly") and iso_date:
	print("{param_prefix}iso_date is ineffective if an exact version is specified".format(param_prefix = param_prefix))

	def serialized_constraint_set_from_triple(target_triple):
	constraint_set = triple_to_constraint_set(target_triple)
	constraint_set_strs = []
	for constraint in constraint_set:
	constraint_set_strs.append("\"{}\"".format(constraint))
	return "[{}]".format(", ".join(constraint_set_strs))

	def BUILD_for_compiler(target_triple):
	"""Emits a BUILD file the compiler .tar.gz."""

	system = triple_to_system(target_triple)
	return """
	load("@io_bazel_rules_rust//rust:toolchain.bzl", "rust_toolchain")

	filegroup(
	name = "rustc",
	srcs = ["bin/rustc{binary_ext}"],
	visibility = ["//visibility:public"],
	)

	filegroup(
	name = "rustc_lib",
	srcs = glob(
	[
	"lib/*{dylib_ext}",
	"lib/rustlib/{target_triple}/codegen-backends/*{dylib_ext}",
	],
	allow_empty = True,
	),
	visibility = ["//visibility:public"],
	)

	filegroup(
	name = "rustdoc",
	srcs = ["bin/rustdoc{binary_ext}"],
	visibility = ["//visibility:public"],
	)
	""".format(
	binary_ext = system_to_binary_ext(system),
	staticlib_ext = system_to_staticlib_ext(system),
	dylib_ext = system_to_dylib_ext(system),
	target_triple = target_triple,
	)

	def BUILD_for_rustfmt(target_triple):
	"""Emits a BUILD file the rustfmt .tar.gz."""

	system = triple_to_system(target_triple)
	return """
	load("@io_bazel_rules_rust//rust:toolchain.bzl", "rust_toolchain")

	filegroup(
	name = "rustfmt_bin",
	srcs = ["bin/rustfmt{binary_ext}"],
	visibility = ["//visibility:public"],
	)

	sh_binary(
	name = "rustfmt",
	srcs = [":rustfmt_bin"],
	visibility = ["//visibility:public"],
	)
	""".format(
	binary_ext = system_to_binary_ext(system),
	)

	def BUILD_for_clippy(target_triple):
	"""Emits a BUILD file the clippy's extracted files."""

	system = triple_to_system(target_triple)
	return """
	load("@io_bazel_rules_rust//rust:toolchain.bzl", "rust_toolchain")

	filegroup(
	name = "clippy_driver_bin",
	srcs = ["bin/clippy-driver{binary_ext}"],
	visibility = ["//visibility:public"],
	)
	""".format(binary_ext = system_to_binary_ext(system))

	def BUILD_for_stdlib(target_triple):
	"""Emits a BUILD file the stdlib .tar.gz."""

	system = triple_to_system(target_triple)
	return """
	filegroup(
	name = "rust_lib-{target_triple}",
	srcs = glob(
	[
	"lib/rustlib/{target_triple}/lib/*.rlib",
	"lib/rustlib/{target_triple}/lib/*{dylib_ext}",
	"lib/rustlib/{target_triple}/lib/*{staticlib_ext}",
	],
	# Some patterns (e.g. `lib/*.a`) don't match anything, see https://github.com/bazelbuild/rules_rust/pull/245
	allow_empty = True,
	),
	visibility = ["//visibility:public"],
	)
	""".format(
	binary_ext = system_to_binary_ext(system),
	staticlib_ext = system_to_staticlib_ext(system),
	dylib_ext = system_to_dylib_ext(system),
	target_triple = target_triple,
	)

	def BUILD_for_rust_toolchain(workspace_name, name, exec_triple, target_triple,
	stdlib_linkflags=None, default_edition = "2015"):
	"""Emits a toolchain declaration to match an existing compiler and stdlib.

	Args:
	workspace_name: The name of the workspace that this toolchain resides in
	name: The name of the toolchain declaration
	exec_triple: The rust-style target that this compiler runs on
	target_triple: The rust-style target triple of the tool
	stdlib_linkflags: Overriden flags needed for linking to rust stdlib, akin to BAZEL_LINKLIBS
	"""

	system = triple_to_system(target_triple)
	if stdlib_linkflags == None:
	stdlib_linkflags = ", ".join(['"%s"' % x for x in system_to_stdlib_linkflags(system)])

	return """
	rust_toolchain(
	name = "{toolchain_name}_impl",
	rust_doc = "@{workspace_name}//:rustdoc",
	rust_lib = "@{workspace_name}//:rust_lib-{target_triple}",
	rustc = "@{workspace_name}//:rustc",
	rustfmt = "@{workspace_name}//:rustfmt_bin",
	clippy_driver = "@{workspace_name}//:clippy_driver_bin",
	rustc_lib = "@{workspace_name}//:rustc_lib",
	binary_ext = "{binary_ext}",
	staticlib_ext = "{staticlib_ext}",
	dylib_ext = "{dylib_ext}",
	stdlib_linkflags = [{stdlib_linkflags}],
	os = "{system}",
	default_edition = "{default_edition}",
	exec_triple = "{exec_triple}",
	target_triple = "{target_triple}",
	visibility = ["//visibility:public"],
	)
	""".format(
	toolchain_name = name,
	workspace_name = workspace_name,
	binary_ext = system_to_binary_ext(system),
	staticlib_ext = system_to_staticlib_ext(system),
	dylib_ext = system_to_dylib_ext(system),
	stdlib_linkflags = stdlib_linkflags,
	system = system,
	default_edition = default_edition,
	exec_triple = exec_triple,
	target_triple = target_triple,
	)

	def BUILD_for_toolchain(name, parent_workspace_name, exec_triple, target_triple):
	return """
	toolchain(
	name = "{name}",
	exec_compatible_with = {exec_constraint_sets_serialized},
	target_compatible_with = {target_constraint_sets_serialized},
	toolchain = "@{parent_workspace_name}//:{name}_impl",
	toolchain_type = "@io_bazel_rules_rust//rust:toolchain",
	)
	""".format(
	name = name,
	exec_constraint_sets_serialized = serialized_constraint_set_from_triple(exec_triple),
	target_constraint_sets_serialized = serialized_constraint_set_from_triple(target_triple),
	parent_workspace_name = parent_workspace_name,
	)

	def produce_tool_suburl(tool_name, target_triple, version, iso_date = None):
	"""Produces a fully qualified Rust tool name for URL

	Args:
	tool_name: The name of the tool per static.rust-lang.org
	target_triple: The rust-style target triple of the tool
	version: The version of the tool among "nightly", "beta', or an exact version.
	iso_date: The date of the tool (or None, if the version is a specific version).
	"""

	if iso_date:
	return "{}/{}-{}-{}".format(iso_date, tool_name, version, target_triple)
	else:
	return "{}-{}-{}".format(tool_name, version, target_triple)

	def produce_tool_path(tool_name, target_triple, version):
	"""Produces a qualified Rust tool name

	Args:
	tool_name: The name of the tool per static.rust-lang.org
	target_triple: The rust-style target triple of the tool
	version: The version of the tool among "nightly", "beta', or an exact version.
	"""

	return "{}-{}-{}".format(tool_name, version, target_triple)

	def load_arbitrary_tool(ctx, tool_name, tool_subdirectories, version, iso_date, target_triple, sha256 = ""):
	"""Loads a Rust tool, downloads, and extracts into the common workspace.

	This function sources the tool from the Rust-lang static file server. The index is available
	at: https://static.rust-lang.org/dist/index.html (or the path specified by
	"${RUST_STATIC_URL}/dist/index.html" if the RUST_STATIC_URL envinronment variable is set).

	Args:
	ctx: A repository_ctx (no attrs required).
	tool_name: The name of the given tool per the archive naming.
	param_prefix: The name of the versioning param if the repository rule supports multiple tools.
	tool_subdirectories: The subdirectories of the tool files (at a level below the root directory of
	the archive). The root directory of the archive is expected to match
	$TOOL_NAME-$VERSION-$TARGET_TRIPLE.
	Example:
	tool_name
	\| version
	\| \| target_triple
	v v v
	rust-1.39.0-x86_64-unknown-linux-gnu/clippy-preview
	.../rustc
	.../etc
	tool_subdirectories = ["clippy-preview", "rustc"]
	version: The version of the tool among "nightly", "beta', or an exact version.
	iso_date: The date of the tool (or None, if the version is a specific version).
	target_triple: The rust-style target triple of the tool
	"""

	_check_version_valid(version, iso_date, param_prefix = tool_name + "_")

	# N.B. See https://static.rust-lang.org/dist/index.html to find the tool_suburl for a given
	# tool.
	tool_suburl = produce_tool_suburl(tool_name, target_triple, version, iso_date)
	static_rust = ctx.os.environ["STATIC_RUST_URL"] if "STATIC_RUST_URL" in ctx.os.environ else "https://static.rust-lang.org"
	url = "{}/dist/{}.tar.gz".format(static_rust, tool_suburl)

	tool_path = produce_tool_path(tool_name, target_triple, version)
	archive_path = tool_path + ".tar.gz"
	ctx.download(
	url,
	output = archive_path,
	sha256 = FILE_KEY_TO_SHA.get(tool_suburl) or sha256,
	)
	for subdirectory in tool_subdirectories:
	ctx.extract(
	archive_path,
	output = "",
	stripPrefix = "{}/{}".format(tool_path, subdirectory),
	)

	def _load_rustfmt(ctx):
	target_triple = ctx.attr.exec_triple

	if ctx.attr.rustfmt_version in ("beta", "nightly"):
	iso_date = ctx.attr.iso_date
	else:
	iso_date = None

	load_arbitrary_tool(
	ctx,
	iso_date = iso_date,
	target_triple = target_triple,
	tool_name = "rustfmt",
	tool_subdirectories = ["rustfmt-preview"],
	version = ctx.attr.rustfmt_version,
	)

	return BUILD_for_rustfmt(target_triple)

	def _load_rust_compiler(ctx):
	"""Loads a rust compiler and yields corresponding BUILD for it

	Args:
	ctx: A repository_ctx.
	Returns:
	The BUILD file contents for this compiler and compiler library
	"""

	target_triple = ctx.attr.exec_triple
	load_arbitrary_tool(
	ctx,
	iso_date = ctx.attr.iso_date,
	target_triple = target_triple,
	tool_name = "rust",
	tool_subdirectories = ["rustc", "clippy-preview"],
	version = ctx.attr.version,
	)

	compiler_BUILD = BUILD_for_compiler(target_triple) + BUILD_for_clippy(target_triple)

	return compiler_BUILD

	def _load_rust_stdlib(ctx, target_triple):
	"""Loads a rust standard library and yields corresponding BUILD for it

	Args:
	ctx: A repository_ctx.
	target_triple: The rust-style target triple of the tool
	Returns:
	The BUILD file contents for this stdlib, and a toolchain decl to match
	"""

	load_arbitrary_tool(
	ctx,
	iso_date = ctx.attr.iso_date,
	target_triple = target_triple,
	tool_name = "rust-std",
	tool_subdirectories = ["rust-std-{}".format(target_triple)],
	version = ctx.attr.version,
	)

	toolchain_prefix = ctx.attr.toolchain_name_prefix or DEFAULT_TOOLCHAIN_NAME_PREFIX
	stdlib_BUILD = BUILD_for_stdlib(target_triple)

	stdlib_linkflags = None
	if 'BAZEL_RUST_STDLIB_LINKFLAGS' in ctx.os.environ:
	stdlib_linkflags = ctx.os.environ['BAZEL_RUST_STDLIB_LINKFLAGS'].split(':')

	toolchain_BUILD = BUILD_for_rust_toolchain(
	name = "{toolchain_prefix}_{target_triple}".format(
	toolchain_prefix = toolchain_prefix,
	target_triple = target_triple,
	),
	exec_triple = ctx.attr.exec_triple,
	target_triple = target_triple,
	stdlib_linkflags = stdlib_linkflags,
	workspace_name = ctx.attr.name,
	default_edition = ctx.attr.edition,
	)

	return stdlib_BUILD + toolchain_BUILD

	def _load_rustc_dev_nightly(ctx, target_triple):
	"""Loads the nightly rustc dev component

	Args:
	ctx: A repository_ctx.
	target_triple: The rust-style target triple of the tool
	"""

	load_arbitrary_tool(
	ctx,
	iso_date = ctx.attr.iso_date,
	target_triple = target_triple,
	tool_name = "rustc-dev",
	tool_subdirectories = ["rustc-dev-{}".format(target_triple)],
	version = ctx.attr.version,
	)

	return

	def _load_llvm_tools(ctx, target_triple):
	"""Loads the llvm tools

	Args:
	ctx: A repository_ctx.
	target_triple: The rust-style target triple of the tool
	"""

	load_arbitrary_tool(
	ctx,
	iso_date = ctx.attr.iso_date,
	target_triple = target_triple,
	tool_name = "llvm-tools",
	tool_subdirectories = ["llvm-tools-preview"],
	version = ctx.attr.version,
	)

	return

	def _rust_toolchain_repository_impl(ctx):
	"""The implementation of the rust toolchain repository rule."""

	_check_version_valid(ctx.attr.version, ctx.attr.iso_date)

	BUILD_components = [_load_rust_compiler(ctx)]

	if ctx.attr.rustfmt_version:
	BUILD_components.append(_load_rustfmt(ctx))

	# Nightly Rust builds after 2020-05-22 need the llvm-tools gzip to get the libLLVM dylib
	if ctx.attr.version == "nightly" and ctx.attr.iso_date > "2020-05-22":
	_load_llvm_tools(ctx, ctx.attr.exec_triple)

	for target_triple in [ctx.attr.exec_triple] + ctx.attr.extra_target_triples:
	BUILD_components.append(_load_rust_stdlib(ctx, target_triple))

	# extra_target_triples contains targets such as wasm, which don't have rustc_dev components
	if ctx.attr.dev_components and target_triple not in ctx.attr.extra_target_triples:
	_load_rustc_dev_nightly(ctx, target_triple)

	ctx.file("WORKSPACE", "")
	ctx.file("BUILD", "\n".join(BUILD_components))

	def _rust_toolchain_repository_proxy_impl(ctx):
	BUILD_components = []
	for target_triple in [ctx.attr.exec_triple] + ctx.attr.extra_target_triples:
	BUILD_components.append(BUILD_for_toolchain(
	name = "{toolchain_prefix}_{target_triple}".format(
	toolchain_prefix = ctx.attr.toolchain_name_prefix,
	target_triple = target_triple,
	),
	exec_triple = ctx.attr.exec_triple,
	parent_workspace_name = ctx.attr.parent_workspace_name,
	target_triple = target_triple,
	))

	ctx.file("WORKSPACE", "")
	ctx.file("BUILD", "\n".join(BUILD_components))

	"""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 rust_toolchain_repository_proxy
	invocation to declare its toolchains to Bazel; the indirection allows separating toolchain
	selection from toolchain fetching

	Args:
	name: A unique name for this rule
	version: The version of the tool among "nightly", "beta', or an exact version.
	rustfmt_version: The version of rustfmt to be associated with the toolchain.
	iso_date: The date of the tool (or None, if the version is a specific version).
	exec_triple: The Rust-style target triple for the compilation platform
	extra_target_triples: The Rust-style triples for extra compilation targets
	toolchain_name_prefix: The per-target prefix expected for the rust_toolchain declarations
	edition: The rust edition to be used by default (2015 (default) or 2018)
	"""

	rust_toolchain_repository = repository_rule(
	attrs = {
	"version": attr.string(mandatory = True),
	"rustfmt_version": attr.string(),
	"iso_date": attr.string(),
	"exec_triple": attr.string(mandatory = True),
	"extra_target_triples": attr.string_list(),
	"toolchain_name_prefix": attr.string(),
	"edition": attr.string(default = "2015"),
	"dev_components": attr.bool(default = False),
	},
	implementation = _rust_toolchain_repository_impl,
	)

	"""Generates a toolchain-bearing repository that declares the toolchains from some other
	rust_toolchain_repository.

	Args:
	name: A unique name for this rule
	parent_workspace_name: The name of the other rust_toolchain_repository
	exec_triple: The Rust-style target triple for the compilation platform
	extra_target_triples: The Rust-style triples for extra compilation targets
	toolchain_name_prefix: The per-target prefix expected for the rust_toolchain declarations in the
	parent workspace.
	"""

	rust_toolchain_repository_proxy = repository_rule(
	attrs = {
	"parent_workspace_name": attr.string(mandatory = True),
	"exec_triple": attr.string(mandatory = True),
	"extra_target_triples": attr.string_list(),
	"toolchain_name_prefix": attr.string(),
	},
	implementation = _rust_toolchain_repository_proxy_impl,
	)

	def rust_repository_set(
	name,
	version,
	exec_triple,
	extra_target_triples = [],
	iso_date = None,
	rustfmt_version = None,
	edition = None,
	dev_components = False):
	"""Assembles a remote repository for the given toolchain params, produces a proxy repository
	to contain the toolchain declaration, and registers the toolchains.

	N.B. A "proxy repository" is needed to allow for registering the toolchain (with constraints)
	without actually downloading the toolchain.

	Args:
	name: The name of the generated repository
	version: The version of the tool among "nightly", "beta', or an exact version.
	iso_date: The date of the tool (or None, if the version is a specific version).
	exec_triple: The Rust-style target that this compiler runs on
	extra_target_triples: Additional rust-style targets that this set of toolchains
	should support.
	rustfmt_version: The version of rustfmt to be associated with the toolchain.
	edition: The rust edition to be used by default (2015 (default) or 2018)
	dev_components: Whether to download the rustc-dev components (defaults to False).
	Requires version to be "nightly".
	"""

	rust_toolchain_repository(
	name = name,
	exec_triple = exec_triple,
	extra_target_triples = extra_target_triples,
	iso_date = iso_date,
	toolchain_name_prefix = DEFAULT_TOOLCHAIN_NAME_PREFIX,
	version = version,
	rustfmt_version = rustfmt_version,
	edition = edition,
	dev_components = dev_components,
	)

	rust_toolchain_repository_proxy(
	name = name + "_toolchains",
	exec_triple = exec_triple,
	extra_target_triples = extra_target_triples,
	parent_workspace_name = name,
	toolchain_name_prefix = DEFAULT_TOOLCHAIN_NAME_PREFIX,
	)

	all_toolchain_names = []
	for target_triple in [exec_triple] + extra_target_triples:
	all_toolchain_names.append("@{name}_toolchains//:{toolchain_name_prefix}_{triple}".format(
	name = name,
	toolchain_name_prefix = DEFAULT_TOOLCHAIN_NAME_PREFIX,
	triple = target_triple,
	))

	# Register toolchains
	native.register_toolchains(*all_toolchain_names)
	native.register_toolchains("@io_bazel_rules_rust//rust/private/dummy_cc_toolchain:dummy_cc_wasm32_toolchain")