Handle versioned dynamic libs when linking

.bazelignore

@@ -4,5 +4,4 @@ crate_universe/private/bootstrap
 crate_universe/tests/integration
 docs
 examples
-extensions
 test/integration

MODULE.bazel

@@ -9,13 +9,21 @@ module(
 ## Core
 ###############################################################################
 
+bazel_dep(name = "bazel_lib", version = "3.0.0")
 bazel_dep(name = "bazel_features", version = "1.32.0")
 bazel_dep(name = "bazel_skylib", version = "1.8.2")
 bazel_dep(name = "platforms", version = "1.1.0")
+bazel_dep(name = "protobuf", version = "28.3", repo_name = "com_google_protobuf")
 bazel_dep(name = "rules_cc", version = "0.2.4")
 bazel_dep(name = "rules_license", version = "1.0.0")
+bazel_dep(name = "rules_proto", version = "7.1.0")
+bazel_dep(name = "rules_python", version = "1.6.3")
 bazel_dep(name = "rules_shell", version = "0.6.1")
 bazel_dep(name = "apple_support", version = "1.24.1")
+bazel_dep(name = "llvm", version = "0.7.7")
+
+osx = use_extension("@llvm//extensions:osx.bzl", "osx")
+use_repo(osx, "macos_sdk")
 
 internal_deps = use_extension("//rust/private:internal_extensions.bzl", "i")
 use_repo(
@@ -86,7 +94,6 @@ use_repo(
     "rules_rust_toolchain_test_target_json",
 )
 
-bazel_dep(name = "rules_python", version = "1.5.1", dev_dependency = True)
 bazel_dep(name = "rules_testing", version = "0.7.0", dev_dependency = True)
 bazel_dep(name = "bazel_ci_rules", version = "1.0.0", dev_dependency = True)
 

cargo/private/BUILD.bazel

@@ -1,5 +1,5 @@
+load("@bazel_lib//lib:copy_file.bzl", "copy_file")
 load("@bazel_skylib//:bzl_library.bzl", "bzl_library")
-load("@bazel_skylib//rules:copy_file.bzl", "copy_file")
 load("//rust:defs.bzl", "rust_binary")
 
 rust_binary(
@@ -39,6 +39,9 @@ copy_file(
 
 bzl_library(
     name = "bzl_lib",
+    deps = [
+        "//rust:bzl_lib",
+    ],
     srcs = glob(["**/*.bzl"]),
-    visibility = ["//:__subpackages__"],
+    visibility = ["//visibility:public"],
 )

cargo/private/cargo_build_script.bzl

@@ -28,6 +28,9 @@ load(
 # Reexport for cargo_build_script_wrapper.bzl
 name_to_crate_name = _name_to_crate_name
 
+# Keep this short: it is part of CARGO_MANIFEST_DIR on Windows.
+_CARGO_MANIFEST_DIR = "m"
+
 CargoBuildScriptRunfilesInfo = provider(
     doc = "Info about a `cargo_build_script.script` target.",
     fields = {
@@ -293,13 +296,33 @@ def _feature_enabled(ctx, feature_name, default = False):
 
     return default
 
+def _manifest_rlocation_prefix(workspace_name, package):
+    if package:
+        return "{}/{}".format(workspace_name, package)
+
+    return workspace_name
+
 def _rlocationpath(file, workspace_name):
     if file.short_path.startswith("../"):
         return file.short_path[len("../"):]
 
     return "{}/{}".format(workspace_name, file.short_path)
 
-def _create_runfiles_dir(ctx, script, retain_list):
+def _manifest_dir_rlocationpath(rlocationpath, manifest_rlocation_prefix):
+    prefix = manifest_rlocation_prefix + "/"
+    if rlocationpath == manifest_rlocation_prefix:
+        return _CARGO_MANIFEST_DIR
+    if rlocationpath.startswith(prefix):
+        return paths.join(_CARGO_MANIFEST_DIR, rlocationpath[len(prefix):])
+
+    return None
+
+def _create_runfiles_dir(
+        ctx,
+        script,
+        retain_list,
+        workspace_name,
+        manifest_rlocation_prefix):
     """Create a runfiles directory to represent `CARGO_MANIFEST_DIR`.
 
     Due to the inability to forcibly generate runfiles directories for use as inputs
@@ -314,20 +337,24 @@ def _create_runfiles_dir(ctx, script, retain_list):
         ctx (ctx): The rule's context object
         script (Target): The `cargo_build_script.script` target.
         retain_list (list): A list of strings to keep in generated runfiles directories.
+        workspace_name (str): The runfiles workspace name for the current repository.
+        manifest_rlocation_prefix (str): The current package's runfiles path prefix.
 
     Returns:
         Tuple[File, Depset[File], Args]:
             - The output directory to be created.
             - Runfile inputs needed by the action.
             - The args required to create the directory.
     """
-    runfiles_dir = ctx.actions.declare_directory("{}.cargo_runfiles".format(ctx.label.name))
-
-    # External repos always fall into the `../` branch of `_rlocationpath`.
-    workspace_name = ctx.workspace_name
+    runfiles_dir = ctx.actions.declare_directory(ctx.label.name + ".crf")
 
     def _runfiles_map(file):
-        return "{}={}".format(file.path, _rlocationpath(file, workspace_name))
+        rlocationpath = _rlocationpath(file, workspace_name)
+        manifest_path = _manifest_dir_rlocationpath(rlocationpath, manifest_rlocation_prefix)
+        if not manifest_path:
+            return "{}={}".format(file.path, rlocationpath)
+
+        return "{}={}".format(file.path, manifest_path)
 
     runfiles = script[DefaultInfo].default_runfiles
 
@@ -382,8 +409,10 @@ def _cargo_build_script_impl(ctx):
         ctx = ctx,
         script = ctx.attr.script,
         retain_list = ctx.attr._cargo_manifest_dir_filename_suffixes_to_retain[BuildSettingInfo].value,
+        workspace_name = workspace_name,
+        manifest_rlocation_prefix = _manifest_rlocation_prefix(workspace_name, ctx.label.package),
     )
-    manifest_dir = "{}/{}/{}".format(runfiles_dir.path, workspace_name, ctx.label.package)
+    manifest_dir = paths.join(runfiles_dir.path, _CARGO_MANIFEST_DIR)
 
     pkg_name = ctx.attr.pkg_name
     if pkg_name == "":
@@ -538,6 +567,7 @@ def _cargo_build_script_impl(ctx):
             known_variables.update(variables)
 
     if ctx.attr.build_script_env:
+        _fail_on_rlocationpath_env(ctx.attr.build_script_env)
         _merge_env_dict(env, expand_dict_value_locations(
             ctx,
             ctx.attr.build_script_env,
@@ -573,8 +603,6 @@ def _cargo_build_script_impl(ctx):
     args.add(link_flags, format = "--link_flags=%s")
     args.add(link_search_paths, format = "--link_search_paths=%s")
     args.add(dep_env_out, format = "--dep_env_out=%s")
-    args.add(ctx.attr.rundir, format = "--rundir=%s")
-
     output_groups = {
         "out_dir": depset([out_dir]),
     }
@@ -642,7 +670,7 @@ def _cargo_build_script_impl(ctx):
         tools = tools,
         inputs = depset(build_script_inputs, transitive = [runfiles_inputs]),
         mnemonic = "CargoBuildScriptRun",
-        progress_message = "Running Cargo build script {}".format(pkg_name),
+        progress_message = "Running Cargo build script %{label}",
         env = env,
         toolchain = None,
         use_default_shell_env = use_default_shell_env,
@@ -660,7 +688,8 @@ def _cargo_build_script_impl(ctx):
             flags = flags_out,
             linker_flags = link_flags,
             link_search_paths = link_search_paths,
-            compile_data = depset([runfiles_dir] + extra_output, transitive = script_data),
+            build_script_data = depset(transitive = script_data),
+            compile_data = depset([runfiles_dir] + extra_output),
         ),
         OutputGroupInfo(
             **output_groups
@@ -717,19 +746,6 @@ cargo_build_script = rule(
         "pkg_name": attr.string(
             doc = "The name of package being compiled, if not derived from `name`.",
         ),
-        "rundir": attr.string(
-            default = "",
-            doc = dedent("""\
-                A directory to cd to before the cargo_build_script is run.
-
-                This should be a pathrelative to the exec root. The default behaviour (and the
-                behaviour if rundir is set to the empty string) is to change to the relative
-                path corresponding to the cargo manifest directory, which replicates the
-                normal behaviour of cargo so it is easy to write compatible build scripts.
-
-                If set to `.`, the cargo build script will run in the exec root.
-            """),
-        ),
         "rustc_flags": attr.string_list(
             doc = dedent("""\
                 List of compiler flags passed to `rustc`.
@@ -818,6 +834,13 @@ def _merge_env_dict(prefix_dict, suffix_dict):
             prefix_dict[key] += " " + suffix_dict.pop(key)
     prefix_dict.update(suffix_dict)
 
+def _fail_on_rlocationpath_env(env):
+    for key, value in env.items():
+        if "$(rlocationpath" in value:
+            fail(
+                "cargo_build_script build_script_env does not support $(rlocationpath ...) in '{}'; use $(execpath ...) or $(location ...) for files needed while running the build script".format(key),
+            )
+
 def name_to_pkg_name(name):
     """Sanitize the name of cargo_build_script targets.
 

cargo/private/cargo_build_script_runner/bin.rs

@@ -18,7 +18,7 @@
 use std::collections::BTreeMap;
 use std::env;
 use std::fs::{create_dir_all, read_dir, read_to_string, remove_file, write};
-use std::path::{Path, PathBuf};
+use std::path::Path;
 use std::process::Command;
 
 use cargo_build_script_runner::cargo_manifest_dir::{remove_symlink, symlink, RunfilesMaker};
@@ -46,7 +46,6 @@ fn run_buildrs() -> Result<(), String> {
         output_dep_env_path,
         stdout_path,
         stderr_path,
-        rundir,
         input_dep_env_paths,
         cargo_manifest_maker,
     } = Args::parse();
@@ -85,11 +84,9 @@ fn run_buildrs() -> Result<(), String> {
     let target_env_vars =
         get_target_env_vars(&rustc_env).expect("Error getting target env vars from rustc");
 
-    let working_directory = resolve_rundir(&rundir, &exec_root, &manifest_dir)?;
-
     let mut command = Command::new(exec_root.join(progname));
     command
-        .current_dir(&working_directory)
+        .current_dir(&manifest_dir)
         .envs(target_env_vars)
         .env("OUT_DIR", &out_dir_abs)
         .env("CARGO_MANIFEST_DIR", manifest_dir)
@@ -315,23 +312,6 @@ fn symlink_if_not_exists(original: &Path, link: &Path) -> Result<(), String> {
         .map_err(|err| format!("Failed to create symlink: {err}"))
 }
 
-fn resolve_rundir(rundir: &str, exec_root: &Path, manifest_dir: &Path) -> Result<PathBuf, String> {
-    if rundir.is_empty() {
-        return Ok(manifest_dir.to_owned());
-    }
-    let rundir_path = Path::new(rundir);
-    if rundir_path.is_absolute() {
-        return Err(format!("rundir must be empty (to run in manifest path) or relative path (relative to exec root), but was {:?}", rundir));
-    }
-    if rundir_path
-        .components()
-        .any(|c| c == std::path::Component::ParentDir)
-    {
-        return Err(format!("rundir must not contain .. but was {:?}", rundir));
-    }
-    Ok(exec_root.join(rundir_path))
-}
-
 fn swallow_already_exists(err: std::io::Error) -> std::io::Result<()> {
     if err.kind() == std::io::ErrorKind::AlreadyExists {
         Ok(())
@@ -352,7 +332,6 @@ struct Args {
     output_dep_env_path: String,
     stdout_path: Option<String>,
     stderr_path: Option<String>,
-    rundir: String,
     input_dep_env_paths: Vec<String>,
     cargo_manifest_maker: RunfilesMaker,
 }
@@ -376,7 +355,6 @@ impl Args {
             Err("Argument `output_dep_env_path` not provided".to_owned());
         let mut stdout_path = None;
         let mut stderr_path = None;
-        let mut rundir: Result<String, String> = Err("Argument `rundir` not provided".to_owned());
         let mut input_dep_env_paths = Vec::new();
         let mut cargo_manifest_maker: Result<RunfilesMaker, String> =
             Err("Argument `cargo_manifest_args` not provided".to_owned());
@@ -402,8 +380,6 @@ impl Args {
                 stdout_path = Some(arg.split_off("--stdout=".len()));
             } else if arg.starts_with("--stderr=") {
                 stderr_path = Some(arg.split_off("--stderr=".len()));
-            } else if arg.starts_with("--rundir=") {
-                rundir = Ok(arg.split_off("--rundir=".len()))
             } else if arg.starts_with("--input_dep_env_path=") {
                 input_dep_env_paths.push(arg.split_off("--input_dep_env_path=".len()));
             } else if arg.starts_with("--cargo_manifest_args=") {
@@ -424,7 +400,6 @@ impl Args {
             output_dep_env_path: output_dep_env_path.unwrap(),
             stdout_path,
             stderr_path,
-            rundir: rundir.unwrap(),
             input_dep_env_paths,
             cargo_manifest_maker: cargo_manifest_maker.unwrap(),
         }
@@ -493,6 +468,7 @@ fn main() {
 mod test {
     use super::*;
     use std::fs::{create_dir_all, write};
+    use std::path::PathBuf;
 
     fn make_temp_dir(label: &str) -> PathBuf {
         let nanos = std::time::SystemTime::now()

cargo/private/cargo_build_script_runner/cargo_manifest_dir.rs

@@ -112,8 +112,8 @@ pub struct RunfilesMaker {
     /// A list of file suffixes to retain when pruning runfiles.
     filename_suffixes_to_retain: BTreeSet<String>,
 
-    /// Runfiles to include in `output_dir`.
-    runfiles: BTreeMap<PathBuf, RlocationPath>,
+    /// Runfiles to include in `output_dir`, keyed by destination path.
+    runfiles: BTreeMap<RlocationPath, PathBuf>,
 }
 
 impl RunfilesMaker {
@@ -151,7 +151,7 @@ impl RunfilesMaker {
                 let (src, dest) = s
                     .split_once('=')
                     .unwrap_or_else(|| panic!("Unexpected runfiles argument: {}", s));
-                (PathBuf::from(src), RlocationPath::from(dest))
+                (RlocationPath::from(dest), PathBuf::from(src))
             })
             .collect::<BTreeMap<_, _>>();
 
@@ -167,7 +167,7 @@ impl RunfilesMaker {
     /// Create a runfiles directory.
     #[cfg(target_family = "unix")]
     pub fn create_runfiles_dir(&self) -> Result<(), String> {
-        for (src, dest) in &self.runfiles {
+        for (dest, src) in &self.runfiles {
             let abs_dest = self.output_dir.join(dest);
 
             if let Some(parent) = abs_dest.parent() {
@@ -213,7 +213,7 @@ impl RunfilesMaker {
 
         let supports_symlinks = system_supports_symlinks(&self.output_dir)?;
 
-        for (src, dest) in &self.runfiles {
+        for (dest, src) in &self.runfiles {
             let abs_dest = self.output_dir.join(dest);
             if let Some(parent) = abs_dest.parent() {
                 if !parent.exists() {
@@ -258,7 +258,7 @@ impl RunfilesMaker {
     /// The Unix implementation assumes symlinks are supported and that the runfiles directory
     /// was created using symlinks.
     fn drain_runfiles_dir_unix(&self) -> Result<(), String> {
-        for (src, dest) in &self.runfiles {
+        for (dest, src) in &self.runfiles {
             let abs_dest = self.output_dir.join(dest);
 
             remove_symlink(&abs_dest).map_err(|e| {
@@ -315,19 +315,17 @@ impl RunfilesMaker {
     /// The Windows implementation assumes symlinks are not supported and real files will have
     /// been copied into the runfiles directory.
     fn drain_runfiles_dir_windows(&self) -> Result<(), String> {
-        for dest in self.runfiles.values() {
+        for dest in self.runfiles.keys() {
             if !self
                 .filename_suffixes_to_retain
                 .iter()
                 .any(|suffix| dest.ends_with(suffix))
             {
-                continue;
+                let abs_dest = self.output_dir.join(dest);
+                std::fs::remove_file(&abs_dest).map_err(|e| {
+                    format!("Failed to remove file {} with {:?}", abs_dest.display(), e)
+                })?;
             }
-
-            let abs_dest = self.output_dir.join(dest);
-            std::fs::remove_file(&abs_dest).map_err(|e| {
-                format!("Failed to remove file {} with {:?}", abs_dest.display(), e)
-            })?;
         }
         Ok(())
     }