update cfgs

alloc/src/collections/vec_deque/into_iter.rs

@@ -121,8 +121,6 @@ impl<T, A: Allocator> Iterator for IntoIter<T, A> {
     {
         match self.try_fold(init, |b, item| Ok::<B, !>(f(b, item))) {
             Ok(b) => b,
-            #[cfg(bootstrap)]
-            Err(e) => match e {},
         }
     }
 
@@ -243,8 +241,6 @@ impl<T, A: Allocator> DoubleEndedIterator for IntoIter<T, A> {
     {
         match self.try_rfold(init, |b, item| Ok::<B, !>(f(b, item))) {
             Ok(b) => b,
-            #[cfg(bootstrap)]
-            Err(e) => match e {},
         }
     }
 }

core/src/arch.rs

@@ -4,15 +4,6 @@
 #[stable(feature = "simd_arch", since = "1.27.0")]
 pub use crate::core_arch::arch::*;
 
-#[cfg(bootstrap)]
-#[allow(dead_code)]
-#[unstable(feature = "sha512_sm_x86", issue = "126624")]
-fn dummy() {
-    // AArch64 also has a target feature named `sm4`, so we need `#![feature(sha512_sm_x86)]` in lib.rs
-    // But as the bootstrap compiler doesn't know about this feature yet, we need to convert it to a
-    // library feature until bootstrap gets bumped
-}
-
 /// Inline assembly.
 ///
 /// Refer to [Rust By Example] for a usage guide and the [reference] for

core/src/cell.rs

@@ -306,7 +306,7 @@ pub use once::OnceCell;
 /// See the [module-level documentation](self) for more.
 #[stable(feature = "rust1", since = "1.0.0")]
 #[repr(transparent)]
-#[cfg_attr(not(bootstrap), rustc_pub_transparent)]
+#[rustc_pub_transparent]
 pub struct Cell<T: ?Sized> {
     value: UnsafeCell<T>,
 }
@@ -2056,7 +2056,7 @@ impl<T: ?Sized + fmt::Display> fmt::Display for RefMut<'_, T> {
 #[lang = "unsafe_cell"]
 #[stable(feature = "rust1", since = "1.0.0")]
 #[repr(transparent)]
-#[cfg_attr(not(bootstrap), rustc_pub_transparent)]
+#[rustc_pub_transparent]
 pub struct UnsafeCell<T: ?Sized> {
     value: T,
 }
@@ -2299,7 +2299,7 @@ impl<T> UnsafeCell<*mut T> {
 /// See [`UnsafeCell`] for details.
 #[unstable(feature = "sync_unsafe_cell", issue = "95439")]
 #[repr(transparent)]
-#[cfg_attr(not(bootstrap), rustc_pub_transparent)]
+#[rustc_pub_transparent]
 pub struct SyncUnsafeCell<T: ?Sized> {
     value: UnsafeCell<T>,
 }

core/src/clone.rs

@@ -161,7 +161,7 @@ pub trait Clone: Sized {
     #[must_use = "cloning is often expensive and is not expected to have side effects"]
     // Clone::clone is special because the compiler generates MIR to implement it for some types.
     // See InstanceKind::CloneShim.
-    #[cfg_attr(not(bootstrap), lang = "clone_fn")]
+    #[lang = "clone_fn"]
     fn clone(&self) -> Self;
 
     /// Performs copy-assignment from `source`.

core/src/default.rs

@@ -103,7 +103,7 @@ use crate::ascii::Char as AsciiChar;
 /// ```
 #[cfg_attr(not(test), rustc_diagnostic_item = "Default")]
 #[stable(feature = "rust1", since = "1.0.0")]
-#[cfg_attr(not(bootstrap), rustc_trivial_field_reads)]
+#[rustc_trivial_field_reads]
 pub trait Default: Sized {
     /// Returns the "default value" for a type.
     ///

core/src/intrinsics.rs

@@ -1020,7 +1020,6 @@ pub const fn unlikely(b: bool) -> bool {
 /// any safety invariants.
 ///
 /// This intrinsic does not have a stable counterpart.
-#[cfg(not(bootstrap))]
 #[unstable(feature = "core_intrinsics", issue = "none")]
 #[rustc_intrinsic]
 #[rustc_nounwind]
@@ -1030,12 +1029,6 @@ pub fn select_unpredictable<T>(b: bool, true_val: T, false_val: T) -> T {
     if b { true_val } else { false_val }
 }
 
-#[cfg(bootstrap)]
-#[inline]
-pub fn select_unpredictable<T>(b: bool, true_val: T, false_val: T) -> T {
-    if b { true_val } else { false_val }
-}
-
 extern "rust-intrinsic" {
     /// Executes a breakpoint trap, for inspection by a debugger.
     ///

core/src/lib.rs

@@ -107,7 +107,6 @@
 //
 // Library features:
 // tidy-alphabetical-start
-#![cfg_attr(bootstrap, feature(offset_of_nested))]
 #![feature(array_ptr_get)]
 #![feature(asm_experimental_arch)]
 #![feature(const_align_of_val)]
@@ -192,9 +191,6 @@
 //
 // Language features:
 // tidy-alphabetical-start
-#![cfg_attr(bootstrap, feature(asm_const))]
-#![cfg_attr(bootstrap, feature(const_fn_floating_point_arithmetic))]
-#![cfg_attr(bootstrap, feature(min_exhaustive_patterns))]
 #![feature(abi_unadjusted)]
 #![feature(adt_const_params)]
 #![feature(allow_internal_unsafe)]

core/src/marker.rs

@@ -992,7 +992,7 @@ pub macro ConstParamTy($item:item) {
     /* compiler built-in */
 }
 
-#[cfg_attr(not(bootstrap), lang = "unsized_const_param_ty")]
+#[lang = "unsized_const_param_ty"]
 #[unstable(feature = "unsized_const_params", issue = "95174")]
 #[diagnostic::on_unimplemented(message = "`{Self}` can't be used as a const parameter type")]
 /// A marker for types which can be used as types of `const` generic parameters.
@@ -1002,10 +1002,9 @@ pub macro ConstParamTy($item:item) {
 pub trait UnsizedConstParamTy: StructuralPartialEq + Eq {}
 
 /// Derive macro generating an impl of the trait `ConstParamTy`.
-#[cfg(not(bootstrap))]
-#[cfg_attr(not(bootstrap), rustc_builtin_macro)]
-#[cfg_attr(not(bootstrap), allow_internal_unstable(unsized_const_params))]
-#[cfg_attr(not(bootstrap), unstable(feature = "unsized_const_params", issue = "95174"))]
+#[rustc_builtin_macro]
+#[allow_internal_unstable(unsized_const_params)]
+#[unstable(feature = "unsized_const_params", issue = "95174")]
 pub macro UnsizedConstParamTy($item:item) {
     /* compiler built-in */
 }
@@ -1021,14 +1020,6 @@ marker_impls! {
         (),
         {T: ConstParamTy_, const N: usize} [T; N],
 }
-#[cfg(bootstrap)]
-marker_impls! {
-    #[unstable(feature = "adt_const_params", issue = "95174")]
-    ConstParamTy_ for
-        str,
-        {T: ConstParamTy_} [T],
-        {T: ConstParamTy_ + ?Sized} &T,
-}
 
 marker_impls! {
     #[unstable(feature = "unsized_const_params", issue = "95174")]

core/src/mem/manually_drop.rs

@@ -47,7 +47,7 @@ use crate::ptr;
 #[lang = "manually_drop"]
 #[derive(Copy, Clone, Debug, Default, PartialEq, Eq, PartialOrd, Ord, Hash)]
 #[repr(transparent)]
-#[cfg_attr(not(bootstrap), rustc_pub_transparent)]
+#[rustc_pub_transparent]
 pub struct ManuallyDrop<T: ?Sized> {
     value: T,
 }

core/src/mem/maybe_uninit.rs

@@ -237,7 +237,7 @@ use crate::{fmt, intrinsics, ptr, slice};
 #[lang = "maybe_uninit"]
 #[derive(Copy)]
 #[repr(transparent)]
-#[cfg_attr(not(bootstrap), rustc_pub_transparent)]
+#[rustc_pub_transparent]
 pub union MaybeUninit<T> {
     uninit: (),
     value: ManuallyDrop<T>,

core/src/mem/mod.rs

@@ -1326,7 +1326,6 @@ impl<T> SizedTypeProperties for T {}
 /// # Examples
 ///
 /// ```
-/// # #![cfg_attr(bootstrap, feature(offset_of_nested))]
 /// #![feature(offset_of_enum)]
 ///
 /// use std::mem;

core/src/mem/transmutability.rs

@@ -43,8 +43,7 @@ use crate::marker::{ConstParamTy_, UnsizedConstParamTy};
 /// conversions that extend the bits of `Src` with trailing padding to fill
 /// trailing uninitialized bytes of `Self`; e.g.:
 ///
-#[cfg_attr(bootstrap, doc = "```rust,ignore not runnable on bootstrap")]
-#[cfg_attr(not(bootstrap), doc = "```rust")]
+/// ```rust
 /// #![feature(transmutability)]
 ///
 /// use core::mem::{Assume, TransmuteFrom};
@@ -151,8 +150,7 @@ pub struct Assume {
     /// When `false`, [`TransmuteFrom`] is not implemented for transmutations
     /// that might violate the alignment requirements of references; e.g.:
     ///
-    #[cfg_attr(bootstrap, doc = "```rust,ignore not runnable on bootstrap")]
-    #[cfg_attr(not(bootstrap), doc = "```compile_fail,E0277")]
+    /// ```compile_fail,E0277
     /// #![feature(transmutability)]
     /// use core::mem::{align_of, TransmuteFrom};
     ///
@@ -171,8 +169,7 @@ pub struct Assume {
     /// that references in the transmuted value satisfy the alignment
     /// requirements of their referent types; e.g.:
     ///
-    #[cfg_attr(bootstrap, doc = "```rust,ignore not runnable on bootstrap")]
-    #[cfg_attr(not(bootstrap), doc = "```rust")]
+    /// ```rust
     /// #![feature(pointer_is_aligned_to, transmutability)]
     /// use core::mem::{align_of, Assume, TransmuteFrom};
     ///
@@ -203,8 +200,7 @@ pub struct Assume {
     /// that might violate the library safety invariants of the destination
     /// type; e.g.:
     ///
-    #[cfg_attr(bootstrap, doc = "```rust,ignore not runnable on bootstrap")]
-    #[cfg_attr(not(bootstrap), doc = "```compile_fail,E0277")]
+    /// ```compile_fail,E0277
     /// #![feature(transmutability)]
     /// use core::mem::TransmuteFrom;
     ///
@@ -225,8 +221,7 @@ pub struct Assume {
     /// that undefined behavior does not arise from using the transmuted value;
     /// e.g.:
     ///
-    #[cfg_attr(bootstrap, doc = "```rust,ignore not runnable on bootstrap")]
-    #[cfg_attr(not(bootstrap), doc = "```rust")]
+    /// ```rust
     /// #![feature(transmutability)]
     /// use core::mem::{Assume, TransmuteFrom};
     ///
@@ -254,8 +249,7 @@ pub struct Assume {
     /// that might violate the language-level bit-validity invariant of the
     /// destination type; e.g.:
     ///
-    #[cfg_attr(bootstrap, doc = "```rust,ignore not runnable on bootstrap")]
-    #[cfg_attr(not(bootstrap), doc = "```compile_fail,E0277")]
+    /// ```compile_fail,E0277
     /// #![feature(transmutability)]
     /// use core::mem::TransmuteFrom;
     ///
@@ -271,8 +265,7 @@ pub struct Assume {
     /// that the value being transmuted is a bit-valid instance of the
     /// transmuted value; e.g.:
     ///
-    #[cfg_attr(bootstrap, doc = "```rust,ignore not runnable on bootstrap")]
-    #[cfg_attr(not(bootstrap), doc = "```rust")]
+    /// ```rust
     /// #![feature(transmutability)]
     /// use core::mem::{Assume, TransmuteFrom};
     ///
@@ -335,9 +328,7 @@ impl Assume {
     /// This is especially useful for extending [`Assume`] in generic contexts;
     /// e.g.:
     ///
-    #[cfg_attr(bootstrap, doc = "```rust,ignore not runnable on bootstrap")]
-    #[cfg_attr(not(bootstrap), doc = "```rust")]
-    #[unstable(feature = "transmutability", issue = "99571")]
+    /// ```rust
     /// #![feature(
     ///     adt_const_params,
     ///     generic_const_exprs,
@@ -379,6 +370,7 @@ impl Assume {
     ///     try_transmute_ref::<_, _, { Assume::NOTHING }>(src)
     /// };
     ///```
+    #[unstable(feature = "transmutability", issue = "99571")]
     pub const fn and(self, other_assumptions: Self) -> Self {
         Self {
             alignment: self.alignment || other_assumptions.alignment,
@@ -390,8 +382,7 @@ impl Assume {
 
     /// Remove `other_assumptions` the obligations of `self`; e.g.:
     ///
-    #[cfg_attr(bootstrap, doc = "```rust,ignore not runnable on bootstrap")]
-    #[cfg_attr(not(bootstrap), doc = "```rust")]
+    /// ```rust
     /// #![feature(transmutability)]
     /// use core::mem::Assume;
     ///

core/src/pin.rs

@@ -1084,7 +1084,7 @@ use crate::{cmp, fmt};
 #[lang = "pin"]
 #[fundamental]
 #[repr(transparent)]
-#[cfg_attr(not(bootstrap), rustc_pub_transparent)]
+#[rustc_pub_transparent]
 #[derive(Copy, Clone)]
 pub struct Pin<Ptr> {
     // FIXME(#93176): this field is made `#[unstable] #[doc(hidden)] pub` to:

core/src/tuple.rs

@@ -154,7 +154,7 @@ macro_rules! tuple_impls {
 // Otherwise, it hides the docs entirely.
 macro_rules! maybe_tuple_doc {
     ($a:ident @ #[$meta:meta] $item:item) => {
-        #[cfg_attr(not(bootstrap), doc(fake_variadic))]
+        #[doc(fake_variadic)]
         #[doc = "This trait is implemented for tuples up to twelve items long."]
         #[$meta]
         $item

core/tests/lib.rs

@@ -1,5 +1,4 @@
 // tidy-alphabetical-start
-#![cfg_attr(bootstrap, feature(offset_of_nested))]
 #![cfg_attr(target_has_atomic = "128", feature(integer_atomics))]
 #![cfg_attr(test, feature(cfg_match))]
 #![feature(alloc_layout_extra)]

panic_unwind/src/seh.rs

@@ -157,9 +157,6 @@ mod imp {
             // going to be cross-lang LTOed anyway. However, using expose is shorter and
             // requires less unsafe.
             let addr: usize = ptr.expose_provenance();
-            #[cfg(bootstrap)]
-            let image_base = unsafe { addr_of!(__ImageBase) }.addr();
-            #[cfg(not(bootstrap))]
             let image_base = addr_of!(__ImageBase).addr();
             let offset: usize = addr - image_base;
             Self(offset as u32)
@@ -253,9 +250,6 @@ extern "C" {
 // This is fine since the MSVC runtime uses string comparison on the type name
 // to match TypeDescriptors rather than pointer equality.
 static mut TYPE_DESCRIPTOR: _TypeDescriptor = _TypeDescriptor {
-    #[cfg(bootstrap)]
-    pVFTable: unsafe { addr_of!(TYPE_INFO_VTABLE) } as *const _,
-    #[cfg(not(bootstrap))]
     pVFTable: addr_of!(TYPE_INFO_VTABLE) as *const _,
     spare: core::ptr::null_mut(),
     name: TYPE_NAME,

std/src/env.rs

@@ -354,12 +354,8 @@ impl Error for VarError {
 /// }
 /// assert_eq!(env::var(key), Ok("VALUE".to_string()));
 /// ```
-#[cfg_attr(bootstrap, rustc_deprecated_safe_2024)]
-#[cfg_attr(
-    not(bootstrap),
-    rustc_deprecated_safe_2024(
-        audit_that = "the environment access only happens in single-threaded code"
-    )
+#[rustc_deprecated_safe_2024(
+    audit_that = "the environment access only happens in single-threaded code"
 )]
 #[stable(feature = "env", since = "1.0.0")]
 pub unsafe fn set_var<K: AsRef<OsStr>, V: AsRef<OsStr>>(key: K, value: V) {
@@ -424,12 +420,8 @@ pub unsafe fn set_var<K: AsRef<OsStr>, V: AsRef<OsStr>>(key: K, value: V) {
 /// }
 /// assert!(env::var(key).is_err());
 /// ```
-#[cfg_attr(bootstrap, rustc_deprecated_safe_2024)]
-#[cfg_attr(
-    not(bootstrap),
-    rustc_deprecated_safe_2024(
-        audit_that = "the environment access only happens in single-threaded code"
-    )
+#[rustc_deprecated_safe_2024(
+    audit_that = "the environment access only happens in single-threaded code"
 )]
 #[stable(feature = "env", since = "1.0.0")]
 pub unsafe fn remove_var<K: AsRef<OsStr>>(key: K) {

std/src/lib.rs

@@ -272,7 +272,6 @@
 //
 // Language features:
 // tidy-alphabetical-start
-#![cfg_attr(bootstrap, feature(min_exhaustive_patterns))]
 #![feature(alloc_error_handler)]
 #![feature(allocator_internals)]
 #![feature(allow_internal_unsafe)]

std/src/os/unix/process.rs

@@ -118,11 +118,7 @@ pub trait CommandExt: Sealed {
     /// [`pre_exec`]: CommandExt::pre_exec
     #[stable(feature = "process_exec", since = "1.15.0")]
     #[deprecated(since = "1.37.0", note = "should be unsafe, use `pre_exec` instead")]
-    #[cfg_attr(bootstrap, rustc_deprecated_safe_2024)]
-    #[cfg_attr(
-        not(bootstrap),
-        rustc_deprecated_safe_2024(audit_that = "the closure is async-signal-safe")
-    )]
+    #[rustc_deprecated_safe_2024(audit_that = "the closure is async-signal-safe")]
     unsafe fn before_exec<F>(&mut self, f: F) -> &mut process::Command
     where
         F: FnMut() -> io::Result<()> + Send + Sync + 'static,