Stabilize #[cfg(version(...))]

compiler/rustc_attr_data_structures/src/version.rs

@@ -1,4 +1,5 @@
 use std::fmt::{self, Display};
+use std::sync::OnceLock;
 
 use rustc_macros::{
     Decodable, Encodable, HashStable_Generic, PrintAttribute, current_rustc_version,
@@ -16,8 +17,29 @@ pub struct RustcVersion {
 
 impl RustcVersion {
     pub const CURRENT: Self = current_rustc_version!();
+    pub fn current_configurable() -> Self {
+        *CURRENT_CONFIGURABLE.get_or_init(|| {
+            if let Ok(override_var) = std::env::var("RUSTC_OVERRIDE_VERSION_STRING")
+                && let Some(override_) = Self::parse_str(&override_var)
+            {
+                override_
+            } else {
+                Self::CURRENT
+            }
+        })
+    }
+    fn parse_str(value: &str) -> Option<Self> {
+        // Ignore any suffixes such as "-dev" or "-nightly".
+        let mut components = value.split('-').next().unwrap().splitn(3, '.');
+        let major = components.next()?.parse().ok()?;
+        let minor = components.next()?.parse().ok()?;
+        let patch = components.next().unwrap_or("0").parse().ok()?;
+        Some(RustcVersion { major, minor, patch })
+    }
 }
 
+static CURRENT_CONFIGURABLE: OnceLock<RustcVersion> = OnceLock::new();
+
 impl Display for RustcVersion {
     fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
         write!(formatter, "{}.{}.{}", self.major, self.minor, self.patch)

compiler/rustc_attr_parsing/src/attributes/cfg.rs

@@ -129,9 +129,9 @@ pub fn eval_condition(
 
             // See https://github.com/rust-lang/rust/issues/64796#issuecomment-640851454 for details
             if sess.psess.assume_incomplete_release {
-                RustcVersion::CURRENT > min_version
+                RustcVersion::current_configurable() > min_version
             } else {
-                RustcVersion::CURRENT >= min_version
+                RustcVersion::current_configurable() >= min_version
             }
         }
         MetaItemKind::List(mis) => {

compiler/rustc_feature/src/accepted.rs

@@ -109,6 +109,8 @@ declare_features! (
     (accepted, cfg_target_feature, "1.27.0", Some(29717)),
     /// Allows `cfg(target_vendor = "...")`.
     (accepted, cfg_target_vendor, "1.33.0", Some(29718)),
+    /// Allow conditional compilation depending on rust version
+    (accepted, cfg_version, "CURRENT_RUSTC_VERSION", Some(64796)),
     /// Allows implementing `Clone` for closures where possible (RFC 2132).
     (accepted, clone_closures, "1.26.0", Some(44490)),
     /// Allows coercing non capturing closures to function pointers.

compiler/rustc_feature/src/builtin_attrs.rs

@@ -33,7 +33,6 @@ const GATED_CFGS: &[GatedCfg] = &[
         Features::cfg_target_has_atomic,
     ),
     (sym::sanitize, sym::cfg_sanitize, Features::cfg_sanitize),
-    (sym::version, sym::cfg_version, Features::cfg_version),
     (sym::relocation_model, sym::cfg_relocation_model, Features::cfg_relocation_model),
     (sym::sanitizer_cfi_generalize_pointers, sym::cfg_sanitizer_cfi, Features::cfg_sanitizer_cfi),
     (sym::sanitizer_cfi_normalize_integers, sym::cfg_sanitizer_cfi, Features::cfg_sanitizer_cfi),

compiler/rustc_feature/src/unstable.rs

@@ -417,8 +417,6 @@ declare_features! (
     (unstable, cfg_target_thread_local, "1.7.0", Some(29594)),
     /// Allows the use of `#[cfg(ub_checks)` to check if UB checks are enabled.
     (unstable, cfg_ub_checks, "1.79.0", Some(123499)),
-    /// Allow conditional compilation depending on rust version
-    (unstable, cfg_version, "1.45.0", Some(64796)),
     /// Allows to use the `#[cfi_encoding = ""]` attribute.
     (unstable, cfi_encoding, "1.71.0", Some(89653)),
     /// Allows `for<...>` on closures and coroutines.

compiler/rustc_lint/messages.ftl

@@ -810,9 +810,10 @@ lint_undropped_manually_drops = calls to `std::mem::drop` with `std::mem::Manual
     .suggestion = use `std::mem::ManuallyDrop::into_inner` to get the inner value
 
 lint_unexpected_builtin_cfg = unexpected `--cfg {$cfg}` flag
-    .controlled_by = config `{$cfg_name}` is only supposed to be controlled by `{$controlled_by}`
     .incoherent = manually setting a built-in cfg can and does create incoherent behaviors
 
+lint_unexpected_builtin_cfg_controlled_by = config `{$cfg_name}` is only supposed to be controlled by `{$controlled_by}`
+
 lint_unexpected_cfg_add_build_rs_println = or consider adding `{$build_rs_println}` to the top of the `build.rs`
 lint_unexpected_cfg_add_cargo_feature = consider using a Cargo feature instead
 lint_unexpected_cfg_add_cargo_toml_lint_cfg = or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint:{$cargo_toml_lint_cfg}

compiler/rustc_lint/src/early/diagnostics.rs

@@ -448,7 +448,13 @@ pub(super) fn decorate_lint(
             lints::OutOfScopeMacroCalls { span, path, location }.decorate_lint(diag)
         }
         BuiltinLintDiag::UnexpectedBuiltinCfg { cfg, cfg_name, controlled_by } => {
-            lints::UnexpectedBuiltinCfg { cfg, cfg_name, controlled_by }.decorate_lint(diag)
+            lints::UnexpectedBuiltinCfg {
+                cfg,
+                cfg_name,
+                controlled_by: controlled_by
+                    .map(|controlled_by| lints::ControlledBy { controlled_by }),
+            }
+            .decorate_lint(diag)
         }
         BuiltinLintDiag::ElidedNamedLifetimes { elided: (span, kind), resolution } => {
             match resolution {

compiler/rustc_lint/src/lints.rs

@@ -2498,11 +2498,17 @@ pub(crate) mod unexpected_cfg_value {
 
 #[derive(LintDiagnostic)]
 #[diag(lint_unexpected_builtin_cfg)]
-#[note(lint_controlled_by)]
 #[note(lint_incoherent)]
 pub(crate) struct UnexpectedBuiltinCfg {
     pub(crate) cfg: String,
     pub(crate) cfg_name: Symbol,
+    #[subdiagnostic]
+    pub(crate) controlled_by: Option<ControlledBy>,
+}
+
+#[derive(Subdiagnostic)]
+#[note(lint_unexpected_builtin_cfg_controlled_by)]
+pub(crate) struct ControlledBy {
     pub(crate) controlled_by: &'static str,
 }
 

compiler/rustc_lint_defs/src/lib.rs

@@ -827,7 +827,7 @@ pub enum BuiltinLintDiag {
     UnexpectedBuiltinCfg {
         cfg: String,
         cfg_name: Symbol,
-        controlled_by: &'static str,
+        controlled_by: Option<&'static str>,
     },
 }
 

compiler/rustc_session/src/config/cfg.rs

@@ -88,7 +88,7 @@ impl<'a, T: Eq + Hash + Copy + 'a> Extend<&'a T> for ExpectedValues<T> {
 
 /// Disallow builtin cfgs from the CLI.
 pub(crate) fn disallow_cfgs(sess: &Session, user_cfgs: &Cfg) {
-    let disallow = |cfg: &(Symbol, Option<Symbol>), controlled_by| {
+    let disallow_controlled_by = |cfg: &(Symbol, Option<Symbol>), controlled_by| {
         let cfg_name = cfg.0;
         let cfg = if let Some(value) = cfg.1 {
             format!(r#"{}="{}""#, cfg_name, value)
@@ -102,6 +102,9 @@ pub(crate) fn disallow_cfgs(sess: &Session, user_cfgs: &Cfg) {
             BuiltinLintDiag::UnexpectedBuiltinCfg { cfg, cfg_name, controlled_by },
         )
     };
+    let disallow = |cfg: &(Symbol, Option<Symbol>), controlled_by| {
+        disallow_controlled_by(cfg, Some(controlled_by));
+    };
 
     // We want to restrict setting builtin cfgs that will produce incoherent behavior
     // between the cfg and the rustc cli flag that sets it.
@@ -147,6 +150,7 @@ pub(crate) fn disallow_cfgs(sess: &Session, user_cfgs: &Cfg) {
             | (sym::target_has_reliable_f128, None | Some(_))
             | (sym::target_has_reliable_f128_math, None | Some(_))
             | (sym::target_thread_local, None) => disallow(cfg, "--target"),
+            (sym::has_cfg_version, None) => disallow_controlled_by(cfg, None),
             (sym::fmt_debug, None | Some(_)) => disallow(cfg, "-Z fmt-debug"),
             (sym::emscripten_wasm_eh, None | Some(_)) => disallow(cfg, "-Z emscripten_wasm_eh"),
             _ => {}
@@ -310,6 +314,8 @@ pub(crate) fn default_configuration(sess: &Session) -> Cfg {
         ins_none!(sym::contract_checks);
     }
 
+    ins_none!(sym::has_cfg_version);
+
     ret
 }
 
@@ -472,6 +478,8 @@ impl CheckCfg {
         ins!(sym::ub_checks, no_values);
         ins!(sym::contract_checks, no_values);
 
+        ins!(sym::has_cfg_version, no_values);
+
         ins!(sym::unix, no_values);
         ins!(sym::windows, no_values);
     }

compiler/rustc_span/src/symbol.rs

@@ -1089,6 +1089,7 @@ symbols! {
         guard_patterns,
         half_open_range_patterns,
         half_open_range_patterns_in_slices,
+        has_cfg_version,
         hash,
         hashmap_contains_key,
         hashmap_drain_ty,

compiler/rustc_trait_selection/src/lib.rs

@@ -19,7 +19,6 @@
 #![feature(assert_matches)]
 #![feature(associated_type_defaults)]
 #![feature(box_patterns)]
-#![feature(cfg_version)]
 #![feature(if_let_guard)]
 #![feature(iter_intersperse)]
 #![feature(iterator_try_reduce)]

tests/ui/cfg/assume-incomplete-release/assume-incomplete.rs

@@ -3,8 +3,6 @@
 //@ revisions: assume no_assume
 //@ [assume]compile-flags: -Z assume-incomplete-release
 
-#![feature(cfg_version)]
-
 extern crate ver_cfg_rel;
 
 use ver_cfg_rel::ver_cfg_rel;

tests/ui/cfg/cfg-version/cfg-version-expand.rs

@@ -0,0 +1,28 @@
+//@ run-pass
+//@ rustc-env:RUSTC_OVERRIDE_VERSION_STRING=1.50.3
+
+#[cfg_attr(has_cfg_version, cfg(version("1.49.0")))]
+const ON_1_49_0: bool = true;
+#[cfg(version("1.50"))]
+const ON_1_50_0: bool = true;
+#[cfg(not(version("1.51")))]
+const ON_1_51_0: bool = false;
+
+// This one uses the wrong syntax, so doesn't eval to true
+#[warn(unexpected_cfgs)]
+#[cfg(not(version = "1.48.0"))] //~ WARN unexpected `cfg` condition name: `version`
+const ON_1_48_0: bool = false;
+
+fn main() {
+    assert!(!ON_1_48_0);
+    assert!(ON_1_49_0);
+    assert!(ON_1_50_0);
+    assert!(!ON_1_51_0);
+    assert!(cfg!(version("1.1")));
+    assert!(cfg!(version("1.49")));
+    assert!(cfg!(version("1.50.0")));
+    assert!(cfg!(version("1.50.3")));
+    assert!(!cfg!(version("1.50.4")));
+    assert!(!cfg!(version("1.51")));
+    assert!(!cfg!(version("1.100")));
+}

tests/ui/cfg/cfg-version/cfg-version-expand.stderr

@@ -0,0 +1,13 @@
+warning: unexpected `cfg` condition name: `version`
+  --> $DIR/cfg-version-expand.rs:13:11
+   |
+LL | #[cfg(not(version = "1.48.0"))]
+   |           ^^^^^^^^^^^^^^^^^^
+   |
+   = help: expected names are: `FALSE` and `test` and 32 more
+   = help: to expect this configuration use `--check-cfg=cfg(version, values("1.48.0"))`
+   = note: see <https://doc.rust-lang.org/nightly/rustc/check-cfg.html> for more information about checking conditional configuration
+   = note: `#[warn(unexpected_cfgs)]` on by default
+
+warning: 1 warning emitted
+

tests/ui/feature-gates/feature-gate-cfg-version.rs → tests/ui/cfg/cfg-version/cfg-version.rs

@@ -1,49 +1,37 @@
 #[cfg(version(42))] //~ ERROR: expected a version literal
-//~^ ERROR `cfg(version)` is experimental and subject to change
 fn foo() {}
 #[cfg(version(1.20))] //~ ERROR: expected a version literal
-//~^ ERROR `cfg(version)` is experimental and subject to change
+fn foo() -> bool { true }
+#[cfg(version = "1.20")] //~ WARN: unexpected `cfg` condition name: `version`
 fn foo() -> bool { true }
 #[cfg(version("1.44"))]
-//~^ ERROR `cfg(version)` is experimental and subject to change
 fn foo() -> bool { true }
 #[cfg(not(version("1.44")))]
-//~^ ERROR `cfg(version)` is experimental and subject to change
 fn foo() -> bool { false }
 
 #[cfg(version("1.43", "1.44", "1.45"))] //~ ERROR: expected single version literal
-//~^ ERROR `cfg(version)` is experimental and subject to change
 fn bar() -> bool  { false }
 #[cfg(version(false))] //~ ERROR: expected a version literal
-//~^ ERROR `cfg(version)` is experimental and subject to change
 fn bar() -> bool  { false }
 #[cfg(version("foo"))] //~ WARNING: unknown version literal format
-//~^ ERROR `cfg(version)` is experimental and subject to change
 fn bar() -> bool  { false }
 #[cfg(version("999"))] //~ WARNING: unknown version literal format
-//~^ ERROR `cfg(version)` is experimental and subject to change
 fn bar() -> bool  { false }
 #[cfg(version("-1"))] //~ WARNING: unknown version literal format
-//~^ ERROR `cfg(version)` is experimental and subject to change
 fn bar() -> bool  { false }
 #[cfg(version("65536"))] //~ WARNING: unknown version literal format
-//~^ ERROR `cfg(version)` is experimental and subject to change
 fn bar() -> bool  { false }
 #[cfg(version("0"))] //~ WARNING: unknown version literal format
-//~^ ERROR `cfg(version)` is experimental and subject to change
 fn bar() -> bool { true }
 #[cfg(version("1.0"))]
-//~^ ERROR `cfg(version)` is experimental and subject to change
 fn bar() -> bool { true }
 #[cfg(version("1.65536.2"))] //~ WARNING: unknown version literal format
-//~^ ERROR `cfg(version)` is experimental and subject to change
 fn bar() -> bool  { false }
 #[cfg(version("1.20.0-stable"))] //~ WARNING: unknown version literal format
-//~^ ERROR `cfg(version)` is experimental and subject to change
 fn bar() {}
 
 fn main() {
     assert!(foo());
     assert!(bar());
-    assert!(cfg!(version("1.42"))); //~ ERROR `cfg(version)` is experimental and subject to change
+    assert!(cfg!(version("1.42")));
 }