Support splicing manifests from multiple Cargo workspaces

When manifests come from different Cargo workspaces (e.g. a primary
workspace depending on crates in a separate external workspace),
splicing previously failed with "manifests are not allowed to come from
different workspaces".

This change:
- Adds `main_manifest` to SplicingManifest so the splicer can
  disambiguate which workspace root is primary when multiple are found.
- Nests the spliced workspace at its repo-relative depth inside the temp
  dir so that `../` path deps resolve within the temp dir instead of
  escaping into unwritable system directories.
- Collects path deps from `[workspace.dependencies]` in addition to
  per-package deps.
- Symlinks entire foreign workspace root directories (not just crate
  dirs) so Cargo can walk up and resolve `dep.workspace = true`
  inherited dependencies.
- Wires `main_manifest` through extensions.bzl and crates_vendor.bzl.
- Calls symlink_external_path_deps from the cargo_tree_resolver so
  `cargo tree` also sees external path deps.

This fixes #3089,
along with adding support for multiple workspaces in the splicer.

Co-Authored-By: Steve Barrau <98589981+stevebarrau@users.noreply.github.com>

Author: malt3

crate_universe/extensions.bzl

@@ -562,7 +562,8 @@ def _generate_hub_and_spokes(
         strip_internal_dependencies_from_cargo_lockfile,
         cargo_lockfile = None,
         manifests = {},
-        packages = {}):
+        packages = {},
+        main_manifest = None):
     """Generates repositories for the transitive closure of crates defined by manifests and packages.
 
     Args:
@@ -618,6 +619,7 @@ def _generate_hub_and_spokes(
             cargo_config = cfg.cargo_config,
             manifests = manifests,
             manifest_to_path = module_ctx.path,
+            main_manifest = main_manifest,
         ),
     )
 
@@ -1155,10 +1157,13 @@ def _crate_impl(module_ctx):
 
             manifests = {}
             packages = {}
+            main_manifest = None
 
             # Only `from_cargo` instances will have `manifests`.
             if hasattr(cfg, "manifests"):
                 manifests = {str(module_ctx.path(m)): str(m) for m in cfg.manifests}
+                if cfg.manifests:
+                    main_manifest = str(module_ctx.path(cfg.manifests[0]))
 
             packages = {
                 p.package_alias or p.package: _package_to_json(p)
@@ -1178,6 +1183,7 @@ def _crate_impl(module_ctx):
                 packages = packages,
                 skip_cargo_lockfile_overwrite = cfg.skip_cargo_lockfile_overwrite,
                 strip_internal_dependencies_from_cargo_lockfile = cfg.strip_internal_dependencies_from_cargo_lockfile,
+                main_manifest = main_manifest,
             )
 
     metadata_kwargs = {}

crate_universe/private/crates_vendor.bzl

@@ -230,6 +230,7 @@ def _write_splicing_manifest(ctx):
             cargo_config = ctx.attr.cargo_config,
             manifests = manifests,
             manifest_to_path = _prepare_manifest_path,
+            main_manifest = _prepare_manifest_path(ctx.attr.manifests[0]) if ctx.attr.manifests else None,
         ),
     )
 
@@ -240,7 +241,7 @@ def _write_splicing_manifest(ctx):
     runfiles = [manifest] + ctx.files.manifests + ([ctx.file.cargo_config] if ctx.attr.cargo_config else [])
     return args, env, runfiles
 
-def generate_splicing_manifest(*, packages, splicing_config, cargo_config, manifests, manifest_to_path):
+def generate_splicing_manifest(*, packages, splicing_config, cargo_config, manifests, manifest_to_path, main_manifest = None):
     # Deserialize information about direct packages
     direct_packages_info = {
         # Ensure the data is using kebab-case as that's what `cargo_toml::DependencyDetail` expects.
@@ -252,6 +253,7 @@ def generate_splicing_manifest(*, packages, splicing_config, cargo_config, manif
         "cargo_config": str(manifest_to_path(cargo_config)) if cargo_config else None,
         "direct_packages": direct_packages_info,
         "manifests": manifests,
+        "main_manifest": main_manifest,
     }
 
     return json.encode_indent(

crate_universe/src/metadata/cargo_tree_resolver.rs

@@ -16,6 +16,7 @@ use url::Url;
 use crate::config::CrateId;
 use crate::metadata::cargo_bin::Cargo;
 use crate::select::{Select, SelectableScalar};
+use crate::splicing::splicer::symlink_external_path_deps;
 use crate::utils::symlink::symlink;
 use crate::utils::target_triple::TargetTriple;
 
@@ -526,6 +527,34 @@ impl TreeResolver {
             )
         })?;
 
+        // Symlink any path dependencies that live outside the workspace root
+        symlink_external_path_deps(
+            pristine_manifest_path.as_std_path(),
+            pristine_root.as_std_path(),
+            output_dir,
+        )?;
+
+        // Also handle workspace members' external path deps
+        let manifest = cargo_toml::Manifest::from_path(pristine_manifest_path.as_std_path())
+            .with_context(|| format!("Failed to parse manifest at {}", pristine_manifest_path))?;
+        if let Some(ref workspace) = manifest.workspace {
+            for member_pattern in &workspace.members {
+                let glob_pattern = pristine_root.join(member_pattern).to_string();
+                if let Ok(entries) = glob::glob(&glob_pattern) {
+                    for entry in entries.flatten() {
+                        let member_manifest = entry.join("Cargo.toml");
+                        if member_manifest.exists() {
+                            symlink_external_path_deps(
+                                &member_manifest,
+                                pristine_root.as_std_path(),
+                                output_dir,
+                            )?;
+                        }
+                    }
+                }
+            }
+        }
+
         let cargo_metadata = self
             .cargo_bin
             .metadata_command_with_options(

crate_universe/src/splicing.rs

@@ -2,7 +2,7 @@
 
 pub(crate) mod cargo_config;
 mod crate_index_lookup;
-mod splicer;
+pub(crate) mod splicer;
 
 use std::collections::{BTreeMap, BTreeSet};
 use std::fs;
@@ -41,6 +41,11 @@ pub(crate) struct SplicingManifest {
 
     /// The Cargo resolver version to use for splicing
     pub(crate) resolver_version: cargo_toml::Resolver,
+
+    /// The path of the "main" manifest (first in the manifests list).
+    /// Used to disambiguate when manifests come from multiple Cargo workspaces.
+    #[serde(default)]
+    pub(crate) main_manifest: Option<Utf8PathBuf>,
 }
 
 impl FromStr for SplicingManifest {
@@ -61,6 +66,7 @@ impl SplicingManifest {
         let Self {
             manifests,
             cargo_config,
+            main_manifest,
             ..
         } = self;
 
@@ -88,9 +94,19 @@ impl SplicingManifest {
             Utf8PathBuf::from(resolved_path)
         });
 
+        // Resolve the main manifest path
+        let main_manifest = main_manifest.map(|path| {
+            let resolved_path = path
+                .to_string()
+                .replace("${build_workspace_directory}", &workspace_dir_str)
+                .replace("${output_base}", &output_base_str);
+            Utf8PathBuf::from(resolved_path)
+        });
+
         Self {
             manifests,
             cargo_config,
+            main_manifest,
             ..self
         }
     }
@@ -678,6 +694,7 @@ mod test {
             ]),
             cargo_config: None,
             resolver_version: cargo_toml::Resolver::V2,
+            main_manifest: None,
         };
         let metadata = SplicingMetadata::try_from(manifest).unwrap();
         let metadata = serde_json::to_string(&metadata).unwrap();