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

@@ -6,6 +6,7 @@ use annotate_snippets::{Level, Renderer, Snippet};
 use cargo_util_schemas::manifest::{TomlLintLevel, TomlToolLints};
 use pathdiff::diff_paths;
 use std::collections::HashSet;
+use std::fmt::Display;
 use std::ops::Range;
 use std::path::Path;
 use toml_edit::ImDocument;
@@ -107,6 +108,17 @@ pub enum LintLevel {
     Forbid,
 }
 
+impl Display for LintLevel {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            LintLevel::Allow => write!(f, "allow"),
+            LintLevel::Warn => write!(f, "warn"),
+            LintLevel::Deny => write!(f, "deny"),
+            LintLevel::Forbid => write!(f, "forbid"),
+        }
+    }
+}
+
 impl LintLevel {
     pub fn to_diagnostic_level(self) -> Level {
         match self {
@@ -215,3 +227,98 @@ 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();
+    // This lint is only relevant for editions 2024 and later.
+    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 user_defined_features = manifest.resolved_toml().features();
+    let features = user_defined_features.map_or(HashSet::new(), |f| {
+        f.keys().map(|k| InternedString::new(&k)).collect()
+    });
+    // Add implicit features for optional dependencies if they weren't
+    // explicitly listed anywhere.
+    let explicitly_listed = user_defined_features.map_or(HashSet::new(), |f| {
+        f.values()
+            .flatten()
+            .filter_map(|v| match FeatureValue::new(v.into()) {
+                Dep { dep_name } => Some(dep_name),
+                _ => None,
+            })
+            .collect()
+    });
+
+    let mut emitted_source = None;
+    for dep in manifest.dependencies() {
+        let dep_name_in_toml = dep.name_in_toml();
+        if !dep.is_optional()
+            || features.contains(&dep_name_in_toml)
+            || explicitly_listed.contains(&dep_name_in_toml)
+        {
+            continue;
+        }
+        if lint_level == LintLevel::Forbid || lint_level == LintLevel::Deny {
+            *error_count += 1;
+        }
+        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(),
+                            &["dependencies", &dep_name_in_toml],
+                            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,39 @@
+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();
+    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 }
+baz = { version = "0.1.0", optional = true }
+
+[features]
+baz = ["dep:baz"]
+"#,
+        )
+        .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;