feat(lint): lint also workspace dependencies

This has a future performance if we have more lints over dependencies
and version requirements:

* Version requirments in `[workspace.dependencies]` are reparsed.
* cfg key in target-specific dep table for each package manifests
  are reparsed.

Author: weihanglo

src/cargo/core/workspace.rs

@@ -39,6 +39,7 @@ use cargo_util::paths;
 use cargo_util::paths::normalize_path;
 use cargo_util_schemas::manifest;
 use cargo_util_schemas::manifest::RustVersion;
+use cargo_util_schemas::manifest::TomlManifest;
 use cargo_util_schemas::manifest::{TomlDependency, TomlProfiles};
 use pathdiff::diff_paths;
 
@@ -1297,7 +1298,13 @@ impl<'gctx> Workspace<'gctx> {
                 self.gctx,
             )?;
             check_im_a_teapot(pkg, &path, &cargo_lints, &mut error_count, self.gctx)?;
-            implicit_minimum_version_req(pkg, &path, &cargo_lints, &mut error_count, self.gctx)?;
+            implicit_minimum_version_req(
+                pkg.into(),
+                &path,
+                &cargo_lints,
+                &mut error_count,
+                self.gctx,
+            )?;
         }
 
         if error_count > 0 {
@@ -1333,7 +1340,13 @@ impl<'gctx> Workspace<'gctx> {
         .unwrap_or(manifest::TomlToolLints::default());
 
         if self.gctx.cli_unstable().cargo_lints {
-            // Calls to lint functions go in here
+            implicit_minimum_version_req(
+                self.root_maybe().into(),
+                self.root_manifest(),
+                &cargo_lints,
+                &mut error_count,
+                self.gctx,
+            )?;
         }
 
         // This is a short term hack to allow `blanket_hint_mostly_unused`
@@ -1988,6 +2001,13 @@ impl MaybePackage {
             MaybePackage::Virtual(vm) => vm.unstable_features(),
         }
     }
+
+    pub fn normalized_toml(&self) -> &TomlManifest {
+        match self {
+            MaybePackage::Package(p) => p.manifest().normalized_toml(),
+            MaybePackage::Virtual(vm) => vm.normalized_toml(),
+        }
+    }
 }
 
 impl WorkspaceRootConfig {

src/cargo/util/lints/implicit_minimum_version_req.rs

@@ -1,3 +1,4 @@
+use std::borrow::Cow;
 use std::collections::HashMap;
 use std::path::Path;
 
@@ -6,16 +7,16 @@ use annotate_snippets::Level;
 use annotate_snippets::Patch;
 use annotate_snippets::Snippet;
 use cargo_platform::Platform;
+use cargo_util_schemas::manifest::TomlDependency;
 use cargo_util_schemas::manifest::TomlToolLints;
 use toml::de::DeValue;
 
 use crate::CargoResult;
 use crate::GlobalContext;
-use crate::core::Manifest;
-use crate::core::Package;
 use crate::util::OptVersionReq;
 use crate::util::lints::Lint;
 use crate::util::lints::LintLevel;
+use crate::util::lints::ManifestFor;
 use crate::util::lints::get_key_value;
 use crate::util::lints::rel_cwd_manifest_path;
 
@@ -30,13 +31,12 @@ pub const LINT: Lint = Lint {
 };
 
 pub fn implicit_minimum_version_req(
-    pkg: &Package,
+    manifest: ManifestFor<'_>,
     manifest_path: &Path,
     cargo_lints: &TomlToolLints,
     error_count: &mut usize,
     gctx: &GlobalContext,
 ) -> CargoResult<()> {
-    let manifest = pkg.manifest();
     let (lint_level, reason) = LINT.level(
         cargo_lints,
         manifest.edition(),
@@ -52,19 +52,24 @@ pub fn implicit_minimum_version_req(
     let manifest_path = rel_cwd_manifest_path(manifest_path, gctx);
     let target_key_for_platform = target_key_for_platform(&manifest);
 
-    for dep in manifest.dependencies().iter() {
+    for dep in dep_entries(&manifest) {
         let version_req = dep.version_req();
         let Some(cmp) = get_implicit_req(&version_req) else {
             continue;
         };
 
-        let name_in_toml = dep.name_in_toml().as_str();
-        let key_path =
-            if let Some(cfg) = dep.platform().and_then(|p| target_key_for_platform.get(p)) {
-                &["target", &cfg, dep.kind().kind_table(), name_in_toml][..]
-            } else {
-                &[dep.kind().kind_table(), name_in_toml][..]
-            };
+        let name_in_toml = dep.name_in_toml();
+        let key_path = match dep {
+            DepView::Workspace { .. } => &["workspace", "dependencies", name_in_toml][..],
+            DepView::Real(dep) => {
+                let dep_kind = dep.kind().kind_table();
+                if let Some(cfg) = dep.platform().and_then(|p| target_key_for_platform.get(p)) {
+                    &["target", cfg, dep_kind, name_in_toml][..]
+                } else {
+                    &[dep_kind, name_in_toml][..]
+                }
+            }
+        };
 
         let Some((_key, value)) = get_key_value(document, key_path) else {
             continue;
@@ -137,15 +142,84 @@ fn get_implicit_req(req: &OptVersionReq) -> Option<&semver::Comparator> {
 ///
 /// This is only relevant for package dependencies.
 /// Workspace deps don't have target-specific variants, so an empty map is returned.
-fn target_key_for_platform(manifest: &Manifest) -> HashMap<Platform, String> {
-    manifest
-        .normalized_toml()
-        .target
-        .as_ref()
-        .map(|map| {
-            map.keys()
-                .map(|k| (k.parse().expect("already parsed"), k.clone()))
-                .collect()
-        })
-        .unwrap_or_default()
+fn target_key_for_platform(scope: &ManifestFor<'_>) -> HashMap<Platform, String> {
+    match scope {
+        ManifestFor::Package(package) => package
+            .manifest()
+            .normalized_toml()
+            .target
+            .as_ref()
+            .map(|map| {
+                map.keys()
+                    .map(|k| (k.parse().expect("already parsed"), k.clone()))
+                    .collect()
+            })
+            .unwrap_or_default(),
+        ManifestFor::Workspace(_) => Default::default(),
+    }
+}
+
+/// A common view of dependency declarations
+/// for linting both workspace and package dependencies.
+enum DepView<'a> {
+    /// Dependency from `[workspace.dependencies]`
+    Workspace {
+        name: &'a str,
+        dep: &'a TomlDependency,
+    },
+    /// Dependency from package manifest
+    Real(&'a crate::core::Dependency),
+}
+
+impl DepView<'_> {
+    fn name_in_toml(&self) -> &str {
+        match self {
+            DepView::Workspace { name, dep: _ } => name,
+            DepView::Real(dep) => dep.name_in_toml().as_str(),
+        }
+    }
+
+    fn version_req(&self) -> Cow<'_, OptVersionReq> {
+        match self {
+            DepView::Workspace { name: _, dep } => {
+                let opt = match dep {
+                    TomlDependency::Simple(ver) => semver::VersionReq::parse(ver),
+                    TomlDependency::Detailed(detailed) => {
+                        let Some(ver) = detailed.version.as_ref() else {
+                            return Cow::Owned(OptVersionReq::Any);
+                        };
+                        semver::VersionReq::parse(ver)
+                    }
+                }
+                .map(Into::into);
+                Cow::Owned(opt.unwrap_or(OptVersionReq::Any))
+            }
+            DepView::Real(dep) => Cow::Borrowed(dep.version_req()),
+        }
+    }
+}
+
+/// An iterator over dependencies to be linted.
+///
+/// * For package manifest, iterates over package dependencies of all kinds.
+/// * For workspace mainfest, iterates over `[workspace.dependencies]` entries.
+fn dep_entries<'a>(scope: &'a ManifestFor<'_>) -> Box<dyn Iterator<Item = DepView<'a>> + 'a> {
+    match scope {
+        ManifestFor::Package(package) => Box::new(package.dependencies().iter().map(DepView::Real)),
+        ManifestFor::Workspace(maybe_package) => {
+            let toml = maybe_package.normalized_toml();
+            let iter = toml
+                .workspace
+                .as_ref()
+                .and_then(|ws| ws.dependencies.as_ref())
+                .into_iter()
+                .flat_map(|deps| {
+                    deps.iter().map(|(name, dep)| DepView::Workspace {
+                        name: name.as_str(),
+                        dep,
+                    })
+                });
+            Box::new(iter)
+        }
+    }
 }

src/cargo/util/lints/mod.rs

@@ -19,6 +19,56 @@ pub const LINTS: &[Lint] = &[
     UNKNOWN_LINTS,
 ];
 
+/// Scope at which a lint runs: package-level or workspace-level.
+pub enum ManifestFor<'a> {
+    /// Lint runs for a specific package.
+    Package(&'a Package),
+    /// Lint runs for workspace-level config.
+    Workspace(&'a MaybePackage),
+}
+
+impl ManifestFor<'_> {
+    fn edition(&self) -> Edition {
+        match self {
+            ManifestFor::Package(p) => p.manifest().edition(),
+            ManifestFor::Workspace(p) => p.edition(),
+        }
+    }
+
+    fn unstable_features(&self) -> &crate::core::Features {
+        match self {
+            ManifestFor::Package(p) => p.manifest().unstable_features(),
+            ManifestFor::Workspace(p) => p.unstable_features(),
+        }
+    }
+
+    fn document(&self) -> &toml::Spanned<toml::de::DeTable<'static>> {
+        match self {
+            ManifestFor::Package(p) => p.manifest().document(),
+            ManifestFor::Workspace(p) => p.document(),
+        }
+    }
+
+    fn contents(&self) -> &str {
+        match self {
+            ManifestFor::Package(p) => p.manifest().contents(),
+            ManifestFor::Workspace(p) => p.contents(),
+        }
+    }
+}
+
+impl<'a> From<&'a MaybePackage> for ManifestFor<'a> {
+    fn from(value: &'a MaybePackage) -> ManifestFor<'a> {
+        ManifestFor::Workspace(value)
+    }
+}
+
+impl<'a> From<&'a Package> for ManifestFor<'a> {
+    fn from(value: &'a Package) -> ManifestFor<'a> {
+        ManifestFor::Package(value)
+    }
+}
+
 pub fn analyze_cargo_lints_table(
     pkg: &Package,
     path: &Path,

tests/testsuite/lints/implicit_minimum_version_req.rs

@@ -822,6 +822,17 @@ workspace = true
     p.cargo("check -Zcargo-lints")
         .masquerade_as_nightly_cargo(&["cargo-lints"])
         .with_stderr_data(str![[r#"
+[WARNING] dependency version requirement without an explicit minimum version
+ --> Cargo.toml:7:7
+  |
+7 | dep = "1"
+  |       ^^^ missing minor and patch components
+  |
+[HELP] consider specifying a full `major.minor.patch` version requirement
+  |
+7 | dep = "1.0.0"
+  |         ++++
+  = [NOTE] `cargo::implicit_minimum_version_req` is set to `warn` in `[lints]`
 [UPDATING] `dummy-registry` index
 [LOCKING] 1 package to latest compatible version
 [DOWNLOADING] crates ...
@@ -868,6 +879,17 @@ edition = "2021"
     p.cargo("check -Zcargo-lints")
         .masquerade_as_nightly_cargo(&["cargo-lints"])
         .with_stderr_data(str![[r#"
+[WARNING] dependency version requirement without an explicit minimum version
+ --> Cargo.toml:7:7
+  |
+7 | dep = "1"
+  |       ^^^ missing minor and patch components
+  |
+[HELP] consider specifying a full `major.minor.patch` version requirement
+  |
+7 | dep = "1.0.0"
+  |         ++++
+  = [NOTE] `cargo::implicit_minimum_version_req` is set to `warn` in `[lints]`
 [CHECKING] member v0.0.0 ([ROOT]/foo/member)
 [FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s
 
@@ -915,6 +937,17 @@ workspace = true
     p.cargo("check -Zcargo-lints")
         .masquerade_as_nightly_cargo(&["cargo-lints"])
         .with_stderr_data(str![[r#"
+[WARNING] dependency version requirement without an explicit minimum version
+ --> Cargo.toml:7:7
+  |
+7 | dep = "1"
+  |       ^^^ missing minor and patch components
+  |
+[HELP] consider specifying a full `major.minor.patch` version requirement
+  |
+7 | dep = "1.0.0"
+  |         ++++
+  = [NOTE] `cargo::implicit_minimum_version_req` is set to `warn` in `[lints]`
 [WARNING] dependency version requirement without an explicit minimum version
  --> member/Cargo.toml:7:7
   |