loadingalias
diff --git a/‎README.md‎
Lines changed: 2 additions & 0 deletions b/‎README.md‎
Lines changed: 2 additions & 0 deletions
diff --git a/‎docs/config.md‎
Lines changed: 1 addition & 1 deletion b/‎docs/config.md‎
Lines changed: 1 addition & 1 deletion
diff --git a/‎src/cargo/multi_target_metadata.rs‎
Lines changed: 8 additions & 7 deletions b/‎src/cargo/multi_target_metadata.rs‎
Lines changed: 8 additions & 7 deletions
diff --git a/‎src/cargo/unify/unused_finder.rs‎
Lines changed: 185 additions & 23 deletions b/‎src/cargo/unify/unused_finder.rs‎
Lines changed: 185 additions & 23 deletions
diff --git a/‎src/cargo/unify_analyzer.rs‎
Lines changed: 9 additions & 12 deletions b/‎src/cargo/unify_analyzer.rs‎
Lines changed: 9 additions & 12 deletions
diff --git a/‎src/cargo/unify_report.rs‎
Lines changed: 1 addition & 0 deletions b/‎src/cargo/unify_report.rs‎
Lines changed: 1 addition & 0 deletions
@@ -93,6 +93,8 @@ cargo rail unify --explain  # understand each decision
 - **Replaces workspace-hack** — enable `pin_transitives` for cargo-hakari equivalent
 - **Configurable** — tune behavior in `rail.toml` (unused removal, feature pruning, sorting, and more).
 
+Unused detection combines resolved-graph analysis with rustc diagnostics (`unused_crate_dependencies`) so deps that are resolved but never referenced are also removed. Optional deps and unconfigured target-gated deps are conservatively skipped.
+
 **Validated impact on real repos:**
 
 | Repository | Crates | Deps Unified | Undeclared Features | MSRV Computed |
 
@@ -106,7 +106,7 @@ Controls workspace dependency unification behavior. All options are optional wit
 | `msrv` | `bool` | `true` | Compute and write MSRV to `[workspace.package].rust-version` (written as `major.minor.patch`). The MSRV is determined by `msrv_source`. |
 | `enforce_msrv_inheritance` | `bool` | `false` | Ensure every workspace member inherits MSRV by setting `[package].rust-version = { workspace = true }` in each member's `Cargo.toml`. This makes `[workspace.package].rust-version` actually apply across the workspace. |
 | `msrv_source` | `enum` | `"max"` | How to compute the final MSRV:<br>• `"deps"` - Use maximum from dependencies only (original behavior)<br>• `"workspace"` - Preserve existing rust-version, warn if deps need higher<br>• `"max"` - Take max(workspace, deps) - your explicit setting wins if higher |
-| `detect_unused` | `bool` | `true` | Detect dependencies declared in manifests but absent from the resolved cargo graph. |
+| `detect_unused` | `bool` | `true` | Detect unused dependencies using two signals: (1) declared deps absent from the resolved cargo graph, and (2) rustc `unused_crate_dependencies` diagnostics for deps that resolve but are never referenced in source. Optional deps and deps behind unconfigured target constraints are conservatively skipped. |
 | `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. |
 
@@ -378,13 +378,14 @@ impl MultiTargetMetadata {
         // that aren't in the current Cargo.lock, breaking resolution.
         // The intersection approach is safe - it only pins features that
         // are already enabled everywhere, avoiding new dep introduction.
-        let common_features: HashSet<String> = features
-          .values()
-          .fold(None, |acc: Option<HashSet<String>>, set| match acc {
-            None => Some(set.clone()),
-            Some(existing) => Some(existing.intersection(set).cloned().collect()),
-          })
-          .unwrap_or_default();
+        let mut feature_sets = features.values();
+        let Some(first_set) = feature_sets.next() else {
+          continue;
+        };
+        let mut common_features = first_set.clone();
+        for set in feature_sets {
+          common_features.retain(|feature| set.contains(feature));
+        }
 
         // Get the resolved version (use highest across all targets)
         let versions = self.all_versions(dep_name);
 
@@ -1,25 +1,34 @@
 //! Unused dependency detection
 //!
-//! Compares declared dependencies (from Cargo.toml) against the resolved
-//! cargo graph to find deps that are declared but never actually used.
+//! Combines graph-level checks with rustc's source-level diagnostics.
 
 use crate::cargo::manifest_analyzer::ManifestAnalyzer;
+use crate::cargo::manifest_analyzer::{DepKind, DepUsage};
 use crate::cargo::multi_target_metadata::MultiTargetMetadata;
 use crate::cargo::unify_types::{MemberEdit, UnusedDep, UnusedReason};
+use crate::error::ResultExt;
 use crate::progress;
+use serde::Deserialize;
 use std::collections::{HashMap, HashSet};
+use std::path::Path;
+use std::process::Command;
 use std::sync::Arc;
 
 /// Detects unused dependencies in workspace members
 pub struct UnusedDepFinder<'a> {
+  workspace_root: &'a Path,
   metadata: &'a MultiTargetMetadata,
   manifests: &'a ManifestAnalyzer,
 }
 
 impl<'a> UnusedDepFinder<'a> {
   /// Create a new unused dependency finder
-  pub fn new(metadata: &'a MultiTargetMetadata, manifests: &'a ManifestAnalyzer) -> Self {
-    Self { metadata, manifests }
+  pub fn new(workspace_root: &'a Path, metadata: &'a MultiTargetMetadata, manifests: &'a ManifestAnalyzer) -> Self {
+    Self {
+      workspace_root,
+      metadata,
+      manifests,
+    }
   }
 
   /// Detect unused dependencies in workspace members
@@ -31,6 +40,7 @@ impl<'a> UnusedDepFinder<'a> {
   /// - Only truly unreferenced deps are flagged
   pub fn find(&self) -> Vec<UnusedDep> {
     let mut unused = Vec::new();
+    let source_unused = self.detect_source_unused_deps();
 
     // Pre-compute workspace member names (these are never "unused")
     let workspace_member_names: HashSet<String> = self
@@ -77,33 +87,38 @@ impl<'a> UnusedDepFinder<'a> {
             .unwrap_or_else(|| dep_key.name.replace('-', "_"))
         };
         if resolved_deps.contains(&resolved_name) {
-          continue; // Dep is resolved, definitely used
+          // Source-level detection catches "declared + resolved but never referenced".
+          // This solves the common single-crate case where graph-only checks miss dead deps.
+          for usage in usages {
+            if self.should_skip_usage(usage, &configured_targets) {
+              continue;
+            }
+            if usage.kind != DepKind::Normal {
+              continue;
+            }
+            let Some(member_unused) = source_unused.get(&member.package_name) else {
+              continue;
+            };
+            if !member_unused.contains(&resolved_name) {
+              continue;
+            }
+            unused.push(UnusedDep {
+              member: Arc::from(member.package_name.as_str()),
+              dep_name: Arc::clone(&dep_key.name),
+              kind: usage.kind,
+              reason: UnusedReason::NotUsedInSource,
+            });
+          }
+          continue;
         }
 
         // Check each usage of this dep (can appear in multiple sections)
         for usage in usages {
-          // === Smart filtering to avoid false positives ===
-
-          // Filter 1: Optional deps are ALWAYS feature-gated
-          // Cargo automatically creates an implicit feature for each optional dependency,
-          // so code can use `#[cfg(feature = "dep_name")]` even without explicit [features] entries.
-          // We cannot safely determine if an optional dep is "unused" without analyzing source code
-          // for cfg attributes, so we conservatively skip all optional deps.
-          if usage.optional {
+          if self.should_skip_usage(usage, &configured_targets) {
             continue;
           }
 
-          // Filter 2: Target-specific deps for unconfigured targets
-          // If a dep has a target constraint (e.g., cfg(windows)) and we don't have
-          // that target configured, we can't verify if it's used or not.
           if let Some(target_cfg) = &usage.target {
-            if !target_constraint_matches_any(target_cfg, &configured_targets) {
-              // Target not configured - can't verify, assume it's valid
-              continue;
-            }
-
-            // Target IS configured but dep still not in resolved graph
-            // This is genuinely suspicious - flag it with context
             unused.push(UnusedDep {
               member: Arc::from(member.package_name.as_str()),
               dep_name: Arc::clone(&dep_key.name),
@@ -134,6 +149,47 @@ impl<'a> UnusedDepFinder<'a> {
     unused
   }
 
+  /// Conservative skip rules to avoid false positives.
+  fn should_skip_usage(&self, usage: &DepUsage, configured_targets: &[&str]) -> bool {
+    // Optional deps may be used under cfg(feature = "...") without explicit references.
+    if usage.optional {
+      return true;
+    }
+
+    // If target isn't configured, we cannot verify usage accurately.
+    if let Some(target_cfg) = &usage.target {
+      return !target_constraint_matches_any(target_cfg, configured_targets);
+    }
+
+    false
+  }
+
+  /// Detect source-unused crates via rustc's `unused_crate_dependencies` lint.
+  ///
+  /// This is the only reliable source-level signal for dependencies that are
+  /// declared/resolved but never referenced in Rust code.
+  fn detect_source_unused_deps(&self) -> HashMap<String, HashSet<String>> {
+    if !has_source_check_candidates(&self.manifests) {
+      return HashMap::new();
+    }
+
+    let manifest_to_member = build_manifest_member_index(&self.manifests.members);
+    if manifest_to_member.is_empty() {
+      return HashMap::new();
+    }
+
+    match run_unused_crate_dependency_check(self.workspace_root, &manifest_to_member) {
+      Ok(map) => map,
+      Err(error) => {
+        crate::warn!(
+          "source-level unused dependency detection failed; falling back to graph-only detection: {}",
+          error
+        );
+        HashMap::new()
+      }
+    }
+  }
+
   /// Generate removal edits for unused dependencies
   pub fn generate_removal_edits(&self, unused: &[UnusedDep]) -> HashMap<String, Vec<MemberEdit>> {
     let mut edits: HashMap<String, Vec<MemberEdit>> = HashMap::new();
@@ -202,6 +258,112 @@ impl<'a> UnusedDepFinder<'a> {
   }
 }
 
+fn build_manifest_member_index(members: &[crate::cargo::manifest_analyzer::ParsedManifest]) -> HashMap<String, String> {
+  let mut index = HashMap::with_capacity(members.len() * 2);
+  for member in members {
+    index.insert(member.path.to_string_lossy().into_owned(), member.package_name.clone());
+    if let Ok(canonical) = member.path.canonicalize() {
+      index.insert(canonical.to_string_lossy().into_owned(), member.package_name.clone());
+    }
+  }
+  index
+}
+
+fn has_source_check_candidates(manifests: &ManifestAnalyzer) -> bool {
+  manifests.members.iter().any(|member| {
+    member
+      .dependencies
+      .values()
+      .flatten()
+      .any(|usage| usage.kind == DepKind::Normal && !usage.optional && usage.target.is_none())
+  })
+}
+
+fn run_unused_crate_dependency_check(
+  workspace_root: &Path,
+  manifest_to_member: &HashMap<String, String>,
+) -> crate::error::RailResult<HashMap<String, HashSet<String>>> {
+  let rustflags = std::env::var("RUSTFLAGS").ok();
+  let lint_flag = "-Wunused-crate-dependencies";
+  let merged_rustflags = match rustflags {
+    Some(flags) if flags.split_whitespace().any(|flag| flag == lint_flag) => flags,
+    Some(flags) => format!("{} {}", flags, lint_flag),
+    None => lint_flag.to_string(),
+  };
+
+  let output = Command::new("cargo")
+    .current_dir(workspace_root)
+    .env("RUSTFLAGS", merged_rustflags)
+    .args([
+      "check",
+      "--workspace",
+      "--all-targets",
+      "--all-features",
+      "--message-format=json",
+    ])
+    .output()
+    .with_context(|| format!("running cargo check in {}", workspace_root.display()))?;
+
+  let mut by_member: HashMap<String, HashSet<String>> = HashMap::new();
+  for line in String::from_utf8_lossy(&output.stdout).lines() {
+    let Ok(message) = serde_json::from_str::<CargoCompilerMessage>(line) else {
+      continue;
+    };
+    if message.reason != "compiler-message" {
+      continue;
+    }
+    if message.message.code.as_ref().and_then(|c| c.code.as_deref()) != Some("unused_crate_dependencies") {
+      continue;
+    }
+    let Some(manifest_path) = message.manifest_path.as_deref() else {
+      continue;
+    };
+    let Some(member_name) = resolve_member_name(manifest_path, manifest_to_member) else {
+      continue;
+    };
+    let Some(crate_name) = parse_unused_crate_name(&message.message.message) else {
+      continue;
+    };
+
+    by_member
+      .entry(member_name.to_string())
+      .or_default()
+      .insert(crate_name.replace('-', "_"));
+  }
+
+  Ok(by_member)
+}
+
+fn resolve_member_name<'a>(manifest_path: &str, manifest_to_member: &'a HashMap<String, String>) -> Option<&'a str> {
+  manifest_to_member.get(manifest_path).map(String::as_str)
+}
+
+fn parse_unused_crate_name(message: &str) -> Option<&str> {
+  let prefix = "extern crate `";
+  let start = message.find(prefix)? + prefix.len();
+  let rest = &message[start..];
+  let end = rest.find('`')?;
+  Some(&rest[..end])
+}
+
+#[derive(Debug, Deserialize)]
+struct CargoCompilerMessage {
+  reason: String,
+  manifest_path: Option<String>,
+  message: CargoDiagnostic,
+}
+
+#[derive(Debug, Deserialize)]
+struct CargoDiagnostic {
+  message: String,
+  code: Option<CargoDiagnosticCode>,
+}
+
+#[derive(Debug, Deserialize)]
+struct CargoDiagnosticCode {
+  code: Option<String>,
+}
+
 /// Check if a target constraint (cfg expression) matches any configured target
 ///
 /// This is a heuristic check - we look for common patterns in the cfg string
 
@@ -37,6 +37,8 @@ pub struct UnifyAnalyzer {
   cohort_issues: Vec<UnifyIssue>,
   /// Workspace root path (for path normalization)
   workspace_root: PathBuf,
+  /// Canonical workspace root path (computed once)
+  canonical_workspace_root: PathBuf,
 }
 
 type FeatureSources = FxHashMap<String, FxHashMap<String, FxHashSet<String>>>;
@@ -64,14 +66,17 @@ impl UnifyAnalyzer {
       .collect();
     let (config, cohort_issues) =
       Self::apply_workspace_member_cohort_policy(base_config, &manifests, &workspace_member_names);
+    let workspace_root = ctx.workspace_root().to_path_buf();
+    let canonical_workspace_root = workspace_root.canonicalize().unwrap_or_else(|_| workspace_root.clone());
 
     Ok(Self {
       metadata,
       manifests,
       config,
       existing_workspace_deps,
       cohort_issues,
-      workspace_root: ctx.workspace_root().to_path_buf(),
+      workspace_root,
+      canonical_workspace_root,
     })
   }
 
@@ -239,14 +244,10 @@ impl UnifyAnalyzer {
     let absolute_dep_path = member_dir.join(dep_path);
 
     // Canonicalize to resolve .. and symlinks (if path exists)
-    let canonical_workspace = self
-      .workspace_root
-      .canonicalize()
-      .unwrap_or_else(|_| self.workspace_root.clone());
     let canonical_dep = absolute_dep_path.canonicalize().unwrap_or(absolute_dep_path.clone());
 
     // Make relative to workspace root
-    if let Ok(relative) = canonical_dep.strip_prefix(&canonical_workspace) {
+    if let Ok(relative) = canonical_dep.strip_prefix(&self.canonical_workspace_root) {
       return relative.to_path_buf();
     }
 
@@ -263,13 +264,9 @@ impl UnifyAnalyzer {
   fn normalize_workspace_member_path(&self, member_manifest_path: &Path) -> PathBuf {
     let member_dir = member_manifest_path.parent().unwrap_or(member_manifest_path);
 
-    let canonical_workspace = self
-      .workspace_root
-      .canonicalize()
-      .unwrap_or_else(|_| self.workspace_root.clone());
     let canonical_member = member_dir.canonicalize().unwrap_or_else(|_| member_dir.to_path_buf());
 
-    if let Ok(relative) = canonical_member.strip_prefix(&canonical_workspace) {
+    if let Ok(relative) = canonical_member.strip_prefix(&self.canonical_workspace_root) {
       return relative.to_path_buf();
     }
 
@@ -698,7 +695,7 @@ impl UnifyAnalyzer {
     };
 
     // Detect unused dependencies
-    let unused_finder = UnusedDepFinder::new(&self.metadata, &self.manifests);
+    let unused_finder = UnusedDepFinder::new(&self.workspace_root, &self.metadata, &self.manifests);
     let unused_deps = if self.config.detect_unused {
       progress!("Detecting unused dependencies...");
       unused_finder.find()
 
@@ -140,6 +140,7 @@ impl UnifyReport {
           DepKind::Build => "build",
         };
         let reason_str = match &ud.reason {
+          UnusedReason::NotUsedInSource => "unused in source".to_string(),
           UnusedReason::NotInResolvedGraph => "not in resolved graph".to_string(),
           UnusedReason::TargetConfiguredButNotResolved { target_cfg } => {
             format!("target `{}` configured but not resolved", target_cfg)