Lint against some unexpected target cfgs

with the help of the Cargo lints infra

Author: Urgau

src/cargo/core/workspace.rs

@@ -25,7 +25,7 @@ use crate::util::context::FeatureUnification;
 use crate::util::edit_distance;
 use crate::util::errors::{CargoResult, ManifestError};
 use crate::util::interning::InternedString;
-use crate::util::lints::{analyze_cargo_lints_table, check_im_a_teapot};
+use crate::util::lints::{analyze_cargo_lints_table, check_im_a_teapot, unexpected_target_cfgs};
 use crate::util::toml::{read_manifest, InheritableFields};
 use crate::util::{
     context::CargoResolverConfig, context::ConfigRelativePath, context::IncompatibleRustVersions,
@@ -1273,6 +1273,7 @@ impl<'gctx> Workspace<'gctx> {
             self.gctx,
         )?;
         check_im_a_teapot(pkg, &path, &cargo_lints, &mut error_count, self.gctx)?;
+        unexpected_target_cfgs(self, pkg, &path, &cargo_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

@@ -1,15 +1,18 @@
-use crate::core::{Edition, Feature, Features, Manifest, Package};
+use crate::core::compiler::{CompileKind, TargetInfo};
+use crate::core::{Edition, Feature, Features, Manifest, Package, Workspace};
 use crate::{CargoResult, GlobalContext};
 use annotate_snippets::{Level, Snippet};
+use cargo_platform::{Cfg, ExpectedValues, Platform};
 use cargo_util_schemas::manifest::{TomlLintLevel, TomlToolLints};
 use pathdiff::diff_paths;
+use std::borrow::Cow;
 use std::fmt::Display;
 use std::ops::Range;
 use std::path::Path;
 use toml_edit::ImDocument;
 
 const LINT_GROUPS: &[LintGroup] = &[TEST_DUMMY_UNSTABLE];
-pub const LINTS: &[Lint] = &[IM_A_TEAPOT, UNKNOWN_LINTS];
+pub const LINTS: &[Lint] = &[IM_A_TEAPOT, UNEXPECTED_CFGS, UNKNOWN_LINTS];
 
 pub fn analyze_cargo_lints_table(
     pkg: &Package,
@@ -605,6 +608,164 @@ fn output_unknown_lints(
     Ok(())
 }
 
+const UNEXPECTED_CFGS: Lint = Lint {
+    name: "unexpected_cfgs",
+    desc: "lint on unexpected target cfgs",
+    groups: &[],
+    default_level: LintLevel::Warn,
+    edition_lint_opts: None,
+    feature_gate: None,
+    docs: Some(
+        r#"
+### What it does
+Checks for unexpected cfgs in `[target.'cfg(...)']`
+
+### Why it is bad
+The lint helps with verifying that the crate is correctly handling conditional
+compilation for different target platforms. It ensures that the cfg settings are
+consistent between what is intended and what is used, helping to
+catch potential bugs or errors early in the development process.
+
+### Example
+```toml
+[lints.cargo]
+unexpected_cfgs = "warn"
+```
+"#,
+    ),
+};
+
+pub fn unexpected_target_cfgs(
+    ws: &Workspace<'_>,
+    pkg: &Package,
+    path: &Path,
+    pkg_lints: &TomlToolLints,
+    error_count: &mut usize,
+    gctx: &GlobalContext,
+) -> CargoResult<()> {
+    let manifest = pkg.manifest();
+
+    let (lint_level, _lint_reason) =
+        UNEXPECTED_CFGS.level(pkg_lints, manifest.edition(), manifest.unstable_features());
+
+    if lint_level == LintLevel::Allow {
+        return Ok(());
+    }
+
+    let rustc = gctx.load_global_rustc(Some(ws))?;
+    // FIXME: While it doesn't doesn't really matter for `--print=check-cfg`, we should
+    // still pass the actual requested targets instead of an empty array so that the
+    // target info can always be de-duplicated.
+    // FIXME: Move the target info creation before any linting is done and re-use it for
+    // all the packages.
+    let compile_kinds = CompileKind::from_requested_targets(gctx, &[])?;
+    let target_info = TargetInfo::new(gctx, &compile_kinds, &rustc, CompileKind::Host)?;
+
+    let Some(global_check_cfg) = target_info.check_cfg() else {
+        return Ok(());
+    };
+
+    if !global_check_cfg.exhaustive {
+        return Ok(());
+    }
+
+    // FIXME: If the `[lints.rust.unexpected_cfgs.check-cfg]` config is set we should
+    // re-fetch the check-cfg informations with those extra args
+
+    for dep in pkg.summary().dependencies() {
+        let Some(platform) = dep.platform() else {
+            continue;
+        };
+        let Platform::Cfg(cfg_expr) = platform else {
+            continue;
+        };
+
+        cfg_expr.walk(|cfg| -> CargoResult<()> {
+            let (name, value) = match cfg {
+                Cfg::Name(name) => (name, None),
+                Cfg::KeyPair(name, value) => (name, Some(value.to_string())),
+            };
+
+            match global_check_cfg.expecteds.get(name.as_str()) {
+                Some(ExpectedValues::Some(values)) if !values.contains(&value) => {
+                    let level = lint_level.to_diagnostic_level();
+                    if lint_level == LintLevel::Forbid || lint_level == LintLevel::Deny {
+                        *error_count += 1;
+                    }
+
+                    let value = match value {
+                        Some(value) => Cow::from(format!("`{value}`")),
+                        None => Cow::from("(none)"),
+                    };
+
+                    // Retrieving the span can fail if our pretty-priting doesn't match what the
+                    // user wrote: `unix="foo"` and `unix = "foo"`, for that reason we don't fail
+                    // and just produce a slightly worth diagnostic.
+                    if let Some(span) = get_span(manifest.document(), &["target", &*format!("cfg({cfg_expr})")], false) {
+                        let manifest_path = rel_cwd_manifest_path(path, gctx);
+                        let title = format!(
+                            "unexpected `cfg` condition value: {value} for `{cfg}`"
+                        );
+                        let diag = level.title(&*title).snippet(
+                            Snippet::source(manifest.contents())
+                                .origin(&manifest_path)
+                                .annotation(level.span(span))
+                                .fold(true)
+                        );
+                        gctx.shell().print_message(diag)?;
+                    } else {
+                        let title = format!(
+                            "unexpected `cfg` condition value: {value} for `{cfg}` in `[target.'cfg({cfg_expr})']`"
+                        );
+                        let help_where = format!("occurred in `{path}`", path = path.display());
+                        let diag = level.title(&*title).footer(Level::Help.title(&*help_where));
+                        gctx.shell().print_message(diag)?;
+                    }
+                }
+                None => {
+                    let level = lint_level.to_diagnostic_level();
+                    if lint_level == LintLevel::Forbid || lint_level == LintLevel::Deny {
+                        *error_count += 1;
+                    }
+
+                    let for_cfg = match value {
+                        Some(_value) => Cow::from(format!(" for `{cfg}`")),
+                        None => Cow::from(""),
+                    };
+
+                    // Retrieving the span can fail if our pretty-priting doesn't match what the
+                    // user wrote: `unix="foo"` and `unix = "foo"`, for that reason we don't fail
+                    // and just produce a slightly worth diagnostic.
+                    if let Some(span) = get_span(manifest.document(), &["target", &*format!("cfg({cfg_expr})")], false) {
+                        let manifest_path = rel_cwd_manifest_path(path, gctx);
+                        let title = format!(
+                            "unexpected `cfg` condition name: {name}{for_cfg}"
+                        );
+                        let diag = level.title(&*title).snippet(
+                            Snippet::source(manifest.contents())
+                                .origin(&manifest_path)
+                                .annotation(level.span(span))
+                                .fold(true)
+                        );
+                        gctx.shell().print_message(diag)?;
+                    } else {
+                        let title = format!(
+                            "unexpected `cfg` condition name: {name}{for_cfg} in `[target.'cfg({cfg_expr})']`"
+                        );
+                        let help_where = format!("occurred in `{path}`", path = path.display());
+                        let diag = level.title(&*title).footer(Level::Help.title(&*help_where));
+                        gctx.shell().print_message(diag)?;
+                    }
+                }
+                _ => { /* not unexpected */ }
+            }
+            Ok(())
+        })?;
+    }
+
+    Ok(())
+}
+
 #[cfg(test)]
 mod tests {
     use itertools::Itertools;

src/doc/src/reference/lints.md

@@ -5,8 +5,28 @@ Note: [Cargo's linting system is unstable](unstable.md#lintscargo) and can only
 ## Warn-by-default
 
 These lints are all set to the 'warn' level by default.
+- [`unexpected_cfgs`](#unexpected_cfgs)
 - [`unknown_lints`](#unknown_lints)
 
+## `unexpected_cfgs`
+Set to `warn` by default
+
+### What it does
+Checks for unexpected cfgs in `[target.'cfg(...)']`
+
+### Why it is bad
+The lint helps with verifying that the crate is correctly handling conditional
+compilation for different target platforms. It ensures that the cfg settings are
+consistent between what is intended and what is used, helping to
+catch potential bugs or errors early in the development process.
+
+### Example
+```toml
+[lints.cargo]
+unexpected_cfgs = "warn"
+```
+
+
 ## `unknown_lints`
 Set to `warn` by default
 

src/doc/src/reference/unstable.md

@@ -1938,7 +1938,7 @@ This feature checks for unexpected cfgs in `[target.'cfg(...)']` entries, based
 on `rustc --print=check-cfg`.
 
 ```sh
-cargo check -Zcheck-target-cfgs
+cargo check -Zcargo-lints -Zcheck-target-cfgs
 ```
 
 It follows the lint Rust `unexpected_cfgs` lint configuration: