cargo-rail: adding 'unused dep' detection edge case handling; auto_remove functionality. Testing across real repos (vello, etc.)

Author: loadingalias

src/cargo/manifest_analyzer.rs

@@ -114,6 +114,10 @@ pub struct DepUsage {
   /// The key name used in Cargo.toml (alias if renamed, otherwise package name)
   /// Used when generating manifest edits to target the correct dependency entry
   pub cargo_toml_key: String,
+  /// Whether this optional dep is referenced in the `[features]` table
+  /// True if the dep appears as: `dep:name`, `name` (for optional deps), or `name/feat`
+  /// Used to distinguish truly unused optional deps from feature-gated ones
+  pub referenced_in_features: bool,
 }
 
 /// Parsed dependency table info (used internally during manifest parsing)
@@ -294,17 +298,42 @@ impl ManifestAnalyzer {
       }
     }
 
-    // Parse [features] table to find conditional feature references
+    // Parse [features] table to find conditional feature references and dep activations
+    // This detects three patterns that reference dependencies:
+    // 1. "dep:name" - explicit dep activation (Rust 2021+)
+    // 2. "name" - implicit optional dep activation (when name matches an optional dep)
+    // 3. "name/feat" - dep with specific feature enabled
     if let Some(features_table) = doc.get("features").and_then(|f| f.as_table()) {
       for (_feature_name, feature_value) in features_table {
         if let Some(feature_list) = feature_value.as_array() {
           for item in feature_list {
             if let Some(s) = item.as_str() {
-              // Check for dep/feature syntax
-              if let Some((dep, feat)) = s.split_once('/') {
-                let dep_key = DepKey::new(dep);
+              // Pattern 1: "dep:name" - explicit dep reference (Rust 2021+)
+              if let Some(dep_name) = s.strip_prefix("dep:") {
+                let dep_key = DepKey::new(dep_name);
+                if let Some(usage) = dependencies.get_mut(&dep_key) {
+                  usage.referenced_in_features = true;
+                }
+              }
+              // Pattern 2: "name/feat" - dep with feature
+              else if let Some((dep, feat)) = s.split_once('/') {
+                // Strip optional "dep:" prefix from the dep part
+                let dep_name = dep.strip_prefix("dep:").unwrap_or(dep);
+                let dep_key = DepKey::new(dep_name);
                 if let Some(usage) = dependencies.get_mut(&dep_key) {
                   usage.conditional_features.insert(feat.to_string());
+                  usage.referenced_in_features = true;
+                }
+              }
+              // Pattern 3: bare "name" - check if it matches an optional dep
+              else {
+                let dep_key = DepKey::new(s);
+                if let Some(usage) = dependencies.get_mut(&dep_key) {
+                  // Only count as referenced if the dep is optional
+                  // (non-optional deps with same name as features are already resolved)
+                  if usage.optional {
+                    usage.referenced_in_features = true;
+                  }
                 }
               }
             }
@@ -364,7 +393,7 @@ impl ManifestAnalyzer {
         // which is the alias if renamed, or the package name otherwise
         let usage = DepUsage {
           unconditional_features: p.unconditional_features,
-          conditional_features: BTreeSet::new(), // Filled in later
+          conditional_features: BTreeSet::new(), // Filled in later by features parsing
           default_features: p.default_features,
           kind,
           target: target.clone(),
@@ -374,6 +403,7 @@ impl ManifestAnalyzer {
           declared_version: p.declared_version,
           manifest_path: Some(manifest_path.to_path_buf()),
           cargo_toml_key: dep_name.to_string(),
+          referenced_in_features: false, // Filled in later by features parsing
         };
 
         out.insert(dep_key, usage);

src/cargo/manifest_ops.rs

@@ -385,12 +385,40 @@ pub fn insert_target_dependency(
   Ok(())
 }
 
+/// Remove a dependency from target-specific section
+///
+/// # Arguments
+///
+/// * `doc` - TOML document to modify
+/// * `target` - Target triple or cfg expression (e.g., "cfg(windows)")
+/// * `section` - Section name ("dependencies", "dev-dependencies", "build-dependencies")
+/// * `name` - Dependency name to remove
+pub fn remove_target_dependency(doc: &mut DocumentMut, target: &str, section: &str, name: &str) -> RailResult<()> {
+  let path = format!("target.{}.{}", target, section);
+  if let Some(target_section) = get_table_mut(doc, &path) {
+    target_section.remove(name);
+  }
+  Ok(())
+}
+
 /// Get target-specific dependencies section (mutable)
 fn get_target_section_mut<'a>(doc: &'a mut DocumentMut, target: &str, section: &str) -> RailResult<&'a mut Table> {
   let path = format!("target.{}.{}", target, section);
   get_or_create_table(doc, &path)
 }
 
+/// Get a mutable reference to a table by path (returns None if not found)
+fn get_table_mut<'a>(doc: &'a mut DocumentMut, path: &str) -> Option<&'a mut Table> {
+  let parts: Vec<&str> = path.split('.').collect();
+  let mut current: &mut Item = doc.as_item_mut();
+
+  for part in parts {
+    current = current.get_mut(part)?;
+  }
+
+  current.as_table_mut()
+}
+
 // ============================================================================
 // SECTION 5: Feature Array Operations
 // ============================================================================

src/cargo/manifest_writer.rs

@@ -194,4 +194,44 @@ impl ManifestWriter {
 
     Ok(())
   }
+
+  /// Remove an unused dependency from a member's Cargo.toml
+  ///
+  /// # Arguments
+  ///
+  /// * `member_toml_path` - Path to the member's Cargo.toml
+  /// * `dep_name` - Name of the dependency to remove
+  /// * `dep_kind` - Type of dependency (Normal, Dev, Build)
+  /// * `target` - Optional target platform constraint (e.g., "cfg(unix)")
+  pub fn remove_dep(
+    &self,
+    member_toml_path: &Path,
+    dep_name: &str,
+    dep_kind: DepKind,
+    target: Option<&str>,
+  ) -> 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
+    if let Some(target_cfg) = target {
+      // Target-specific: remove from [target.'cfg(...)'.dependencies]
+      manifest_ops::remove_target_dependency(&mut doc, target_cfg, kind_section, dep_name)
+        .context("Failed to remove target-specific dependency")?;
+    } else {
+      // Regular section: remove from [dependencies], [dev-dependencies], or [build-dependencies]
+      if let Some(deps) = doc.get_mut(kind_section).and_then(|d| d.as_table_like_mut()) {
+        deps.remove(dep_name);
+      }
+    }
+
+    // Format and write
+    self.formatter.format_manifest(&mut doc)?;
+    manifest_ops::write_toml_file(member_toml_path, &doc)?;
+
+    Ok(())
+  }
 }