remaining

Author: UebelAndre

rust/platform/BUILD.bazel

@@ -21,6 +21,22 @@ constraint_value(
     constraint_setting = ":wasi_version",
 )
 
+# ABI constraint settings
+constraint_setting(
+    name = "abi",
+    default_constraint_value = ":gnu",
+)
+
+constraint_value(
+    name = "gnu",
+    constraint_setting = ":abi",
+)
+
+constraint_value(
+    name = "musl",
+    constraint_setting = ":abi",
+)
+
 package_group(
     name = "function_transition_allowlist",
     packages = [

rust/platform/triple_mappings.bzl

@@ -69,6 +69,7 @@ SUPPORTED_T2_PLATFORM_TRIPLES = {
     "x86_64-linux-android": _support(std = True, host_tools = False),
     "x86_64-unknown-freebsd": _support(std = True, host_tools = True),
     "x86_64-unknown-fuchsia": _support(std = True, host_tools = False),
+    "x86_64-unknown-linux-musl": _support(std = True, host_tools = True),
     "x86_64-unknown-none": _support(std = True, host_tools = False),
     "x86_64-unknown-uefi": _support(std = True, host_tools = False),
 }

rust/private/repository_utils.bzl

@@ -20,7 +20,13 @@ load(":semver.bzl", "semver")
 DEFAULT_TOOLCHAIN_NAME_PREFIX = "toolchain_for"
 DEFAULT_STATIC_RUST_URL_TEMPLATES = ["https://static.rust-lang.org/dist/{}.tar.xz"]
 DEFAULT_NIGHTLY_VERSION = "nightly/{}".format(DEFAULT_NIGHTLY_ISO_DATE)
-DEFAULT_EXTRA_TARGET_TRIPLES = ["wasm32-unknown-unknown", "wasm32-wasip1", "wasm32-wasip2"]
+DEFAULT_EXTRA_TARGET_TRIPLES = [
+    "wasm32-unknown-unknown",
+    "wasm32-wasip1",
+    "wasm32-wasip2",
+    "x86_64-unknown-linux-musl",
+    "aarch64-unknown-linux-musl",
+]
 
 TINYJSON_KWARGS = dict(
     name = "rules_rust_tinyjson",
@@ -446,9 +452,36 @@ def BUILD_for_toolchain(
         toolchain,
         toolchain_type,
         target_settings,
+        target_settings_select,
         target_compatible_with,
         exec_compatible_with):
-    target_settings_value = "target_settings = {},".format(json.encode(target_settings)) if target_settings else "# target_settings = []"
+    """Generates BUILD file content for a Bazel toolchain target.
+
+    Args:
+        name (str): The name of the toolchain target.
+        toolchain (str): Label of the toolchain implementation (e.g., rust_toolchain target).
+        toolchain_type (str): The toolchain type label (e.g., "@rules_rust//rust:toolchain").
+        target_settings (list): A list of config_setting labels that must be satisfied for
+            this toolchain to be selected.
+        target_settings_select (dict): A dictionary mapping config_setting labels to lists of
+            additional target_settings, used to generate a select() statement. If empty, no
+            select() is generated.
+        target_compatible_with (list): A list of constraint values for the target platform.
+        exec_compatible_with (list): A list of constraint values for the execution platform.
+
+    Returns:
+        str: The generated BUILD file content as a string.
+    """
+    target_settings_value = "# target_settings = []"
+
+    if target_settings or target_settings_select:
+        target_settings_value = "target_settings = {}".format(
+            json.encode(target_settings),
+        )
+        if target_settings_select:
+            target_settings_value += " + select({})".format(
+                json.encode(target_settings_select),
+            )
 
     return _build_file_for_toolchain_template.format(
         name = name,
@@ -1035,6 +1068,7 @@ def BUILD_for_toolchain_hub(
         toolchain_labels,
         toolchain_types,
         target_settings,
+        target_settings_select,
         target_compatible_with,
         exec_compatible_with):
     """Generates BUILD file content for a toolchain hub repository.
@@ -1072,11 +1106,15 @@ def _toolchain_repository_hub_impl(repository_ctx):
         repository_ctx.name,
     ))
 
+    # Decode the JSON-encoded target_settings_select
+    target_settings_select = json.decode(repository_ctx.attr.target_settings_select)
+
     repository_ctx.file("BUILD.bazel", BUILD_for_toolchain_hub(
         toolchain_names = repository_ctx.attr.toolchain_names,
         toolchain_labels = repository_ctx.attr.toolchain_labels,
         toolchain_types = repository_ctx.attr.toolchain_types,
         target_settings = repository_ctx.attr.target_settings,
+        target_settings_select = target_settings_select,
         target_compatible_with = repository_ctx.attr.target_compatible_with,
         exec_compatible_with = repository_ctx.attr.exec_compatible_with,
     ))
@@ -1099,6 +1137,10 @@ toolchain_repository_hub = repository_rule(
             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, keyed by toolchain name.",
             mandatory = True,
         ),
+        "target_settings_select": attr.string(
+            doc = "JSON-encoded dictionary mapping toolchain name to a dict of config_setting labels to lists of additional target_settings, used to generate select() statements. For internal use only.",
+            default = "{}",
+        ),
         "toolchain_labels": attr.string_dict(
             doc = "The name of the toolchain implementation target, keyed by toolchain name.",
             mandatory = True,

rust/private/rust.bzl

@@ -1348,38 +1348,103 @@ def _common_attrs_for_binary_without_process_wrapper(attrs):
 
     return new_attr
 
+def _rust_binary_without_process_wrapper_transition_impl(_settings, _attr):
+    # For process wrapper bootstrapping, we force musl on Linux for better portability
+    # and set the linker preference to use Rust's linker
+    return {
+        str(Label("//rust/settings:toolchain_linker_preference")): "rust",
+        str(Label("//rust/settings:platform_linux_musl")): True,
+    }
+
+_rust_binary_without_process_wrapper_transition = transition(
+    implementation = _rust_binary_without_process_wrapper_transition_impl,
+    inputs = [],
+    outputs = [
+        str(Label("//rust/settings:toolchain_linker_preference")),
+        str(Label("//rust/settings:platform_linux_musl")),
+    ],
+)
+
+_RustBuiltWithoutProcessWrapperInfo = provider(
+    doc = "A provider identifying the target having been built using a `*_without_process_wrapper` rule variant.",
+    fields = {},
+)
+
+def _rust_binary_without_process_wrapper_impl(ctx):
+    providers = _rust_binary_impl(ctx)
+    return providers + [_RustBuiltWithoutProcessWrapperInfo()]
+
 # Provides an internal rust_{binary,library} to use that we can use to build the process
 # wrapper, this breaks the dependency of rust_* on the process wrapper by
 # setting it to None, which the functions in rustc detect and build accordingly.
 rust_binary_without_process_wrapper = rule(
-    implementation = _rust_binary_impl,
-    provides = COMMON_PROVIDERS,
-    attrs = _common_attrs_for_binary_without_process_wrapper(_common_attrs | _rust_binary_attrs | {
-        "platform": attr.label(
-            doc = "Optional platform to transition the binary to.",
-            default = None,
-        ),
-        "_allowlist_function_transition": attr.label(
-            default = "@bazel_tools//tools/allowlists/function_transition_allowlist",
-        ),
-    }),
+    implementation = _rust_binary_without_process_wrapper_impl,
+    doc = "A variant of `rust_binary` that uses a minimal process wrapper for `Rustc` actions.",
+    provides = COMMON_PROVIDERS + [_RustBuiltWithoutProcessWrapperInfo],
+    attrs = _common_attrs_for_binary_without_process_wrapper(_common_attrs | _rust_binary_attrs),
+    cfg = _rust_binary_without_process_wrapper_transition,
     executable = True,
     fragments = ["cpp"],
-    cfg = _rust_binary_transition,
     toolchains = [
         str(Label("//rust:toolchain_type")),
-        "@bazel_tools//tools/cpp:toolchain_type",
+        config_common.toolchain_type("@bazel_tools//tools/cpp:toolchain_type", mandatory = False),
     ],
 )
 
+def _rust_library_without_process_wrapper_impl(ctx):
+    providers = _rust_library_impl(ctx)
+    return providers + [_RustBuiltWithoutProcessWrapperInfo()]
+
 rust_library_without_process_wrapper = rule(
-    implementation = _rust_library_impl,
-    provides = COMMON_PROVIDERS,
+    implementation = _rust_library_without_process_wrapper_impl,
+    doc = "A variant of `rust_library` that uses a minimal process wrapper for `Rustc` actions.",
+    provides = COMMON_PROVIDERS + [_RustBuiltWithoutProcessWrapperInfo],
     attrs = dict(_common_attrs_for_binary_without_process_wrapper(_common_attrs).items()),
     fragments = ["cpp"],
     toolchains = [
         str(Label("//rust:toolchain_type")),
-        "@bazel_tools//tools/cpp:toolchain_type",
+        config_common.toolchain_type("@bazel_tools//tools/cpp:toolchain_type", mandatory = False),
+    ],
+)
+
+def _test_attrs_for_binary_without_process_wrapper(attrs):
+    new_attrs = {}
+    new_attrs.update(attrs)
+
+    # Require that `crate` has the correct internal provider.
+    new_attrs["crate"] = attr.label(
+        mandatory = False,
+        providers = [_RustBuiltWithoutProcessWrapperInfo],
+        doc = dedent("""\
+            Target inline tests declared in the given crate
+
+            These tests are typically those that would be held out under
+            `#[cfg(test)]` declarations.
+        """),
+    )
+
+    return new_attrs
+
+def _rust_test_without_process_wrapper_test_impl(ctx):
+    if ctx.attr.srcs:
+        fail("`rust_test_without_process_wrapper_test.srcs` is not allowed. Remove it from {}".format(
+            ctx.label,
+        ))
+    providers = _rust_test_impl(ctx)
+    return providers
+
+rust_test_without_process_wrapper_test = rule(
+    implementation = _rust_test_without_process_wrapper_test_impl,
+    doc = "Unlike other `*_without_process_wrapper` rules, this rule does use the process wrapper but requires it's dependencies were not built with one.",
+    provides = COMMON_PROVIDERS,
+    attrs = _test_attrs_for_binary_without_process_wrapper(_common_attrs | _rust_test_attrs),
+    executable = True,
+    cfg = _rust_binary_without_process_wrapper_transition,
+    fragments = ["cpp"],
+    test = True,
+    toolchains = [
+        str(Label("//rust:toolchain_type")),
+        config_common.toolchain_type("@bazel_tools//tools/cpp:toolchain_type", mandatory = False),
     ],
 )
 

rust/repositories.bzl

@@ -43,14 +43,18 @@ 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_macos_aarch64",
+    # "aarch64-pc-windows-gnu": "rust_windows_aarch64_gnu",
     "aarch64-pc-windows-msvc": "rust_windows_aarch64",
     "aarch64-unknown-linux-gnu": "rust_linux_aarch64",
+    # "aarch64-unknown-linux-musl": "rust_linux_aarch64_gnu",
     "powerpc64le-unknown-linux-gnu": "rust_linux_powerpc64le",
     "s390x-unknown-linux-gnu": "rust_linux_s390x",
     "x86_64-apple-darwin": "rust_macos_x86_64",
+    # "x86_64-pc-windows-gnu": "rust_windows_x86_64_gnu",
     "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",
+    # "x86_64-unknown-linux-musl": "rust_linux_x86_64_musl",
 }
 
 _COMPACT_WINDOWS_NAMES = True
@@ -234,6 +238,7 @@ def rust_register_toolchains(
     toolchain_names = []
     toolchain_labels = {}
     toolchain_target_settings = {}
+    toolchain_target_settings_select = {}
     toolchain_types = {}
     exec_compatible_with_by_toolchain = {}
     target_compatible_with_by_toolchain = {}
@@ -295,6 +300,7 @@ def rust_register_toolchains(
             target_compatible_with_by_toolchain[toolchain.name] = toolchain.target_constraints
             toolchain_types[toolchain.name] = "@rules_rust//rust:toolchain"
             toolchain_target_settings[toolchain.name] = ["@rules_rust//rust/toolchain/channel:{}".format(toolchain.channel.name)] + target_settings
+            toolchain_target_settings_select[toolchain.name] = _get_abi_target_settings_select(toolchain.target_triple)
 
     for exec_triple, name in rustfmt_toolchain_triples.items():
         rustfmt_repo_name = "rustfmt_{}__{}".format(rustfmt_version.replace("/", "-"), exec_triple)
@@ -319,6 +325,7 @@ def rust_register_toolchains(
         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_target_settings_select[rustfmt_repo_name] = {}
         toolchain_types[rustfmt_repo_name] = "@rules_rust//rust/rustfmt:toolchain_type"
 
     if aliases:
@@ -332,6 +339,7 @@ def rust_register_toolchains(
                 exec_compatible_with_by_toolchain[name] = info["exec_compatible_with"]
                 target_compatible_with_by_toolchain[name] = info["target_compatible_with"]
                 toolchain_target_settings[name] = info["target_settings"]
+                toolchain_target_settings_select[name] = info["target_settings_select"]
                 toolchain_types[name] = info["toolchain_type"]
 
         toolchain_repository_hub(
@@ -340,6 +348,7 @@ def rust_register_toolchains(
             toolchain_labels = toolchain_labels,
             toolchain_types = toolchain_types,
             target_settings = toolchain_target_settings,
+            target_settings_select = json.encode(toolchain_target_settings_select),
             exec_compatible_with = exec_compatible_with_by_toolchain,
             target_compatible_with = target_compatible_with_by_toolchain,
         )
@@ -590,6 +599,7 @@ def _toolchain_repository_proxy_impl(repository_ctx):
         name = "toolchain",
         toolchain = repository_ctx.attr.toolchain,
         target_settings = repository_ctx.attr.target_settings,
+        target_settings_select = repository_ctx.attr.target_settings_select,
         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,
@@ -610,6 +620,9 @@ toolchain_repository_proxy = repository_rule(
         "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.",
         ),
+        "target_settings_select": attr.string_list_dict(
+            doc = "A dictionary mapping config_setting labels to lists of additional target_settings, used to generate a select() statement. If empty, no select() is generated.",
+        ),
         "toolchain": attr.string(
             doc = "The name of the toolchain implementation target.",
             mandatory = True,
@@ -625,6 +638,42 @@ toolchain_repository_proxy = repository_rule(
 # For legacy support
 rust_toolchain_repository_proxy = toolchain_repository_proxy
 
+def _get_abi_target_settings_select(target_triple):
+    """Returns the ABI-specific config_settings for use in a select() statement.
+
+    Args:
+        target_triple (str): The target triple to check
+
+    Returns:
+        dict: A dictionary mapping config_setting labels to lists of target_settings,
+              for use in a select() statement. Empty dict if no ABI-specific settings apply.
+    """
+    triple_struct = triple(target_triple)
+
+    # Check for linux + musl combination
+    if triple_struct.system == "linux":
+        return {
+            "@rules_rust//rust/settings:experimental_use_platform_abi_settings_enabled": [
+                "@rules_rust//rust/settings:platform_linux_musl_{}".format(
+                    "enabled" if triple_struct.abi == "musl" else "disabled",
+                ),
+            ],
+            "//conditions:default": [],
+        }
+
+    # Check for windows + gnu combination
+    if triple_struct.system == "windows":
+        return {
+            "@rules_rust//rust/settings:experimental_use_platform_abi_settings_enabled": [
+                "@rules_rust//rust/settings:platform_windows_gnu_{}".format(
+                    "enabled" if triple_struct.abi == "gnu" else "disabled",
+                ),
+            ],
+            "//conditions:default": [],
+        }
+
+    return {}
+
 # N.B. A "proxy repository" is needed to allow for registering the toolchain (with constraints)
 # without actually downloading the toolchain.
 def rust_toolchain_repository(
@@ -718,6 +767,7 @@ def rust_toolchain_repository(
     )
 
     channel_target_settings = ["@rules_rust//rust/toolchain/channel:{}".format(channel)] if channel else []
+    abi_target_settings_select = _get_abi_target_settings_select(target_triple)
 
     tools_toolchain_label = "@{}//:rust_toolchain".format(tools_repo_name)
 
@@ -727,6 +777,7 @@ def rust_toolchain_repository(
         name = name,
         toolchain = tools_toolchain_label,
         target_settings = channel_target_settings + target_settings,
+        target_settings_select = abi_target_settings_select,
         toolchain_type = toolchain_type,
         exec_compatible_with = exec_compatible_with,
         target_compatible_with = target_compatible_with,
@@ -736,7 +787,8 @@ def rust_toolchain_repository(
         "exec_compatible_with": exec_compatible_with,
         "name": name,
         "target_compatible_with": target_compatible_with,
-        "target_settings": target_settings,
+        "target_settings": channel_target_settings + target_settings,
+        "target_settings_select": abi_target_settings_select,
         "toolchain_label": "@{name}//:toolchain".format(name = name),
         "toolchain_type": toolchain_type,
         "tools_toolchain_label": tools_toolchain_label,