Struct MultiTargetMetadata 

pub struct MultiTargetMetadata { /* private fields */ }

Multi-target metadata cache for the HYBRID approach

Loads metadata for each target in parallel WITHOUT –all-features. This gives us accurate version resolution per target while avoiding the maximal feature set problem.

Implementations

impl MultiTargetMetadata

pub fn load_parallel( workspace_root: &Path, targets: &[String], ) -> RailResult<Self>

Load metadata for all targets in parallel

pub fn get(&self, target: &str) -> Option<&Metadata>

Get metadata for a specific target

pub fn any(&self) -> Option<&Metadata>

Get metadata for any target (useful when they should all be the same)

pub fn targets(&self) -> Vec<&str>

Get all targets we have metadata for (sorted for deterministic output)

pub fn workspace_packages(&self) -> Vec<&Package>

Get workspace packages (same across all targets)

pub fn all_versions(&self, dep_name: &str) -> HashMap<String, Version>

Get all versions of a dependency across targets (includes transitive deps) Returns map of target -> version NOTE: This includes transitive dependencies - use direct_dep_versions() for direct deps only

pub fn direct_dep_versions(&self, dep_name: &str) -> HashMap<String, Version>

Get versions of a dependency that are DIRECT dependencies of workspace members only

This filters out transitive dependencies, ensuring we only unify versions that workspace members explicitly depend on. Returns map of target -> version.

Note: Within each target, cargo’s resolver produces exactly ONE version per crate. We return that resolved version for each target where the dep is a direct dependency.

pub fn is_transitive_only(&self, dep_name: &str) -> bool

Check if a dependency is transitive-only (never in direct deps)

pub fn is_path_dependency(&self, dep_name: &str) -> bool

Check if a dependency is a path/workspace dependency (not from a registry)

Path dependencies have source: None in cargo metadata. These cannot be pinned in workspace.dependencies without a registry source, so we skip them during transitive pinning.

pub fn all_features(&self, dep_name: &str) -> HashMap<String, HashSet<String>>

Get features enabled for a package across all targets Returns map of target -> set of features

pub fn targets_with_dep(&self, dep_name: &str) -> Vec<String>

Check which targets include a specific dependency (sorted for deterministic output)

pub fn find_fragmented_transitives(&self) -> Vec<FragmentedTransitive>

Detect transitive dependencies with fragmented features These are candidates for pinning (workspace-hack replacement)

pub fn compute_msrv_with_config( &self, workspace_root: &Path, msrv_source: MsrvSource, ) -> Option<ComputedMsrv>

Compute the workspace MSRV with config-driven source selection

Takes into account the existing workspace rust-version and the msrv_source configuration to determine the final MSRV value.

Arguments

• workspace_root - Path to workspace root (for reading existing rust-version)
• msrv_source - How to determine the final MSRV (deps, workspace, or max)

Returns

• None if no MSRV can be determined (no deps have rust-version AND no workspace rust-version)
• Some(ComputedMsrv) with the final MSRV and metadata about the computation

impl MultiTargetMetadata

pub fn package_to_lib_name_map(&self) -> HashMap<String, String>

Build a mapping from package name to library name

In Rust, a crate’s package name (in Cargo.toml) can differ from its library name (what you use in code). For example:

• Package: mopa-maintained
• Library: mopa (what you write as use mopa::...)

The resolved dependency graph uses library names, but Cargo.toml uses package names. This mapping allows correct lookup when detecting unused deps.

Returns a map where:

• Key: package name (e.g., “mopa-maintained”)
• Value: library name normalized with underscores (e.g., “mopa”)

Trait Implementations

impl Clone for MultiTargetMetadata

fn clone(&self) -> MultiTargetMetadata

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.