Merge branch 'main' into path-mapping-support

Author: krasimirgg

cargo/private/cargo_build_script.bzl

@@ -273,17 +273,14 @@ def _rlocationpath(file, workspace_name):
 def _create_runfiles_dir(ctx, script, data_runfiles, retain_list):
     """Create a runfiles directory to represent `CARGO_MANIFEST_DIR`.
 
+    Merges runfiles from both the script binary and the data runfiles target,
+    filtering out the fake executable from the data runfiles.
+
     Due to the inability to forcibly generate runfiles directories for use as inputs
     to actions, this function creates a custom runfiles directory that can more
     consistently be relied upon as an input. For more details see:
     https://github.com/bazelbuild/bazel/issues/15486
 
-    Merges runfiles from both the script binary and the data runfiles target,
-    filtering out the fake executable from the data runfiles.
-
-    If runfiles directories can ever be more directly treated as an input this function
-    can be retired.
-
     Args:
         ctx (ctx): The rule's context object
         script (Target): The build script binary target.
@@ -534,7 +531,6 @@ def _cargo_build_script_impl(ctx):
 
     tools = depset(
         direct = [
-            script,
             ctx.executable._cargo_build_script_runner,
         ] + fallback_tools + ([toolchain.target_json] if toolchain.target_json else []),
         transitive = script_data + toolchain_tools,
@@ -620,7 +616,10 @@ def _cargo_build_script_impl(ctx):
             dep_env_out,
             runfiles_dir,
         ] + extra_output,
-        tools = tools,
+        tools = [
+            ctx.attr.script[DefaultInfo].files_to_run,
+            tools,
+        ],
         inputs = depset(build_script_inputs, transitive = [runfiles_inputs]),
         mnemonic = "CargoBuildScriptRun",
         progress_message = "Running Cargo build script {}".format(pkg_name),

cargo/private/cargo_build_script_runner/bin.rs

@@ -87,7 +87,8 @@ fn run_buildrs() -> Result<(), String> {
 
     let working_directory = resolve_rundir(&rundir, &exec_root, &manifest_dir)?;
 
-    let mut command = Command::new(exec_root.join(progname));
+    let script_path = exec_root.join(&progname);
+    let mut command = Command::new(&script_path);
     command
         .current_dir(&working_directory)
         .envs(target_env_vars)
@@ -96,6 +97,15 @@ fn run_buildrs() -> Result<(), String> {
         .env("RUSTC", rustc)
         .env("RUST_BACKTRACE", "full");
 
+    // The script binary may have a `<script>.runfiles/` tree or a
+    // `<script>.runfiles_manifest` file materialized next to it by Bazel
+    // (because the script was passed as a `FilesToRunProvider`). Expose
+    // whichever exists so the runfiles library can locate the script's
+    // runfiles (tools). Data files of `cargo_build_script` are intentionally
+    // NOT in this tree — they must be looked up relative to
+    // `CARGO_MANIFEST_DIR`.
+    set_script_runfiles_env(&script_path, &mut command);
+
     for dep_env_path in input_dep_env_paths.iter() {
         if let Ok(contents) = read_to_string(dep_env_path) {
             for line in contents.split('\n') {
@@ -313,6 +323,39 @@ fn should_symlink_exec_root() -> bool {
         .unwrap_or(false)
 }
 
+/// Locate the runfiles materialized for `script_path` and expose them to the
+/// build script via the appropriate env var.
+///
+/// Bazel materializes runfiles for a `FilesToRunProvider` tool either as a
+/// `<script>.runfiles/` directory tree, a `<script>.runfiles_manifest` file,
+/// or both. Both are checked; if neither is present, no env var is set and
+/// the runfiles library falls back to its own heuristics (e.g. argv[0]).
+///
+/// `RUNFILES_MANIFEST_FILE` inherited from the parent process is cleared so
+/// it doesn't shadow what we're exposing.
+fn set_script_runfiles_env(script_path: &Path, command: &mut Command) {
+    command.env_remove("RUNFILES_MANIFEST_FILE");
+    command.env_remove("RUNFILES_DIR");
+
+    let Some(file_name) = script_path.file_name() else {
+        return;
+    };
+
+    let mut runfiles_dir_name = file_name.to_owned();
+    runfiles_dir_name.push(".runfiles");
+    let runfiles_dir = script_path.with_file_name(&runfiles_dir_name);
+    if runfiles_dir.is_dir() {
+        command.env("RUNFILES_DIR", &runfiles_dir);
+    }
+
+    let mut runfiles_manifest_name = file_name.to_owned();
+    runfiles_manifest_name.push(".runfiles_manifest");
+    let runfiles_manifest = script_path.with_file_name(&runfiles_manifest_name);
+    if runfiles_manifest.is_file() {
+        command.env("RUNFILES_MANIFEST_FILE", &runfiles_manifest);
+    }
+}
+
 /// Create a symlink from `link` to `original` if `link` doesn't already exist.
 fn symlink_if_not_exists(original: &Path, link: &Path) -> Result<(), String> {
     symlink(original, link)

cargo/private/cargo_build_script_runner/cargo_manifest_dir.rs

@@ -139,6 +139,7 @@ impl RunfilesMaker {
             .next()
             .unwrap_or_else(|| panic!("Not enough arguments provided."))
             .split(',')
+            .filter(|s| !s.is_empty())
             .map(|s| s.to_owned())
             .collect::<BTreeSet<String>>();
         let runfiles = args

cargo/tests/cargo_build_script/runfiles/BUILD.bazel

@@ -0,0 +1,41 @@
+load("@bazel_skylib//rules:write_file.bzl", "write_file")
+load("//cargo:defs.bzl", "cargo_build_script")
+load("//rust:defs.bzl", "rust_test")
+
+# A "tool" file that becomes `data` on the rust_binary backing the build
+# script. The build script should be able to locate it via the runfiles
+# library (RUNFILES_DIR).
+write_file(
+    name = "tool_txt",
+    out = "tool.txt",
+    content = ["this is a tool, locatable via the runfiles library"],
+)
+
+# A "data" file that lives in CARGO_MANIFEST_DIR. The build script must NOT
+# be able to locate it via the runfiles library; it should be looked up
+# relative to CARGO_MANIFEST_DIR like a normal source file.
+write_file(
+    name = "data_txt",
+    out = "data.txt",
+    content = ["this is data, locatable only via CARGO_MANIFEST_DIR"],
+)
+
+cargo_build_script(
+    name = "build_rs",
+    srcs = ["build.rs"],
+    build_script_env = {
+        "DATA_RLOCATION": "$(rlocationpath :data.txt)",
+        "TOOL_RLOCATION": "$(rlocationpath :tool.txt)",
+    },
+    data = [":data.txt"],
+    edition = "2021",
+    tools = [":tool.txt"],
+    deps = ["//rust/runfiles"],
+)
+
+rust_test(
+    name = "test",
+    srcs = ["test.rs"],
+    edition = "2021",
+    deps = [":build_rs"],
+)

cargo/tests/cargo_build_script/runfiles/build.rs

@@ -0,0 +1,52 @@
+//! A Cargo build script binary used in unit tests for the Bazel
+//! `cargo_build_script` rule.
+//!
+//! Asserts that:
+//!   1. Tools (which are `data` of the underlying `rust_binary`) are locatable
+//!      via the runfiles library (RUNFILES_DIR).
+//!   2. Data (which is `data` of `cargo_build_script`) is NOT locatable via
+//!      the runfiles library.
+//!   3. Data IS locatable relative to `CARGO_MANIFEST_DIR`, like a normal
+//!      source file alongside `build.rs`.
+
+fn main() {
+    let r = runfiles::Runfiles::create().expect(
+        "Build scripts should be able to construct a Runfiles object — \
+         RUNFILES_DIR or RUNFILES_MANIFEST_FILE must be exposed by the build script runner",
+    );
+
+    let tool_rlocation =
+        std::env::var("TOOL_RLOCATION").expect("TOOL_RLOCATION env var should be set");
+    let tool_path = r.rlocation(&tool_rlocation).unwrap_or_else(|| {
+        panic!(
+            "Tool must be locatable via the runfiles library (rlocation: {})",
+            tool_rlocation,
+        )
+    });
+    assert!(
+        tool_path.exists(),
+        "Tool must exist at the path returned by the runfiles library: {}",
+        tool_path.display(),
+    );
+
+    let data_rlocation =
+        std::env::var("DATA_RLOCATION").expect("DATA_RLOCATION env var should be set");
+    let data_via_runfiles = r.rlocation(&data_rlocation);
+    if let Some(path) = data_via_runfiles {
+        assert!(
+            !path.exists(),
+            "Data must NOT be locatable via the runfiles library, but found it at {} (rlocation: {})",
+            path.display(),
+            data_rlocation,
+        );
+    }
+
+    let manifest_dir =
+        std::env::var("CARGO_MANIFEST_DIR").expect("CARGO_MANIFEST_DIR should be set");
+    let data_in_manifest = std::path::Path::new(&manifest_dir).join("data.txt");
+    assert!(
+        data_in_manifest.exists(),
+        "Data must be locatable relative to CARGO_MANIFEST_DIR at {}",
+        data_in_manifest.display(),
+    );
+}

cargo/tests/cargo_build_script/runfiles/test.rs

@@ -0,0 +1,6 @@
+//! Triggers execution of the `build.rs` build script. The build script
+//! itself contains the assertions; if any fail the action fails and this
+//! test fails to build.
+
+#[test]
+fn build_script_ran() {}

rust/private/rustc.bzl

@@ -651,6 +651,7 @@ def collect_inputs(
         stamp = False,
         force_depend_on_objects = False,
         experimental_use_cc_common_link = False,
+        include_linker_inputs = False,
         include_link_flags = True):
     """Gather's the inputs and required input information for a rustc action
 
@@ -673,6 +674,7 @@ def collect_inputs(
             metadata, even for libraries. This is used in rustdoc tests.
         experimental_use_cc_common_link (bool, optional): Whether rules_rust uses cc_common.link to link
             rust binaries.
+        include_linker_inputs (bool, optional): Whether to include linker inputs in transitive dependencies.
         include_link_flags (bool, optional): Whether to include flags like `-l` that instruct the linker to search for a library.
 
     Returns:
@@ -713,7 +715,7 @@ def collect_inputs(
     # flattened on each transitive rust_library dependency.
     libs_from_linker_inputs = []
     ambiguous_libs = {}
-    if crate_info.type not in ("lib", "rlib"):
+    if crate_info.type not in ("lib", "rlib") or include_linker_inputs:
         linker_inputs = dep_info.transitive_noncrates.to_list()
         ambiguous_libs = _disambiguate_libs(ctx.actions, toolchain, crate_info, dep_info, use_pic)
         libs_from_linker_inputs = _collect_libs_from_linker_inputs(linker_inputs, use_pic) + [
@@ -2634,8 +2636,6 @@ def _add_native_link_flags(
         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 = cc_toolchain,

rust/private/rustdoc.bzl

@@ -15,9 +15,18 @@
 """Rules for generating documentation with `rustdoc` for Bazel built crates"""
 
 load("//rust/private:common.bzl", "rust_common")
+load("//rust/private:pic_utils.bzl", "should_use_pic")
 load("//rust/private:providers.bzl", "LintsInfo")
 load("//rust/private:rustc.bzl", "collect_deps", "collect_inputs", "construct_arguments")
-load("//rust/private:utils.bzl", "dedent", "find_cc_toolchain", "find_toolchain")
+load(
+    "//rust/private:utils.bzl",
+    "dedent",
+    "find_cc_toolchain",
+    "find_toolchain",
+    "get_lib_name_default",
+    "get_lib_name_for_windows",
+    "get_preferred_artifact",
+)
 
 def _strip_crate_info_output(crate_info):
     """Set the CrateInfo.output to None for a given CrateInfo provider.
@@ -122,6 +131,7 @@ def rustdoc_compile_action(
         build_info = build_info,
         lint_files = lint_files,
         force_depend_on_objects = force_depend_on_objects,
+        include_linker_inputs = is_test or force_depend_on_objects,
         include_link_flags = False,
     )
 
@@ -131,6 +141,32 @@ def rustdoc_compile_action(
     # arguments expecting to do so.
     rustdoc_crate_info = _strip_crate_info_output(crate_info)
 
+    # rustdoc does not understand linker flags like -lstatic that
+    # `include_link_flags` generates. So we manually build flags that only apply
+    # to rustdoc.
+    if is_test or force_depend_on_objects:
+        compilation_mode = ctx.var["COMPILATION_MODE"]
+        use_pic = should_use_pic(
+            cc_toolchain = cc_toolchain,
+            feature_configuration = feature_configuration,
+            crate_type = crate_info.type,
+            compilation_mode = compilation_mode,
+            toolchain = toolchain,
+        )
+        for_windows = toolchain.target_abi == "msvc"
+        get_lib_name = get_lib_name_for_windows if for_windows else get_lib_name_default
+        for dep in dep_info.transitive_noncrates.to_list():
+            for lib in dep.libraries:
+                if not (lib.static_library or lib.pic_static_library):
+                    continue
+                arg = get_lib_name(get_preferred_artifact(lib, use_pic))
+                if not for_windows:
+                    arg = "-l" + arg
+                if type(rustdoc_flags) == "Args":
+                    rustdoc_flags.add("-Clink-arg=%s" % arg)
+                else:
+                    rustdoc_flags.append("-Clink-arg=%s" % arg)
+
     args, env = construct_arguments(
         ctx = ctx,
         attr = ctx.attr,

rust/private/rustdoc_test.bzl

@@ -20,6 +20,15 @@ load("//rust/private:providers.bzl", "CrateInfo")
 load("//rust/private:rustdoc.bzl", "rustdoc_compile_action")
 load("//rust/private:utils.bzl", "dedent", "find_toolchain", "transform_deps")
 
+def _collect_library_roots(roots, deps):
+    for dep in deps.to_list():
+        for lib in dep.libraries:
+            for artifact in [lib.static_library, lib.pic_static_library]:
+                if artifact:
+                    roots.append(artifact.root.path)
+        for input in dep.additional_inputs:
+            roots.append(input.root.path)
+
 def _construct_writer_arguments(ctx, test_runner, opt_test_params, action, crate_info):
     """Construct arguments and environment variables specific to `rustdoc_test_writer`.
 
@@ -64,29 +73,23 @@ def _construct_writer_arguments(ctx, test_runner, opt_test_params, action, crate
 
     # Collect and dedupe all of the file roots in a list before appending
     # them to args to prevent generating a large amount of identical args
-    roots = []
-    root = crate_info.output.root.path
-    if not root in roots:
-        roots.append(root)
+    roots = [crate_info.output.root.path]
     for dep in crate_info.deps.to_list() + crate_info.proc_macro_deps.to_list():
         dep_crate_info = getattr(dep, "crate_info", None)
         dep_dep_info = getattr(dep, "dep_info", None)
+        dep_cc_info = getattr(dep, "cc_info", None)
         if dep_crate_info:
-            root = dep_crate_info.output.root.path
-            if not root in roots:
-                roots.append(root)
+            roots.append(dep_crate_info.output.root.path)
         if dep_dep_info:
             for direct_dep in dep_dep_info.direct_crates.to_list():
-                root = direct_dep.dep.output.root.path
-                if not root in roots:
-                    roots.append(root)
+                roots.append(direct_dep.dep.output.root.path)
             for transitive_dep in dep_dep_info.transitive_crates.to_list():
-                root = transitive_dep.output.root.path
-                if not root in roots:
-                    roots.append(root)
+                roots.append(transitive_dep.output.root.path)
+            _collect_library_roots(roots, dep_dep_info.transitive_noncrates)
+        if dep_cc_info:
+            _collect_library_roots(roots, dep_cc_info.linking_context.linker_inputs)
 
-    for root in roots:
-        writer_args.add("--strip_substring={}/".format(root))
+    writer_args.add_all(roots, format_each = "--strip_substring=%s/", uniquify = True)
 
     # Indicate that the rustdoc_test args are over.
     writer_args.add("--")

test/unit/rustdoc/rustdoc.cc

@@ -0,0 +1,3 @@
+#include "test/unit/rustdoc/rustdoc.h"
+
+int rustdoc_native_dep() { return 42; }