Implement RFC3695: Allow boolean literals as cfg predicates (#14649)

epage · web-flow · commit 69eeb6ad94c6 · 2025-04-22T17:54:52.000Z
### What does this PR try to resolve? This PR implements rust-lang/rfcs#3695: allow boolean literals as cfg predicates, i.e. `cfg(true)` and `cfg(false)`. ### How should we test and review this PR? The PR should be reviewed commit by commit and tested by looking at the tests and using `[target.'cfg(<true/false>)']` in `Cargo.toml`/`.cargo/config.toml`. ### Additional information I had to bump `cargo-platform` to `0.3.0` has we are changing `CfgExpr` enum in a semver incompatible change. We currently have (thks to #14671) a forward compatibility warning against `cfg(true/false)` as identifiers instead of keywords. ~~I choose a use a `Cargo.toml` feature (for the manifest) as well as a unstable CLI flag for the `.cargo/config.toml` part.~~ ~~Given the very small (two occurrences on Github Search) for [`cfg(true)`](https://github.com/search?q=lang%3Atoml+%2F%28%3F-i%29%5C%5Btarget%5C.%5B%27%22%5Dcfg.*true%2F&type=code) and [`cfg(false)`](https://github.com/search?q=lang%3Atoml+%2F%28%3F-i%29%5C%5Btarget%5C.%5B%27%22%5Dcfg.*false%2F&type=code), I choose to gate the feature under a error and not a warning.~~
diff --git a/Cargo.lock b/Cargo.lock
diff --git a/Cargo.toml b/Cargo.toml
@@ -30,7 +30,7 @@ cargo-credential = { version = "0.4.2", path = "credential/cargo-credential" }
 cargo-credential-libsecret = { version = "0.4.13", path = "credential/cargo-credential-libsecret" }
 cargo-credential-macos-keychain = { version = "0.4.13", path = "credential/cargo-credential-macos-keychain" }
 cargo-credential-wincred = { version = "0.4.13", path = "credential/cargo-credential-wincred" }
-cargo-platform = { path = "crates/cargo-platform", version = "0.2.0" }
+cargo-platform = { path = "crates/cargo-platform", version = "0.3.0" }
 cargo-test-macro = { version = "0.4.2", path = "crates/cargo-test-macro" }
 cargo-test-support = { version = "0.7.1", path = "crates/cargo-test-support" }
 cargo-util = { version = "0.2.20", path = "crates/cargo-util" }
diff --git a/crates/cargo-platform/Cargo.toml b/crates/cargo-platform/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "cargo-platform"
-version = "0.2.0"
+version = "0.3.0"
 edition.workspace = true
 license.workspace = true
 rust-version.workspace = true
diff --git a/crates/cargo-platform/src/cfg.rs b/crates/cargo-platform/src/cfg.rs
@@ -11,6 +11,8 @@ pub enum CfgExpr {
     All(Vec<CfgExpr>),
     Any(Vec<CfgExpr>),
     Value(Cfg),
+    True,
+    False,
 }
 
 /// A cfg value.
@@ -147,6 +149,8 @@ impl CfgExpr {
             CfgExpr::All(ref e) => e.iter().all(|e| e.matches(cfg)),
             CfgExpr::Any(ref e) => e.iter().any(|e| e.matches(cfg)),
             CfgExpr::Value(ref e) => cfg.contains(e),
+            CfgExpr::True => true,
+            CfgExpr::False => false,
         }
     }
 }
@@ -174,6 +178,8 @@ impl fmt::Display for CfgExpr {
             CfgExpr::All(ref e) => write!(f, "all({})", CommaSep(e)),
             CfgExpr::Any(ref e) => write!(f, "any({})", CommaSep(e)),
             CfgExpr::Value(ref e) => write!(f, "{}", e),
+            CfgExpr::True => write!(f, "true"),
+            CfgExpr::False => write!(f, "false"),
         }
     }
 }
@@ -229,7 +235,11 @@ impl<'a> Parser<'a> {
                 self.eat(&Token::RightParen)?;
                 Ok(CfgExpr::Not(Box::new(e)))
             }
-            Some(Ok(..)) => self.cfg().map(CfgExpr::Value),
+            Some(Ok(..)) => self.cfg().map(|v| match v {
+                Cfg::Name(n) if n == "true" => CfgExpr::True,
+                Cfg::Name(n) if n == "false" => CfgExpr::False,
+                v => CfgExpr::Value(v),
+            }),
             Some(Err(..)) => Err(self.t.next().unwrap().err().unwrap()),
             None => Err(ParseError::new(
                 self.t.orig,
diff --git a/crates/cargo-platform/src/lib.rs b/crates/cargo-platform/src/lib.rs
@@ -98,6 +98,7 @@ impl Platform {
                         ))
                     },
                 }
+                CfgExpr::True | CfgExpr::False => {},
             }
         }
 
@@ -115,30 +116,18 @@ impl Platform {
                         check_cfg_expr(e, warnings, path);
                     }
                 }
+                CfgExpr::True | CfgExpr::False => {}
                 CfgExpr::Value(ref e) => match e {
                     Cfg::Name(name) | Cfg::KeyPair(name, _) => {
                         if !name.raw && KEYWORDS.contains(&name.as_str()) {
-                            if name.as_str() == "true" || name.as_str() == "false" {
-                                warnings.push(format!(
-                                    "[{}] future-incompatibility: the meaning of `cfg({e})` will change in the future\n \
-                                     | Cargo is erroneously allowing `cfg(true)` and `cfg(false)`, but both forms are interpreted as false unless manually overridden with `--cfg`.\n \
-                                     | In the future these will be built-in defines that will have the corresponding true/false value.\n \
-                                     | It is recommended to avoid using these configs until they are properly supported.\n \
-                                     | See <https://github.com/rust-lang/rust/issues/131204> for more information.\n \
-                                     |\n \
-                                     | help: use raw-idents instead: `cfg(r#{name})`",
-                                    path.display()
-                                ));
-                            } else {
-                                warnings.push(format!(
-                                    "[{}] future-incompatibility: `cfg({e})` is deprecated as `{name}` is a keyword \
-                                     and not an identifier and should not have have been accepted in this position.\n \
-                                     | this was previously accepted by Cargo but is being phased out; it will become a hard error in a future release!\n \
-                                     |\n \
-                                     | help: use raw-idents instead: `cfg(r#{name})`",
-                                     path.display()
-                                ));
-                            }
+                            warnings.push(format!(
+                                "[{}] future-incompatibility: `cfg({e})` is deprecated as `{name}` is a keyword \
+                                 and not an identifier and should not have have been accepted in this position.\n \
+                                 | this was previously accepted by Cargo but is being phased out; it will become a hard error in a future release!\n \
+                                 |\n \
+                                 | help: use raw-idents instead: `cfg(r#{name})`",
+                                 path.display()
+                            ));
                         }
                     }
                 },
diff --git a/crates/cargo-platform/tests/test_cfg.rs b/crates/cargo-platform/tests/test_cfg.rs
@@ -39,6 +39,8 @@ macro_rules! e {
     (any($($t:tt),*)) => (CfgExpr::Any(vec![$(e!($t)),*]));
     (all($($t:tt),*)) => (CfgExpr::All(vec![$(e!($t)),*]));
     (not($($t:tt)*)) => (CfgExpr::Not(Box::new(e!($($t)*))));
+    (true) => (CfgExpr::True);
+    (false) => (CfgExpr::False);
     (($($t:tt)*)) => (e!($($t)*));
     ($($t:tt)*) => (CfgExpr::Value(c!($($t)*)));
 }
@@ -122,6 +124,9 @@ fn cfg_expr() {
     good(" foo=\"3\"      ", e!(foo = "3"));
     good("foo = \"3 e\"", e!(foo = "3 e"));
 
+    good("true", e!(true));
+    good("false", e!(false));
+
     good("all()", e!(all()));
     good("all(a)", e!(all(a)));
     good("all(a, b)", e!(all(a, b)));
@@ -249,6 +254,8 @@ fn check_cfg_attributes() {
     ok("windows");
     ok("any(not(unix), windows)");
     ok("foo");
+    ok("true");
+    ok("false");
 
     ok("target_arch = \"abc\"");
     ok("target_feature = \"abc\"");
diff --git a/tests/testsuite/cfg.rs b/tests/testsuite/cfg.rs
@@ -545,6 +545,7 @@ fn cfg_raw_idents() {
     p.cargo("check")
         .with_stderr_data(str![[r#"
 [LOCKING] 1 package to latest compatible version
+[CHECKING] b v0.0.1 ([ROOT]/foo/b)
 [CHECKING] foo v0.1.0 ([ROOT]/foo)
 [FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s
 
@@ -638,24 +639,181 @@ fn cfg_keywords() {
 
     p.cargo("check")
         .with_stderr_data(str![[r#"
-[WARNING] [[ROOT]/foo/Cargo.toml] future-incompatibility: the meaning of `cfg(true)` will change in the future
- | Cargo is erroneously allowing `cfg(true)` and `cfg(false)`, but both forms are interpreted as false unless manually overridden with `--cfg`.
- | In the future these will be built-in defines that will have the corresponding true/false value.
- | It is recommended to avoid using these configs until they are properly supported.
- | See <https://github.com/rust-lang/rust/issues/131204> for more information.
- |
- | [HELP] use raw-idents instead: `cfg(r#true)`
-[WARNING] [.cargo/config.toml] future-incompatibility: the meaning of `cfg(false)` will change in the future
- | Cargo is erroneously allowing `cfg(true)` and `cfg(false)`, but both forms are interpreted as false unless manually overridden with `--cfg`.
- | In the future these will be built-in defines that will have the corresponding true/false value.
- | It is recommended to avoid using these configs until they are properly supported.
- | See <https://github.com/rust-lang/rust/issues/131204> for more information.
- |
- | [HELP] use raw-idents instead: `cfg(r#false)`
 [LOCKING] 1 package to latest compatible version
+[CHECKING] b v0.0.1 ([ROOT]/foo/b)
 [CHECKING] foo v0.1.0 ([ROOT]/foo)
 [FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s
 
 "#]])
         .run();
 }
+
+#[cargo_test]
+fn cfg_booleans() {
+    let p = project()
+        .file(
+            "Cargo.toml",
+            r#"
+                [package]
+                name = "a"
+                version = "0.0.1"
+                edition = "2015"
+                authors = []
+
+                [target.'cfg(true)'.dependencies]
+                b = { path = 'b' }
+                
+                [target.'cfg(false)'.dependencies]
+                c = { path = 'c' }
+            "#,
+        )
+        .file("src/lib.rs", "")
+        .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
+[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();
+}
+
+#[cargo_test]
+fn cfg_booleans_config() {
+    let p = project()
+        .file(
+            "Cargo.toml",
+            r#"
+                [package]
+                name = "a"
+                version = "0.0.1"
+                edition = "2015"
+            "#,
+        )
+        .file("src/lib.rs", "")
+        .file(
+            ".cargo/config.toml",
+            r#"
+                [target.'cfg(true)']
+                rustflags = []
+            "#,
+        )
+        .build();
+
+    p.cargo("check")
+        .with_stderr_data(str![[r#"
+[CHECKING] a v0.0.1 ([ROOT]/foo)
+[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s
+
+"#]])
+        .run();
+}
+
+#[cargo_test]
+fn cfg_booleans_not() {
+    let p = project()
+        .file(
+            "Cargo.toml",
+            r#"
+                [package]
+                name = "a"
+                version = "0.0.1"
+                edition = "2015"
+                authors = []
+
+                [target.'cfg(not(false))'.dependencies]
+                b = { path = 'b' }
+            "#,
+        )
+        .file("src/lib.rs", "")
+        .file("b/Cargo.toml", &basic_manifest("b", "0.0.1"))
+        .file("b/src/lib.rs", "")
+        .build();
+
+    p.cargo("check")
+        .with_stderr_data(str![[r#"
+[LOCKING] 1 package to latest compatible version
+[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();
+}
+
+#[cargo_test]
+fn cfg_booleans_combinators() {
+    let p = project()
+        .file(
+            "Cargo.toml",
+            r#"
+                [package]
+                name = "a"
+                version = "0.0.1"
+                edition = "2015"
+                authors = []
+
+                [target.'cfg(all(any(true), not(false), true))'.dependencies]
+                b = { path = 'b' }
+            "#,
+        )
+        .file("src/lib.rs", "")
+        .file("b/Cargo.toml", &basic_manifest("b", "0.0.1"))
+        .file("b/src/lib.rs", "")
+        .build();
+
+    p.cargo("check")
+        .with_stderr_data(str![[r#"
+[LOCKING] 1 package to latest compatible version
+[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();
+}
+
+#[cargo_test]
+fn cfg_booleans_rustflags_no_effect() {
+    let p = project()
+        .file(
+            "Cargo.toml",
+            r#"
+                [package]
+                name = "a"
+                version = "0.0.1"
+                edition = "2015"
+                authors = []
+
+                [target.'cfg(true)'.dependencies]
+                b = { path = 'b' }
+                
+                [target.'cfg(false)'.dependencies]
+                c = { path = 'c' }
+            "#,
+        )
+        .file("src/lib.rs", "")
+        .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")
+        .env("RUSTFLAGS", "--cfg false")
+        .with_stderr_data(str![[r#"
+[LOCKING] 2 packages to latest compatible versions
+[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();
+}

Original file line number	Diff line number	Diff line change
`@@ -11,6 +11,8 @@ pub enum CfgExpr {`
`11`	`11`	`All(Vec<CfgExpr>),`
`12`	`12`	`Any(Vec<CfgExpr>),`
`13`	`13`	`Value(Cfg),`
	`14`	`+ True,`
	`15`	`+ False,`
`14`	`16`	`}`
`15`	`17`
`16`	`18`	`/// A cfg value.`
`@@ -147,6 +149,8 @@ impl CfgExpr {`
`147`	`149`	`CfgExpr::All(ref e) => e.iter().all(\|e\| e.matches(cfg)),`
`148`	`150`	`CfgExpr::Any(ref e) => e.iter().any(\|e\| e.matches(cfg)),`
`149`	`151`	`CfgExpr::Value(ref e) => cfg.contains(e),`
	`152`	`+ CfgExpr::True => true,`
	`153`	`+ CfgExpr::False => false,`
`150`	`154`	`}`
`151`	`155`	`}`
`152`	`156`	`}`
`@@ -174,6 +178,8 @@ impl fmt::Display for CfgExpr {`
`174`	`178`	`CfgExpr::All(ref e) => write!(f, "all({})", CommaSep(e)),`
`175`	`179`	`CfgExpr::Any(ref e) => write!(f, "any({})", CommaSep(e)),`
`176`	`180`	`CfgExpr::Value(ref e) => write!(f, "{}", e),`
	`181`	`+ CfgExpr::True => write!(f, "true"),`
	`182`	`+ CfgExpr::False => write!(f, "false"),`
`177`	`183`	`}`
`178`	`184`	`}`
`179`	`185`	`}`
`@@ -229,7 +235,11 @@ impl<'a> Parser<'a> {`
`229`	`235`	`self.eat(&Token::RightParen)?;`
`230`	`236`	`Ok(CfgExpr::Not(Box::new(e)))`
`231`	`237`	`}`
`232`		`- Some(Ok(..)) => self.cfg().map(CfgExpr::Value),`
	`238`	`+ Some(Ok(..)) => self.cfg().map(\|v\| match v {`
	`239`	`+ Cfg::Name(n) if n == "true" => CfgExpr::True,`
	`240`	`+ Cfg::Name(n) if n == "false" => CfgExpr::False,`
	`241`	`+ v => CfgExpr::Value(v),`
	`242`	`+ }),`
`233`	`243`	`Some(Err(..)) => Err(self.t.next().unwrap().err().unwrap()),`
`234`	`244`	`None => Err(ParseError::new(`
`235`	`245`	`self.t.orig,`