Add support for boolean literals in target cfgs

Author: Urgau

Diff for: crates/cargo-platform/src/cfg.rs

@@ -10,6 +10,8 @@ pub enum CfgExpr {
     All(Vec<CfgExpr>),
     Any(Vec<CfgExpr>),
     Value(Cfg),
+    True,
+    False,
 }
 
 /// A cfg value.
@@ -87,6 +89,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,
         }
     }
 
@@ -106,7 +110,7 @@ impl CfgExpr {
                     }
                     Ok(())
                 }
-                CfgExpr::Value(_) => Ok(()),
+                CfgExpr::Value(_) | CfgExpr::True | CfgExpr::False => Ok(()),
             }
         }
 
@@ -137,6 +141,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"),
         }
     }
 }
@@ -191,7 +197,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 for: crates/cargo-platform/src/lib.rs

@@ -97,6 +97,7 @@ impl Platform {
                         ))
                     },
                 }
+                CfgExpr::True | CfgExpr::False => {},
             }
         }
 

Diff for: src/cargo/core/features.rs

@@ -517,6 +517,9 @@ features! {
 
     /// Allow paths that resolve relatively to a base specified in the config.
     (unstable, path_bases, "", "reference/unstable.html#path-bases"),
+
+    /// Allow boolean literals in `[target.'cfg(<true/false>)']`
+    (unstable, cfg_boolean_literals, "", "reference/unstable.html#cfg-boolean-literals"),
 }
 
 /// Status and metadata for a single unstable feature.
@@ -761,6 +764,7 @@ unstable_cli_options!(
     build_std: Option<Vec<String>>  = ("Enable Cargo to compile the standard library itself as part of a crate graph compilation"),
     build_std_features: Option<Vec<String>>  = ("Configure features enabled for the standard library itself when building the standard library"),
     cargo_lints: bool = ("Enable the `[lints.cargo]` table"),
+    cfg_boolean_literals: bool = ("Allow boolean literals in `[target.'cfg(<true/false>)']`"),
     checksum_freshness: bool = ("Use a checksum to determine if output is fresh rather than filesystem mtime"),
     codegen_backend: bool = ("Enable the `codegen-backend` option in profiles in .cargo/config.toml file"),
     config_include: bool = ("Enable the `include` key in config files"),
@@ -1259,6 +1263,7 @@ impl CliUnstable {
             }
             "build-std-features" => self.build_std_features = Some(parse_features(v)),
             "cargo-lints" => self.cargo_lints = parse_empty(k, v)?,
+            "cfg-boolean-literals" => self.cfg_boolean_literals = parse_empty(k, v)?,
             "codegen-backend" => self.codegen_backend = parse_empty(k, v)?,
             "config-include" => self.config_include = parse_empty(k, v)?,
             "direct-minimal-versions" => self.direct_minimal_versions = parse_empty(k, v)?,

Diff for: src/cargo/util/context/target.rs

@@ -1,6 +1,7 @@
 use super::{ConfigKey, ConfigRelativePath, GlobalContext, OptValue, PathAndArgs, StringList, CV};
 use crate::core::compiler::{BuildOutput, LinkArgTarget};
 use crate::util::CargoResult;
+use cargo_platform::{CfgExpr, Platform};
 use serde::Deserialize;
 use std::collections::{BTreeMap, HashMap};
 use std::path::PathBuf;
@@ -53,6 +54,17 @@ pub(super) fn load_target_cfgs(
     let target: BTreeMap<String, TargetCfgConfig> = gctx.get("target")?;
     tracing::debug!("Got all targets {:#?}", target);
     for (key, cfg) in target {
+        // Feature gate `cfg(true)`/`cfg(false)` under `-Zcfg-boolean-literals`
+        if !gctx.cli_unstable().cfg_boolean_literals {
+            if let Ok(Platform::Cfg(cfg_expr)) = key.parse() {
+                cfg_expr.walk_expr(|e| match e {
+                    CfgExpr::True | CfgExpr::False => {
+                        anyhow::bail!("`-Zcfg-boolean-literals` should be used to enable cfg boolean literals in `.cargo/config.toml`")
+                    },
+                    _ => Ok(()),
+                })?;
+            }
+        }
         if key.starts_with("cfg(") {
             // Unfortunately this is not able to display the location of the
             // unused key. Using config::Value<toml::Value> doesn't work. One

Diff for: src/cargo/util/toml/mod.rs

@@ -8,7 +8,7 @@ use std::str::{self, FromStr};
 use crate::core::summary::MissingDependencyError;
 use crate::AlreadyPrintedError;
 use anyhow::{anyhow, bail, Context as _};
-use cargo_platform::Platform;
+use cargo_platform::{CfgExpr, Platform};
 use cargo_util::paths;
 use cargo_util_schemas::manifest::{
     self, PackageName, PathBaseName, TomlDependency, TomlDetailedDependency, TomlManifest,
@@ -1314,6 +1314,12 @@ pub fn to_real_manifest(
     for (name, platform) in original_toml.target.iter().flatten() {
         let platform_kind: Platform = name.parse()?;
         platform_kind.check_cfg_attributes(warnings);
+        if let Platform::Cfg(cfg_expr) = &platform_kind {
+            cfg_expr.walk_expr(|e| match e {
+                CfgExpr::True | CfgExpr::False => features.require(Feature::cfg_boolean_literals()),
+                _ => Ok(()),
+            })?;
+        }
         let platform_kind = Some(platform_kind);
         validate_dependencies(
             platform.dependencies.as_ref(),

Diff for: src/doc/src/reference/unstable.md

@@ -121,6 +121,7 @@ Each new feature described below should explain how to use it.
     * [package-workspace](#package-workspace) --- Allows for packaging and publishing multiple crates in a workspace.
     * [native-completions](#native-completions) --- Move cargo shell completions to native completions.
     * [warnings](#warnings) --- controls warning behavior; options for allowing or denying warnings.
+    * [cfg-boolean-literals](#cfg-boolean-literals) --- Allows the use of boolean literals in `[target.'cfg(<true/false>)']`
 
 ## allow-features
 
@@ -1764,6 +1765,30 @@ Controls how Cargo handles warnings. Allowed values are:
 * `warn`: warnings are emitted as warnings (default).
 * `allow`: warnings are hidden.
 * `deny`: if warnings are emitted, an error will be raised at the end of the operation and the process will exit with a failure exit code. 
+
+## cfg-boolean-literals
+
+* Tracking Issue: [#00000](https://github.com/rust-lang/cargo/issues/00000)
+
+This feature allows the use of boolean literals in `[target.'cfg(<true/false>)']`.
+
+Those boolean literals always evaluate to true and false respectively, they are **not** subject
+to `RUSTFLAGS`.
+
+For example, in this example the `b` dependencies is always compiled, while `c` is never:
+
+```toml
+cargo-features = ["cfg-boolean-literals"]
+
+[target.'cfg(true)'.dependencies]
+b = { path = 'b' }
+
+[target.'cfg(false)'.dependencies]
+c = { path = 'c' }
+```
+
+For cfgs in `.cargo/config.toml`, `-Zcfg-boolean-literals` must be used.
+
 # Stabilized and removed features
 
 ## Compile progress