cargo-rail: updating the 'unify' process and transitive nightmare; cleaning up the split/sync commands and rail.toml configs.

Author: loadingalias

README.md

@@ -179,7 +179,8 @@ components = ["clippy", "rustfmt"]
 
 # Dependency unification
 [unify]
-pin_transitives = false
+consolidate_transitive_features = false  # Consolidate transitive deps
+transitive_feature_host = "auto"         # Smart auto-selection
 validate_targets = []
 
 # Split/sync (optional)

src/cargo/manifest.rs

@@ -287,21 +287,48 @@ impl CargoTransform {
       doc["workspace"] = table();
     }
 
-    // Ensure [workspace.dependencies] section exists
-    let workspace = doc["workspace"]
-      .as_table_mut()
-      .ok_or_else(|| RailError::message("[workspace] is not a table"))?;
+    // Write each unified dependency
+    // Group by target (None for regular deps, Some(target) for platform-specific)
+    for unified in unified_deps {
+      // Determine which table to write to based on target
+      let deps_table = if let Some(ref target) = unified.target {
+        // Platform-specific dependency: write to [target.'<target>'.dependencies]
+        let target_key = format!("target.'{}'", target);
+
+        // Ensure target section exists in workspace
+        let workspace = doc["workspace"]
+          .as_table_mut()
+          .ok_or_else(|| RailError::message("[workspace] is not a table"))?;
+
+        if !workspace.contains_key(&target_key) {
+          workspace[&target_key] = table();
+        }
 
-    if !workspace.contains_key("dependencies") {
-      workspace["dependencies"] = table();
-    }
+        let target_section = workspace[&target_key]
+          .as_table_mut()
+          .ok_or_else(|| RailError::message(format!("[workspace.{}] is not a table", target_key)))?;
 
-    let workspace_deps = workspace["dependencies"]
-      .as_table_mut()
-      .ok_or_else(|| RailError::message("[workspace.dependencies] is not a table"))?;
+        if !target_section.contains_key("dependencies") {
+          target_section["dependencies"] = table();
+        }
 
-    // Write each unified dependency
-    for unified in unified_deps {
+        target_section["dependencies"]
+          .as_table_mut()
+          .ok_or_else(|| RailError::message(format!("[workspace.{}.dependencies] is not a table", target_key)))?
+      } else {
+        // Regular dependency: write to [workspace.dependencies]
+        let workspace = doc["workspace"]
+          .as_table_mut()
+          .ok_or_else(|| RailError::message("[workspace] is not a table"))?;
+
+        if !workspace.contains_key("dependencies") {
+          workspace["dependencies"] = table();
+        }
+
+        workspace["dependencies"]
+          .as_table_mut()
+          .ok_or_else(|| RailError::message("[workspace.dependencies] is not a table"))?
+      };
       // Use inline table for simple deps and deps with few features
       // Use regular table format only for deps with many features (>10) to avoid long lines
       let use_inline_table = unified.features.len() <= 10;
@@ -335,12 +362,12 @@ impl CargoTransform {
         }
 
         // Insert the dependency
-        workspace_deps.insert(&unified.name, toml_edit::Item::Value(dep_table.into()));
+        deps_table.insert(&unified.name, toml_edit::Item::Value(dep_table.into()));
 
         // Add comments if enabled and any exist
         if add_comments
           && !unified.comments.is_empty()
-          && let Some(item) = workspace_deps.get_mut(&unified.name)
+          && let Some(item) = deps_table.get_mut(&unified.name)
         {
           let comment_str = unified.comments.join(", ");
           item
@@ -373,7 +400,7 @@ impl CargoTransform {
         dep_table["features"] = toml_edit::value(Value::Array(features_array));
 
         // Insert the dependency
-        workspace_deps.insert(&unified.name, dep_table);
+        deps_table.insert(&unified.name, dep_table);
 
         // Add comments if enabled and any exist
         // Note: Comments for regular tables are more complex - for now we skip them
@@ -671,12 +698,15 @@ members = ["crate-a", "crate-b"]
       name: "serde".to_string(),
       version_req: VersionReq::parse("1.0").unwrap(),
       features: vec!["derive".to_string()],
+      feature_provenance: HashMap::new(),
       default_features: true,
       used_by: vec!["crate-a".to_string(), "crate-b".to_string()],
       dep_kinds: HashSet::new(),
       fragmentation_count: 2,
       path: None,
+      target: None,
       comments: Vec::new(),
+      is_proc_macro: false,
     }];
 
     // Write workspace dependencies
@@ -728,12 +758,15 @@ members = ["crate-a"]
       name: "anyhow".to_string(),
       version_req: VersionReq::parse("1.0").unwrap(),
       features: vec![], // No features
+      feature_provenance: HashMap::new(),
       default_features: true,
       used_by: vec!["crate-a".to_string()],
       dep_kinds: HashSet::new(),
       fragmentation_count: 1,
       path: None,
+      target: None,
       comments: Vec::new(),
+      is_proc_macro: false,
     }];
 
     transformer
@@ -766,12 +799,15 @@ members = ["crate-a"]
       name: "tokio".to_string(),
       version_req: VersionReq::parse("1.0").unwrap(),
       features: vec!["fs".to_string(), "net".to_string()],
+      feature_provenance: HashMap::new(),
       default_features: false, // Explicitly disabled
       used_by: vec!["crate-a".to_string()],
       dep_kinds: HashSet::new(),
       fragmentation_count: 1,
       path: None,
+      target: None,
       comments: Vec::new(),
+      is_proc_macro: false,
     }];
 
     transformer

src/cargo/mod.rs

@@ -24,5 +24,5 @@ pub mod validate;
 
 pub use manifest::{CargoTransform, TransformContext};
 pub use metadata::WorkspaceMetadata;
-pub use unify::{IssueSeverity, UnifiedDep, UnifyConfig, UnifyReport, UnifyStrategy, WorkspaceUnifier};
+pub use unify::{IssueSeverity, UnifiedDep, UnifyConfig, UnifyReport, WorkspaceUnifier};
 pub use validate::validate_targets;

src/cargo/unify/collector.rs

@@ -1,7 +1,7 @@
 //! Dependency collection from workspace members
 
 use super::path_handling::is_workspace_member_path;
-use super::types::DependencyInstance;
+use super::types::{DependencyInstance, FeatureSource};
 use crate::cargo::WorkspaceMetadata;
 use std::collections::{HashMap, HashSet};
 
@@ -39,17 +39,25 @@ pub fn collect_dependencies(metadata: &WorkspaceMetadata) -> Vec<DependencyInsta
         dep.features.clone()
       };
 
+      // Track feature provenance: WHY is each feature enabled?
+      let feature_provenance = determine_feature_provenance(&features, dep, &pkg.name, metadata);
+
+      // Detect if this is a proc-macro crate
+      // Proc-macros are build-time only and have different optimization strategies
+      let is_proc_macro = metadata.is_proc_macro_crate(&dep.name);
+
       instances.push(DependencyInstance {
         member: pkg.name.to_string(),
         name: dep.name.clone(),
         version_req: dep.req.clone(),
         features,
+        feature_provenance,
         default_features: dep.uses_default_features,
-        optional: dep.optional,
         kind: dep.kind,
         target: dep.target.as_ref().map(|t| t.to_string()),
         rename: dep.rename.clone(),
         path: dep.path.clone(),
+        is_proc_macro,
       });
     }
   }
@@ -111,3 +119,68 @@ fn get_member_workspace_deps(manifest_path: &cargo_metadata::camino::Utf8Path) -
 
   workspace_deps
 }
+
+/// Determine WHY each feature is enabled for a dependency
+///
+/// This is the key to showing users Cargo.toml-level information about their dependencies.
+/// We check multiple sources in order of specificity:
+/// 1. Direct declaration in member's Cargo.toml
+/// 2. Default features
+/// 3. Target-specific
+/// 4. Transitive or --all-features
+fn determine_feature_provenance(
+  resolved_features: &[String],
+  dep: &cargo_metadata::Dependency,
+  member_name: &str,
+  metadata: &WorkspaceMetadata,
+) -> HashMap<String, FeatureSource> {
+  let mut provenance = HashMap::new();
+
+  // Get the actual package metadata for this dependency
+  let dep_pkg = metadata.get_package(&dep.name);
+
+  for feature in resolved_features {
+    let source = determine_single_feature_source(feature, dep, member_name, dep_pkg);
+    provenance.insert(feature.clone(), source);
+  }
+
+  provenance
+}
+
+/// Determine the source of a single feature
+fn determine_single_feature_source(
+  feature: &str,
+  dep: &cargo_metadata::Dependency,
+  member_name: &str,
+  dep_pkg: Option<&cargo_metadata::Package>,
+) -> FeatureSource {
+  // 1. Check if declared directly in this member's Cargo.toml
+  if dep.features.contains(&feature.to_string()) {
+    return FeatureSource::Direct {
+      member: member_name.to_string(),
+    };
+  }
+
+  // 2. Check if it's a default feature (and default features are enabled)
+  if dep.uses_default_features
+    && let Some(pkg) = dep_pkg
+    && let Some(default_features) = pkg.features.get("default")
+  {
+    // Default features can reference other features
+    if default_features.iter().any(|f| f.trim_start_matches("dep:") == feature) {
+      return FeatureSource::Default;
+    }
+  }
+
+  // 3. Check if target-specific
+  if let Some(ref target) = dep.target {
+    return FeatureSource::TargetSpecific {
+      target: target.to_string(),
+    };
+  }
+
+  // 4. Otherwise it's either transitive or from --all-features
+  // For now, we classify it as AllFeatures since we're using --all-features metadata
+  // In a future enhancement, we could trace the actual dependency chain
+  FeatureSource::AllFeatures
+}

src/cargo/unify/config.rs

@@ -1,17 +1,11 @@
 //! Configuration for workspace dependency unification
 
+use crate::config::RailConfig;
 use std::collections::HashSet;
 
 /// Configuration for workspace unification
 #[derive(Debug, Clone)]
 pub struct UnifyConfig {
-  /// Strategy for selecting dependencies to unify
-  ///
-  /// Currently only UnifyStrategy::All is supported. This field is kept for
-  /// future extensibility (e.g., threshold-based unification, fragmentation-only).
-  #[allow(dead_code)]
-  pub strategy: UnifyStrategy,
-
   /// Allow renamed dependencies to be unified (default: false)
   pub allow_renamed: bool,
 
@@ -31,17 +25,9 @@ pub struct UnifyConfig {
   pub generate_report: bool,
 }
 
-/// Strategy for selecting which dependencies to unify
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
-pub enum UnifyStrategy {
-  /// Unify all possible dependencies
-  All,
-}
-
 impl Default for UnifyConfig {
   fn default() -> Self {
     Self {
-      strategy: UnifyStrategy::All,
       allow_renamed: false,
       exclude: HashSet::new(),
       include: HashSet::new(),
@@ -51,3 +37,16 @@ impl Default for UnifyConfig {
     }
   }
 }
+
+impl From<&RailConfig> for UnifyConfig {
+  fn from(rail_config: &RailConfig) -> Self {
+    Self {
+      allow_renamed: rail_config.unify.allow_renamed,
+      exclude: rail_config.unify.exclude.iter().cloned().collect(),
+      include: rail_config.unify.include.iter().cloned().collect(),
+      auto_resolve_version_conflicts: rail_config.unify.conflicts.auto_resolve,
+      add_conflict_comments: rail_config.unify.conflicts.add_markers,
+      generate_report: rail_config.unify.output.generate_report,
+    }
+  }
+}

src/cargo/unify/issue_detection.rs

@@ -4,7 +4,7 @@ use super::path_handling::are_all_identical_workspace_paths;
 use super::types::{DependencyInstance, IssueSeverity, IssueType, UnificationIssue};
 use crate::cargo::WorkspaceMetadata;
 use crate::error::RailResult;
-use std::collections::HashMap;
+use std::collections::{HashMap, HashSet};
 
 /// Detect dependencies that exist in multiple resolved versions
 ///
@@ -138,14 +138,34 @@ pub fn detect_issues(
   // Check if all are target-specific
   if instances.iter().all(|i| i.target.is_some()) {
     let targets: Vec<_> = instances.iter().filter_map(|i| i.target.clone()).collect();
+
+    // Check if all instances use the SAME target
+    let unique_targets: HashSet<_> = targets.iter().collect();
+
+    if unique_targets.len() == 1 {
+      // All instances use the same target - we CAN unify this!
+      // This is NOT an issue, it's a unification opportunity
+      // Don't return an issue here - let the normal unification flow handle it
+      // The unified dep can use [target.'cfg(...)'.dependencies]
+      return None;
+    }
+
+    // Multiple different targets - this is more complex
     return Some(UnificationIssue {
       dep_name: dep_name.to_string(),
       issue_type: IssueType::AllTargetSpecific {
         targets: targets.clone(),
       },
-      severity: IssueSeverity::Info, // Just informational, not a blocker
+      severity: IssueSeverity::Info, // Just informational
       affected_members: instances.iter().map(|i| i.member.clone()).collect(),
-      suggestion: "Target-specific dependencies cannot be unified at workspace level".to_string(),
+      suggestion: format!(
+        "Multiple platform-specific targets detected: {}. Consider per-platform unification.",
+        unique_targets
+          .iter()
+          .map(|t| format!("'{}'", t))
+          .collect::<Vec<_>>()
+          .join(", ")
+      ),
     });
   }
 
@@ -194,12 +214,13 @@ mod tests {
       name: "test-dep".to_string(),
       version_req: VersionReq::parse(version).unwrap(),
       features: vec![],
+      feature_provenance: std::collections::HashMap::new(),
       default_features: true,
-      optional: false,
       kind: DependencyKind::Normal,
       target: None,
       rename: None,
       path: None,
+      is_proc_macro: false,
     }
   }
 

src/cargo/unify/mod.rs

@@ -50,7 +50,7 @@ mod unifier;
 mod version_merge;
 
 // Re-export public types
-pub use config::{UnifyConfig, UnifyStrategy};
+pub use config::UnifyConfig;
 pub use report::UnifyReport;
 pub use types::{IssueSeverity, MemberEdit, UnificationPlan, UnificationStats, UnifiedDep};