cargo-rail: meilisearch PR revealed a bug in Meilisearch and in cargo-rail; fixing 'undeclard features detection' to avoid 'borrowed features' sneaking through. added 'auto-fix' undeclared features w/ warning for manual. This is a big win.

Author: loadingalias

docs/config.md

@@ -107,6 +107,8 @@ Controls workspace dependency unification behavior. All options are optional wit
 | `remove_unused` | `bool` | `true` | Automatically remove unused dependencies during unification. Requires `detect_unused = true`. |
 | `prune_dead_features` | `bool` | `true` | Remove features that are never enabled in the resolved dependency graph across all targets. Only prunes empty no-ops (`feature = []`). Features with actual dependencies are preserved. |
 | `preserve_features` | `string[]` | `[]` | Features to preserve from dead feature pruning. Supports glob patterns (e.g., `"unstable-*"`, `"bench*"`). Use this to keep features intended for future use or external consumers. |
+| `detect_undeclared_features` | `bool` | `true` | Detect crates that rely on Cargo's feature unification to "borrow" features from other workspace members. These crates will fail when built standalone after unification. Reports as warnings (or auto-fixes if `fix_undeclared_features` is enabled). |
+| `fix_undeclared_features` | `bool` | `true` | Auto-fix undeclared feature dependencies by adding missing features to each crate's Cargo.toml. Produces a cleaner graph where standalone builds work correctly. Requires `detect_undeclared_features = true`. |
 | `max_backups` | `usize` | `3` | Maximum number of backup archives to keep. Older backups are automatically cleaned up after successful operations. Set to `0` to disable backup creation entirely. |
 
 **Example:**
@@ -119,6 +121,8 @@ detect_unused = true
 remove_unused = true
 prune_dead_features = true
 preserve_features = ["future-api", "unstable-*"]  # Keep these from pruning
+detect_undeclared_features = true  # Catch borrowed features
+fix_undeclared_features = true    # Auto-fix them (default)
 max_backups = 5
 ```
 

src/cargo/manifest_writer.rs

@@ -263,4 +263,89 @@ impl ManifestWriter {
 
     Ok(())
   }
+
+  /// Add features to an existing dependency in a member's Cargo.toml
+  ///
+  /// This is used to fix undeclared feature dependencies - when a crate relies on
+  /// Cargo's feature unification to "borrow" features from other workspace members.
+  ///
+  /// # Arguments
+  /// * `member_toml_path` - Path to the member's Cargo.toml
+  /// * `dep_name` - Name of the dependency to update
+  /// * `dep_kind` - Type of dependency (Normal, Dev, Build)
+  /// * `target` - Optional target platform constraint (e.g., "cfg(unix)")
+  /// * `features_to_add` - Features to add to the dependency
+  pub fn add_features(
+    &self,
+    member_toml_path: &Path,
+    dep_name: &str,
+    dep_kind: DepKind,
+    target: Option<&str>,
+    features_to_add: &[String],
+  ) -> RailResult<()> {
+    // Read member Cargo.toml
+    let mut doc = manifest_ops::read_toml_file(member_toml_path)?;
+
+    // Get section name from kind
+    let kind_section = self.dep_kind_to_section(dep_kind);
+
+    // Handle target-specific vs regular sections
+    let dep_item = if let Some(target_cfg) = target {
+      // Target-specific: look in [target.'cfg(...)'.dependencies]
+      let path = format!("target.{}.{}", target_cfg, kind_section);
+      let table = manifest_ops::get_or_create_table(&mut doc, &path)?;
+      table.get_mut(dep_name)
+    } else {
+      // Regular section
+      doc
+        .get_mut(kind_section)
+        .and_then(|t| t.as_table_mut())
+        .and_then(|t| t.get_mut(dep_name))
+    };
+
+    let Some(dep_item) = dep_item else {
+      // Dependency not found in manifest - skip silently
+      // This can legitimately happen with:
+      // - Renamed dependencies (package = "other-name")
+      // - Target-specific deps where the target section doesn't exist
+      // - Dependencies that were already converted to workspace = true
+      return Ok(());
+    };
+
+    // Get existing features (if any)
+    let mut existing_features: Vec<String> = manifest_ops::extract_features(dep_item).unwrap_or_default();
+
+    // Add new features (dedup)
+    for feature in features_to_add {
+      if !existing_features.contains(feature) {
+        existing_features.push(feature.clone());
+      }
+    }
+
+    // Sort for consistency
+    existing_features.sort();
+
+    // Update the dependency entry
+    // If it's a simple string like `serde = "1.0"`, we need to convert it to a table
+    if dep_item.is_str() {
+      // Convert simple string (e.g., `dep = "1.0"`) to inline table with features
+      let version = dep_item
+        .as_str()
+        .expect("dep_item.is_str() was true but as_str() returned None")
+        .to_string();
+      let mut inline_table = toml_edit::InlineTable::new();
+      inline_table.insert("version", toml_edit::Value::from(version));
+      inline_table.insert("features", manifest_ops::build_feature_array(&existing_features));
+      *dep_item = toml_edit::Item::Value(toml_edit::Value::InlineTable(inline_table));
+    } else {
+      // Already a table, just update features
+      manifest_ops::set_features(dep_item, existing_features)?;
+    }
+
+    // Format and write
+    self.formatter.format_manifest(&mut doc)?;
+    manifest_ops::write_toml_file(member_toml_path, &doc)?;
+
+    Ok(())
+  }
 }

src/cargo/mod.rs

@@ -26,6 +26,6 @@ pub use multi_target_metadata::{ComputedMsrv, FragmentedTransitive, MsrvSourceUs
 pub use unify_analyzer::UnifyAnalyzer;
 pub use unify_report::UnifyReport;
 pub use unify_types::{
-  DuplicateCleanup, IssueSeverity, MemberEdit, OptionalFeature, PrunedFeature, TransitivePin, UnificationPlan,
-  UnifiedDep, UnifyIssue, UnusedDep, UnusedReason, ValidationResult, VersionMismatch,
+  DuplicateCleanup, IssueSeverity, MemberEdit, OptionalFeature, PrunedFeature, TransitivePin, UndeclaredFeature,
+  UnificationPlan, UnifiedDep, UnifyIssue, UnusedDep, UnusedReason, ValidationResult, VersionMismatch,
 };

src/cargo/unify_analyzer.rs

@@ -9,8 +9,8 @@ use crate::cargo::{
   unify::version_utils::{find_major_version_conflicts, is_exact_pin, versions_compatible},
   unify::{CandidateIterator, FeaturePruner, TransitivePlanner, UnusedDepFinder},
   unify_types::{
-    DuplicateCleanup, IssueSeverity, MemberEdit, UnificationPlan, UnifiedDep, UnifyIssue, ValidationResult,
-    VersionMismatch,
+    DuplicateCleanup, IssueSeverity, MemberEdit, UndeclaredFeature, UnificationPlan, UnifiedDep, UnifyIssue,
+    ValidationResult, VersionMismatch,
   },
 };
 use crate::config::{ExactPinHandling, MajorVersionConflict, UnifyConfig};
@@ -473,6 +473,56 @@ impl UnifyAnalyzer {
       member_edits.entry(crate_name).or_default().extend(edits);
     }
 
+    // === Detect undeclared features ===
+    // Find cases where a crate uses features that it didn't declare in Cargo.toml
+    // This happens when Cargo's feature unification "borrows" features from other members
+    let undeclared_features = if self.config.detect_undeclared_features {
+      progress!("Checking for undeclared feature dependencies...");
+      self.detect_undeclared_features()
+    } else {
+      Vec::new()
+    };
+
+    // Generate fixes or warnings for undeclared features
+    if self.config.fix_undeclared_features && !undeclared_features.is_empty() {
+      progress!(
+        "Generating fixes for {} undeclared feature issues...",
+        undeclared_features.len()
+      );
+      for uf in &undeclared_features {
+        let edit = MemberEdit::AddFeatures {
+          dep_name: uf.dep_name.clone(),
+          dep_kind: uf.dep_kind,
+          target: uf.target.clone(),
+          features_to_add: uf.undeclared_features.clone(),
+        };
+        member_edits.entry(uf.member.clone()).or_default().push(edit);
+      }
+    } else {
+      // Add issues for undeclared features (warn mode)
+      for uf in &undeclared_features {
+        issues.push(UnifyIssue {
+          dep_name: uf.dep_name.clone(),
+          severity: IssueSeverity::Warning,
+          message: format!(
+            "{} uses {} features [{}] but only declares [{}]. \
+             This crate relies on feature unification from other workspace members. \
+             After unification, standalone builds will fail. \
+             Fix: Add the missing features to {}'s Cargo.toml.",
+            uf.member,
+            uf.dep_name,
+            uf.undeclared_features.join(", "),
+            if uf.declared_features.is_empty() {
+              "none".to_string()
+            } else {
+              uf.declared_features.join(", ")
+            },
+            uf.member,
+          ),
+        });
+      }
+    }
+
     // Run validation
     let validation_results = self.validate_targets()?;
 
@@ -489,6 +539,7 @@ impl UnifyAnalyzer {
       optional_features,
       version_mismatches,
       unused_deps,
+      undeclared_features,
     })
   }
 
@@ -534,4 +585,95 @@ impl UnifyAnalyzer {
       )
     }
   }
+
+  /// Detect dependencies where resolved features exceed declared features
+  ///
+  /// This catches cases where a crate relies on Cargo's feature unification to
+  /// "borrow" features from other workspace members. After workspace dependency
+  /// unification, standalone builds (cargo test -p <crate>) will fail because
+  /// the borrowed features are no longer available.
+  ///
+  /// Example:
+  /// - crate A declares: `backoff = "0.4"` (no features)
+  /// - crate B declares: `backoff = { version = "0.4", features = ["tokio"] }`
+  /// - crate A uses `backoff::future::retry()` which requires `features = ["futures"]`
+  /// - When building the whole workspace, A gets `futures` from B via unification
+  /// - After unification, A's standalone build fails
+  fn detect_undeclared_features(&self) -> Vec<UndeclaredFeature> {
+    let mut undeclared = Vec::new();
+
+    // Common features that are typically not actionable:
+    // - "default", "std" - usually implicit
+    // - Internal features like "*_backend", "*_impl" - implementation details
+    let should_skip_feature = |f: &str| -> bool {
+      f == "default" || f == "std" || f == "alloc" || f.ends_with("_backend") || f.ends_with("_impl")
+    };
+
+    // Build a map of what each member explicitly declares for each dependency
+    // We want to find cases where member A would need a feature that ONLY comes from member B
+    let mut member_declared_features: HashMap<String, HashMap<String, HashSet<String>>> = HashMap::new();
+
+    for member in &self.manifests.members {
+      let mut dep_features: HashMap<String, HashSet<String>> = HashMap::new();
+      for (dep_key, usage) in &member.dependencies {
+        let mut feats: HashSet<String> = usage.unconditional_features.iter().cloned().collect();
+        // If default_features = true (default), add "default"
+        if usage.default_features {
+          feats.insert("default".to_string());
+        }
+        dep_features.insert(dep_key.name.to_string(), feats);
+      }
+      member_declared_features.insert(member.package_name.clone(), dep_features);
+    }
+
+    // Compute the unified features (what will end up in workspace.dependencies)
+    // This is the UNION of all declared features across all members
+    let mut unified_features: HashMap<String, HashSet<String>> = HashMap::new();
+    for dep_features in member_declared_features.values() {
+      for (dep_name, features) in dep_features {
+        unified_features
+          .entry(dep_name.clone())
+          .or_default()
+          .extend(features.iter().cloned());
+      }
+    }
+
+    // Now check: for each member, are there features in unified that it doesn't declare?
+    // These are features "borrowed" from other workspace members
+    for member in &self.manifests.members {
+      for (dep_key, usage) in &member.dependencies {
+        let Some(unified) = unified_features.get(&*dep_key.name) else {
+          continue;
+        };
+
+        // Get declared features from this member's Cargo.toml
+        let mut declared: HashSet<String> = usage.unconditional_features.iter().cloned().collect();
+        if usage.default_features {
+          declared.insert("default".to_string());
+        }
+
+        // Find features that are unified but not declared by this member
+        // These are features this member will lose access to after unification
+        let borrowed: Vec<String> = unified
+          .difference(&declared)
+          .filter(|f| !should_skip_feature(f))
+          .cloned()
+          .collect();
+
+        if !borrowed.is_empty() {
+          undeclared.push(UndeclaredFeature {
+            member: member.package_name.clone(),
+            dep_name: dep_key.name.to_string(),
+            undeclared_features: borrowed,
+            declared_features: declared.into_iter().collect(),
+            resolved_features: unified.iter().cloned().collect(),
+            dep_kind: usage.kind,
+            target: usage.target.clone(),
+          });
+        }
+      }
+    }
+
+    undeclared
+  }
 }