WIP

Author: UebelAndre

cargo/private/cargo_build_script.bzl

@@ -414,7 +414,7 @@ def _cargo_build_script_impl(ctx):
     # Pull in env vars which may be required for the cc_toolchain to work (e.g. on OSX, the SDK version).
     # We hope that the linker env is sufficient for the whole cc_toolchain.
     cc_toolchain, feature_configuration = find_cc_toolchain(ctx)
-    linker, link_args, linker_env = get_linker_and_args(ctx, "bin", toolchain, cc_toolchain, feature_configuration, None)
+    linker, _, link_args, linker_env = get_linker_and_args(ctx, "bin", toolchain, cc_toolchain, feature_configuration, None)
     env.update(**linker_env)
     env["LD"] = linker
     env["LDFLAGS"] = " ".join(_pwd_flags(link_args))

rust/private/rustc.bzl

@@ -422,12 +422,14 @@ def get_linker_and_args(ctx, crate_type, toolchain, cc_toolchain, feature_config
     Returns:
         tuple: A tuple of the following items:
             - (str): The tool path for given action.
+            - (bool): Whether or not the linker is a direct driver (e.g. `ld`) vs a wrapper (e.g. `gcc`).
             - (sequence): A flattened command line flags for given action.
             - (dict): Environment variables to be set for given action.
     """
     user_link_flags = get_cc_user_link_flags(ctx)
 
     ld = None
+    ld_is_direct_driver = False
     link_args = []
     link_env = {}
 
@@ -471,9 +473,11 @@ def get_linker_and_args(ctx, crate_type, toolchain, cc_toolchain, feature_config
             feature_configuration = feature_configuration,
             action_name = action_name,
         )
+        ld_is_direct_driver = False
 
     if not ld and toolchain.linker:
         ld = toolchain.linker.path
+        ld_is_direct_driver = toolchain.linker_type == "direct"
 
     if not ld:
         fail("No linker available for rustc. Either `rust_toolchain.linker` must be set or a `cc_toolchain` configured for the current configuration.")
@@ -490,7 +494,7 @@ def get_linker_and_args(ctx, crate_type, toolchain, cc_toolchain, feature_config
             for element in link_env["LIB"].split(";")
         ])
 
-    return ld, link_args, link_env
+    return ld, ld_is_direct_driver, link_args, link_env
 
 def _symlink_for_ambiguous_lib(actions, toolchain, crate_info, lib):
     """Constructs a disambiguating symlink for a library dependency.
@@ -1041,6 +1045,10 @@ def construct_arguments(
     _add_lto_flags(ctx, toolchain, rustc_flags, crate_info)
     _add_codegen_units_flags(toolchain, emit, rustc_flags)
 
+    # Use linker_type to determine whether to use direct or indirect linker invocation
+    # If linker_type is not explicitly set, infer from which linker is actually being used
+    ld_is_direct_driver = False
+
     # Link!
     if ("link" in emit and crate_info.type not in ["rlib", "lib"]) or add_flags_for_binary:
         # Rust's built-in linker can handle linking wasm files. We don't want to attempt to use the cc
@@ -1053,7 +1061,7 @@ def construct_arguments(
             else:
                 rpaths = depset()
 
-            ld, link_args, link_env = get_linker_and_args(
+            ld, ld_is_direct_driver, link_args, link_env = get_linker_and_args(
                 ctx,
                 crate_info.type,
                 toolchain,
@@ -1080,6 +1088,7 @@ def construct_arguments(
             cc_toolchain,
             feature_configuration,
             compilation_mode,
+            ld_is_direct_driver,
             include_link_flags = include_link_flags,
         )
 
@@ -2308,6 +2317,7 @@ def _add_native_link_flags(
         cc_toolchain,
         feature_configuration,
         compilation_mode,
+        use_direct_link_driver,
         include_link_flags = True):
     """Adds linker flags for all dependencies of the current target.
 
@@ -2321,29 +2331,14 @@ def _add_native_link_flags(
         cc_toolchain (CcToolchainInfo): The current `cc_toolchain`
         feature_configuration (FeatureConfiguration): feature configuration to use with cc_toolchain
         compilation_mode (bool): The compilation mode for this build.
+        use_direct_link_driver (bool): Whether the linker is a direct driver (e.g. `ld`, `wasm-ld`) vs a wrapper (e.g. `clang`, `gcc`).
         include_link_flags (bool, optional): Whether to include flags like `-l` that instruct the linker to search for a library.
     """
     if crate_type in ["lib", "rlib"]:
         return
 
     use_pic = _should_use_pic(cc_toolchain, feature_configuration, crate_type, compilation_mode)
 
-    # Use linker_type to determine whether to use direct or indirect linker invocation
-    # If linker_type is not explicitly set, infer from which linker is actually being used
-    use_direct_link_driver = False
-    if toolchain.linker_type:
-        # Explicit linker_type takes precedence
-        use_direct_link_driver = toolchain.linker_type == "direct"
-    elif toolchain.linker_preference == "rust":
-        # If rust linker is preferred, use direct invocation
-        use_direct_link_driver = True
-    elif toolchain.linker_preference == "cc" or (cc_toolchain and toolchain.linker_preference != "rust"):
-        # If cc linker is preferred or being used, use indirect invocation
-        use_direct_link_driver = False
-    elif toolchain.linker:
-        # If we have a rust linker available and no cc_toolchain, use direct invocation
-        use_direct_link_driver = True
-
     make_link_flags, get_lib_name = _get_make_link_flag_funcs(
         target_os = toolchain.target_os,
         target_abi = toolchain.target_abi,

test/unit/native_deps/native_deps_test.bzl

@@ -32,6 +32,54 @@ def _get_bin_dir_from_action(action):
         bin_dir = bin_dir.split("/bin/")[0] + "/bin"
     return bin_dir
 
+def _get_darwin_component(arg):
+    """Extract darwin component from a path.
+
+    Args:
+        arg: Path like "path/to/darwin_x86_64-fastbuild-ST-abc123/package"
+
+    Returns:
+        Darwin component like "darwin" (ignoring arch and compilation mode)
+    """
+
+    # path/to/darwin_x86_64-fastbuild-ST-abc123/package -> darwin_x86_64-fastbuild-ST-abc123
+    darwin_component = [x for x in arg.split("/") if x.startswith("darwin")][0]
+
+    # darwin_x86_64-fastbuild-ST-abc123 -> darwin
+    return darwin_component.split("-")[0]
+
+def _assert_bin_dir_structure(env, ctx, bin_dir, toolchain):
+    """Validate bin_dir structure, ignoring ST-{hash} suffix from config transitions.
+
+    Args:
+        env: The analysis test environment
+        ctx: The test context
+        bin_dir: The bin directory path to validate
+        toolchain: The toolchain info
+    """
+    compilation_mode = ctx.var["COMPILATION_MODE"]
+
+    # bin_dir should be like: bazel-out/{platform}-{mode}[-ST-{hash}]/bin
+    asserts.true(env, bin_dir.startswith("bazel-out/"), "bin_dir should start with bazel-out/")
+    asserts.true(env, bin_dir.endswith("/bin"), "bin_dir should end with /bin")
+
+    # Validate it contains compilation mode (ignoring potential ST-{hash})
+    bin_dir_components = bin_dir.split("/")[1]  # Get the platform-mode component
+    asserts.true(
+        env,
+        compilation_mode in bin_dir_components,
+        "bin_dir should contain compilation mode: expected '{}' in '{}'".format(compilation_mode, bin_dir_components),
+    )
+
+    # For Darwin platforms, validate darwin component
+    if toolchain.target_os in ["macos", "darwin"] and "darwin" in bin_dir:
+        darwin_component = _get_darwin_component(bin_dir)
+        asserts.true(
+            env,
+            darwin_component.startswith("darwin"),
+            "darwin component should start with 'darwin', got '{}'".format(darwin_component),
+        )
+
 def _rlib_has_no_native_libs_test_impl(ctx):
     env = analysistest.begin(ctx)
     tut = analysistest.target_under_test(env)
@@ -138,7 +186,7 @@ def _extract_linker_args(argv):
         )
     ]
 
-def _bin_has_native_dep_and_alwayslink_test_impl(ctx):
+def _bin_has_native_dep_and_alwayslink_test_impl(ctx, use_cc_linker):
     env = analysistest.begin(ctx)
     tut = analysistest.target_under_test(env)
     action = tut.actions[0]
@@ -147,8 +195,9 @@ def _bin_has_native_dep_and_alwayslink_test_impl(ctx):
     link_args = _extract_linker_args(action.argv)
     bin_dir = _get_bin_dir_from_action(action)
 
-    # Use the explicit test attribute to determine expected behavior
-    use_cc_linker = ctx.attr._use_cc_linker
+    # Validate bin_dir structure (ignoring ST-{hash} suffix from config transitions)
+    _assert_bin_dir_structure(env, ctx, bin_dir, toolchain)
+
     if toolchain.target_os in ["macos", "darwin"]:
         if use_cc_linker:
             # When using CC linker, args are passed with -Wl, prefix as separate arguments
@@ -216,7 +265,7 @@ def _bin_has_native_dep_and_alwayslink_test_impl(ctx):
     assert_list_contains_adjacent_elements(env, link_args, want)
     return analysistest.end(env)
 
-def _cdylib_has_native_dep_and_alwayslink_test_impl(ctx):
+def _cdylib_has_native_dep_and_alwayslink_test_impl(ctx, use_cc_linker):
     toolchain = _get_toolchain(ctx)
 
     env = analysistest.begin(ctx)
@@ -226,11 +275,12 @@ def _cdylib_has_native_dep_and_alwayslink_test_impl(ctx):
     linker_args = _extract_linker_args(action.argv)
     bin_dir = _get_bin_dir_from_action(action)
 
+    # Validate bin_dir structure (ignoring ST-{hash} suffix from config transitions)
+    _assert_bin_dir_structure(env, ctx, bin_dir, toolchain)
+
     compilation_mode = ctx.var["COMPILATION_MODE"]
     pic_suffix = _get_pic_suffix(ctx, compilation_mode)
 
-    # Use the explicit test attribute to determine expected behavior
-    use_cc_linker = ctx.attr._use_cc_linker
     if toolchain.target_os in ["macos", "darwin"]:
         if use_cc_linker:
             # When using CC linker, args are passed with -Wl, prefix as separate arguments
@@ -319,48 +369,57 @@ bin_has_native_libs_test = analysistest.make(_bin_has_native_libs_test_impl, att
     "_linker_preference": attr.label(default = Label("//rust/settings:toolchain_linker_preference")),
     "_toolchain": attr.label(default = Label("//rust/toolchain:current_rust_toolchain")),
 })
+
+def _bin_has_native_dep_and_alwayslink_rust_linker_test_impl(ctx):
+    return _bin_has_native_dep_and_alwayslink_test_impl(ctx, False)
+
 bin_has_native_dep_and_alwayslink_rust_linker_test = analysistest.make(
-    _bin_has_native_dep_and_alwayslink_test_impl,
+    _bin_has_native_dep_and_alwayslink_rust_linker_test_impl,
     attrs = {
         "_linker_preference": attr.label(default = Label("//rust/settings:toolchain_linker_preference")),
         "_toolchain": attr.label(default = Label("//rust/toolchain:current_rust_toolchain")),
-        "_use_cc_linker": attr.bool(default = False, doc = "Whether to expect CC linker flags (vs rust-lld)"),
     },
     config_settings = {
         str(Label("//rust/settings:toolchain_linker_preference")): "rust",
     },
 )
 
+def _bin_has_native_dep_and_alwayslink_cc_linker_test_impl(ctx):
+    return _bin_has_native_dep_and_alwayslink_test_impl(ctx, True)
+
 bin_has_native_dep_and_alwayslink_cc_linker_test = analysistest.make(
-    _bin_has_native_dep_and_alwayslink_test_impl,
+    _bin_has_native_dep_and_alwayslink_cc_linker_test_impl,
     attrs = {
         "_linker_preference": attr.label(default = Label("//rust/settings:toolchain_linker_preference")),
         "_toolchain": attr.label(default = Label("//rust/toolchain:current_rust_toolchain")),
-        "_use_cc_linker": attr.bool(default = True, doc = "Whether to expect CC linker flags (vs rust-lld)"),
     },
     config_settings = {
         str(Label("//rust/settings:toolchain_linker_preference")): "cc",
     },
 )
 
+def _cdylib_has_native_dep_and_alwayslink_rust_linker_test_impl(ctx):
+    return _cdylib_has_native_dep_and_alwayslink_test_impl(ctx, False)
+
 cdylib_has_native_dep_and_alwayslink_rust_linker_test = analysistest.make(
-    _cdylib_has_native_dep_and_alwayslink_test_impl,
+    _cdylib_has_native_dep_and_alwayslink_rust_linker_test_impl,
     attrs = {
         "_linker_preference": attr.label(default = Label("//rust/settings:toolchain_linker_preference")),
         "_toolchain": attr.label(default = Label("//rust/toolchain:current_rust_toolchain")),
-        "_use_cc_linker": attr.bool(default = False, doc = "Whether to expect CC linker flags (vs rust-lld)"),
     },
     config_settings = {
         str(Label("//rust/settings:toolchain_linker_preference")): "rust",
     },
 )
 
+def _cdylib_has_native_dep_and_alwayslink_cc_linker_test_impl(ctx):
+    return _cdylib_has_native_dep_and_alwayslink_test_impl(ctx, True)
+
 cdylib_has_native_dep_and_alwayslink_cc_linker_test = analysistest.make(
-    _cdylib_has_native_dep_and_alwayslink_test_impl,
+    _cdylib_has_native_dep_and_alwayslink_cc_linker_test_impl,
     attrs = {
         "_linker_preference": attr.label(default = Label("//rust/settings:toolchain_linker_preference")),
         "_toolchain": attr.label(default = Label("//rust/toolchain:current_rust_toolchain")),
-        "_use_cc_linker": attr.bool(default = True, doc = "Whether to expect CC linker flags (vs rust-lld)"),
     },
     config_settings = {
         str(Label("//rust/settings:toolchain_linker_preference")): "cc",