feat: Add unused_optional_dependency lint

Author: Muscraft

src/cargo/core/workspace.rs

@@ -24,7 +24,7 @@ use crate::sources::{PathSource, CRATES_IO_INDEX, CRATES_IO_REGISTRY};
 use crate::util::edit_distance;
 use crate::util::errors::{CargoResult, ManifestError};
 use crate::util::interning::InternedString;
-use crate::util::lints::check_implicit_features;
+use crate::util::lints::{check_implicit_features, unused_dependencies};
 use crate::util::toml::{read_manifest, InheritableFields};
 use crate::util::{context::ConfigRelativePath, Filesystem, GlobalContext, IntoUrl};
 use cargo_util::paths;
@@ -1158,6 +1158,7 @@ impl<'gctx> Workspace<'gctx> {
             .collect();
 
         check_implicit_features(pkg, &path, &normalized_lints, &mut error_count, self.gctx)?;
+        unused_dependencies(pkg, &path, &normalized_lints, &mut error_count, self.gctx)?;
         if error_count > 0 {
             Err(crate::util::errors::AlreadyPrintedError::new(anyhow!(
                 "encountered {error_count} errors(s) while running lints"

src/cargo/util/lints.rs

@@ -236,3 +236,89 @@ pub fn check_implicit_features(
     }
     Ok(())
 }
+
+const UNUSED_OPTIONAL_DEPENDENCY: Lint = Lint {
+    name: "unused_optional_dependency",
+    desc: "unused optional dependency",
+    groups: &[],
+    default_level: LintLevel::Warn,
+    edition_lint_opts: None,
+};
+
+pub fn unused_dependencies(
+    pkg: &Package,
+    path: &Path,
+    lints: &TomlToolLints,
+    error_count: &mut usize,
+    gctx: &GlobalContext,
+) -> CargoResult<()> {
+    let edition = pkg.manifest().edition();
+    // Unused optional dependencies can only exist on edition 2024+
+    if edition <= Edition::Edition2021 {
+        return Ok(());
+    }
+
+    let lint_level = UNUSED_OPTIONAL_DEPENDENCY.level(lints, edition);
+    if lint_level == LintLevel::Allow {
+        return Ok(());
+    }
+
+    let manifest = pkg.manifest();
+    let activated_opt_deps = manifest
+        .resolved_toml()
+        .features()
+        .map(|map| {
+            map.values()
+                .flatten()
+                .filter_map(|f| match FeatureValue::new(InternedString::new(f)) {
+                    Dep { dep_name } => Some(dep_name.as_str()),
+                    _ => None,
+                })
+                .collect::<HashSet<_>>()
+        })
+        .unwrap_or_default();
+
+    let mut emitted_source = None;
+    for dep in manifest.dependencies() {
+        let dep_name_in_toml = dep.name_in_toml();
+        if !dep.is_optional() || activated_opt_deps.contains(dep_name_in_toml.as_str()) {
+            continue;
+        }
+        if lint_level == LintLevel::Forbid || lint_level == LintLevel::Deny {
+            *error_count += 1;
+        }
+        let mut toml_path = vec![dep.kind().kind_table(), dep_name_in_toml.as_str()];
+        let platform = dep.platform().map(|p| p.to_string());
+        if let Some(platform) = platform.as_ref() {
+            toml_path.insert(0, platform);
+            toml_path.insert(0, "target");
+        }
+        let level = lint_level.to_diagnostic_level();
+        let manifest_path = rel_cwd_manifest_path(path, gctx);
+        let mut message = level.title(UNUSED_OPTIONAL_DEPENDENCY.desc).snippet(
+            Snippet::source(manifest.contents())
+                .origin(&manifest_path)
+                .annotation(level.span(get_span(manifest.document(), &toml_path, false).unwrap()))
+                .fold(true),
+        );
+        if emitted_source.is_none() {
+            emitted_source = Some(format!(
+                "`cargo::{}` is set to `{lint_level}`",
+                UNUSED_OPTIONAL_DEPENDENCY.name
+            ));
+            message = message.footer(Level::Note.title(emitted_source.as_ref().unwrap()));
+        }
+        let help = format!(
+            "remove the dependency or activate it in a feature with `dep:{dep_name_in_toml}`"
+        );
+        message = message.footer(Level::Help.title(&help));
+        let renderer = Renderer::styled().term_width(
+            gctx.shell()
+                .err_width()
+                .diagnostic_terminal_width()
+                .unwrap_or(annotate_snippets::renderer::DEFAULT_TERM_WIDTH),
+        );
+        writeln!(gctx.shell().err(), "{}", renderer.render(message))?;
+    }
+    Ok(())
+}

tests/testsuite/lints/implicit_features/edition_2024/mod.rs

@@ -23,15 +23,19 @@ baz = { version = "0.1.0", optional = true }
 
 [features]
 baz = ["dep:baz"]
+
+[lints.cargo]
+unused-optional-dependency = "allow"
 "#,
         )
         .file("src/lib.rs", "")
         .build();
 
     snapbox::cmd::Command::cargo_ui()
-        .masquerade_as_nightly_cargo(&["edition2024"])
+        .masquerade_as_nightly_cargo(&["cargo-lints", "edition2024"])
         .current_dir(p.root())
         .arg("check")
+        .arg("-Zcargo-lints")
         .assert()
         .success()
         .stdout_matches(str![""])

tests/testsuite/lints/mod.rs

@@ -1 +1,2 @@
 mod implicit_features;
+mod unused_optional_dependencies;

tests/testsuite/lints/unused_optional_dependencies/edition_2021/mod.rs

@@ -0,0 +1,37 @@
+use cargo_test_support::prelude::*;
+use cargo_test_support::project;
+use cargo_test_support::registry::Package;
+use cargo_test_support::{file, str};
+
+#[cargo_test]
+fn case() {
+    Package::new("bar", "0.1.0").publish();
+    let p = project()
+        .file(
+            "Cargo.toml",
+            r#"
+[package]
+name = "foo"
+version = "0.1.0"
+edition = "2021"
+
+[dependencies]
+bar = { version = "0.1.0", optional = true }
+
+[lints.cargo]
+implicit-features = "allow"
+"#,
+        )
+        .file("src/lib.rs", "")
+        .build();
+
+    snapbox::cmd::Command::cargo_ui()
+        .masquerade_as_nightly_cargo(&["cargo-lints"])
+        .current_dir(p.root())
+        .arg("check")
+        .arg("-Zcargo-lints")
+        .assert()
+        .success()
+        .stdout_matches(str![""])
+        .stderr_matches(file!["stderr.term.svg"]);
+}

tests/testsuite/lints/unused_optional_dependencies/edition_2021/stderr.term.svg

@@ -0,0 +1,42 @@
+use cargo_test_support::prelude::*;
+use cargo_test_support::registry::Package;
+use cargo_test_support::str;
+use cargo_test_support::{file, project};
+
+#[cargo_test(nightly, reason = "edition2024 is not stable")]
+fn case() {
+    Package::new("bar", "0.1.0").publish();
+    Package::new("baz", "0.1.0").publish();
+    Package::new("target-dep", "0.1.0").publish();
+    let p = project()
+        .file(
+            "Cargo.toml",
+            r#"
+cargo-features = ["edition2024"]
+[package]
+name = "foo"
+version = "0.1.0"
+edition = "2024"
+
+[dependencies]
+bar = { version = "0.1.0", optional = true }
+
+[build-dependencies]
+baz = { version = "0.1.0", optional = true }
+
+[target.'cfg(target_os = "linux")'.dependencies]
+target-dep = { version = "0.1.0", optional = true }
+"#,
+        )
+        .file("src/lib.rs", "")
+        .build();
+
+    snapbox::cmd::Command::cargo_ui()
+        .masquerade_as_nightly_cargo(&["edition2024"])
+        .current_dir(p.root())
+        .arg("check")
+        .assert()
+        .success()
+        .stdout_matches(str![""])
+        .stderr_matches(file!["stderr.term.svg"]);
+}

tests/testsuite/lints/unused_optional_dependencies/edition_2024/mod.rs

@@ -0,0 +1,2 @@
+mod edition_2021;
+mod edition_2024;