Warn against unexpected cfgs in [target.'cfg(...)']

Author: Urgau

src/cargo/ops/cargo_compile/mod.rs

@@ -37,8 +37,11 @@
 
 use std::collections::{HashMap, HashSet};
 use std::hash::{Hash, Hasher};
+use std::path::Path;
+use std::str::FromStr;
 use std::sync::Arc;
 
+use crate::core::compiler::build_context::{CheckCfg, ExpectedValues};
 use crate::core::compiler::unit_dependencies::build_unit_dependencies;
 use crate::core::compiler::unit_graph::{self, UnitDep, UnitGraph};
 use crate::core::compiler::{standard_lib, CrateType, TargetInfo};
@@ -57,6 +60,7 @@ use crate::util::interning::InternedString;
 use crate::util::{CargoResult, StableHasher};
 
 mod compile_filter;
+use cargo_platform::{Cfg, CfgExpr, Platform};
 pub use compile_filter::{CompileFilter, FilterRule, LibRule};
 
 mod unit_generator;
@@ -476,6 +480,49 @@ pub fn create_bcx<'a, 'gctx>(
             .extend(args);
     }
 
+    {
+        let check_cfg = target_data.check_cfg();
+
+        if check_cfg.exhaustive {
+            let target_cfgs = gctx.target_cfgs()?;
+            for (key, _fields) in target_cfgs {
+                if !key.starts_with("cfg(") || !key.ends_with(')') {
+                    continue;
+                }
+
+                let cfg_expr = &key[4..key.len() - 1];
+                let Ok(cfg_expr) = CfgExpr::from_str(cfg_expr) else {
+                    continue;
+                };
+
+                warn_on_unexpected_cfgs(gctx, check_cfg, &cfg_expr, None, "")?;
+            }
+
+            for unit in &units {
+                if !unit.show_warnings(gctx) {
+                    continue;
+                }
+
+                for dep in unit.pkg.summary().dependencies() {
+                    let Some(platform) = dep.platform() else {
+                        continue;
+                    };
+                    let Platform::Cfg(cfg_expr) = platform else {
+                        continue;
+                    };
+
+                    warn_on_unexpected_cfgs(
+                        gctx,
+                        check_cfg,
+                        cfg_expr,
+                        Some(unit.pkg.manifest_path()),
+                        ".dependencies",
+                    )?;
+                }
+            }
+        }
+    }
+
     if honor_rust_version.unwrap_or(true) {
         let rustc_version = target_data.rustc.version.clone().into();
 
@@ -542,6 +589,52 @@ where `<compatible-ver>` is the latest version supporting rustc {rustc_version}"
     Ok(bcx)
 }
 
+fn warn_on_unexpected_cfgs(
+    gctx: &GlobalContext,
+    check_cfg: &CheckCfg,
+    cfg_expr: &CfgExpr,
+    path: Option<&Path>,
+    suffix: &str,
+) -> CargoResult<()> {
+    let prefix = if let Some(path) = path {
+        format!("{path}: ", path = path.display())
+    } else {
+        "".to_string()
+    };
+
+    cfg_expr.fold(&|cfg| -> CargoResult<()> {
+        let (name, value) = match cfg {
+            Cfg::Name(name) => (name, None),
+            Cfg::KeyPair(name, value) => (name, Some(value.to_string())),
+        };
+
+        match check_cfg.expecteds.get(name) {
+            Some(ExpectedValues::Some(values)) if !values.contains(&value) => {
+                let value = if let Some(ref value) = value {
+                    value
+                } else {
+                    "(none)"
+                };
+                gctx.shell().warn(format!(
+                    "{prefix}unexpected `cfg` condition value: `{value}` for `{cfg}` in `[target.'cfg({cfg_expr})'{suffix}]`"
+                ))?;
+            }
+            None => {
+                gctx.shell().warn(format!(
+                    "{prefix}unexpected `cfg` condition name: `{name}`{cfg} in `[target.'cfg({cfg_expr})'{suffix}]`",
+                    cfg = if value.is_some() {
+                        format!(" for `{cfg}`")
+                    } else {
+                        format!("")
+                    }
+                ))?;
+            }
+            _ => { /* not unexpected */ }
+        }
+        Ok(())
+    })
+}
+
 /// This is used to rebuild the unit graph, sharing host dependencies if possible,
 /// and applying other unit adjustments based on the whole graph.
 ///

tests/testsuite/cfg.rs

@@ -515,9 +515,73 @@ fn exclusive_dep_kinds() {
         .with_status(101)
         // can't find crate for `bar`
         .with_stderr_data(str![[r#"
+[WARNING] [ROOT]/foo/Cargo.toml: unexpected `cfg` condition name: `abc` in `[target.'cfg(abc)'.dependencies]`
+[WARNING] [ROOT]/foo/Cargo.toml: unexpected `cfg` condition name: `abc` in `[target.'cfg(not(abc))'.dependencies]`
 [COMPILING] foo v0.1.0 ([ROOT]/foo)
 error[E0463]: can't find crate for `bar`
 ...
 "#]])
         .run();
 }
+
+#[cargo_test]
+fn unexpected_cfgs_target() {
+    let p = project()
+        .file(
+            "Cargo.toml",
+            r#"
+                [package]
+                name = "a"
+                version = "0.0.1"
+                edition = "2015"
+                authors = []
+
+                [target."cfg(any(windows, unix))".dependencies]
+                b = { path = 'b' }
+                
+                [target."cfg(any(foo, all(bar)))".dependencies]
+                b = { path = 'b' }
+                
+                [target.'cfg(unix = "zoo")'.dependencies]
+                b = { path = 'b' }
+                c = { path = 'c' }
+                
+                [target.'cfg(not(windows = ""))'.dependencies]
+                b = { path = 'b' }
+            "#,
+        )
+        .file(
+            ".cargo/config.toml",
+            r#"
+                [target."cfg(any(windows, unix))"]
+                [target."cfg(any(foo, all(bar)))"]
+                [target.'cfg(unix = "zoo")']
+                [target.'cfg(not(windows = ""))']
+            "#,
+        )
+        .file("src/lib.rs", "extern crate b;")
+        .file("b/Cargo.toml", &basic_manifest("b", "0.0.1"))
+        .file("b/src/lib.rs", "")
+        .file("c/Cargo.toml", &basic_manifest("c", "0.0.1"))
+        .file("c/src/lib.rs", "")
+        .build();
+
+    p.cargo("check")
+        .with_stderr_data(str![[r#"
+[LOCKING] 2 packages to latest compatible versions
+[WARNING] unexpected `cfg` condition name: `foo` in `[target.'cfg(any(foo, all(bar)))']`
+[WARNING] unexpected `cfg` condition name: `bar` in `[target.'cfg(any(foo, all(bar)))']`
+[WARNING] unexpected `cfg` condition value: `` for `windows = ""` in `[target.'cfg(not(windows = ""))']`
+[WARNING] unexpected `cfg` condition value: `zoo` for `unix = "zoo"` in `[target.'cfg(unix = "zoo")']`
+[WARNING] [ROOT]/foo/Cargo.toml: unexpected `cfg` condition name: `foo` in `[target.'cfg(any(foo, all(bar)))'.dependencies]`
+[WARNING] [ROOT]/foo/Cargo.toml: unexpected `cfg` condition name: `bar` in `[target.'cfg(any(foo, all(bar)))'.dependencies]`
+[WARNING] [ROOT]/foo/Cargo.toml: unexpected `cfg` condition value: `` for `windows = ""` in `[target.'cfg(not(windows = ""))'.dependencies]`
+[WARNING] [ROOT]/foo/Cargo.toml: unexpected `cfg` condition value: `zoo` for `unix = "zoo"` in `[target.'cfg(unix = "zoo")'.dependencies]`
+[WARNING] [ROOT]/foo/Cargo.toml: unexpected `cfg` condition value: `zoo` for `unix = "zoo"` in `[target.'cfg(unix = "zoo")'.dependencies]`
+[CHECKING] b v0.0.1 ([ROOT]/foo/b)
+[CHECKING] a v0.0.1 ([ROOT]/foo)
+[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s
+
+"#]])
+        .run();
+}

tests/testsuite/tool_paths.rs

@@ -479,6 +479,8 @@ fn cfg_ignored_fields() {
 [WARNING] unused key `ar` in [target] config table `cfg(not(target_os = "none"))`
 [WARNING] unused key `foo` in [target] config table `cfg(not(target_os = "none"))`
 [WARNING] unused key `invalid` in [target] config table `cfg(not(target_os = "none"))`
+[WARNING] unexpected `cfg` condition name: `bar` in `[target.'cfg(not(bar))']`
+[WARNING] unexpected `cfg` condition name: `foo` in `[target.'cfg(not(foo))']`
 [CHECKING] foo v0.0.1 ([ROOT]/foo)
 [FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s