update cfgs

Author: BoxyUwU

Diff for: alloc/src/alloc.rs

@@ -16,22 +16,22 @@ unsafe extern "Rust" {
     // otherwise.
     #[rustc_allocator]
     #[rustc_nounwind]
-    #[cfg_attr(not(bootstrap), rustc_std_internal_symbol)]
+    #[rustc_std_internal_symbol]
     fn __rust_alloc(size: usize, align: usize) -> *mut u8;
     #[rustc_deallocator]
     #[rustc_nounwind]
-    #[cfg_attr(not(bootstrap), rustc_std_internal_symbol)]
+    #[rustc_std_internal_symbol]
     fn __rust_dealloc(ptr: *mut u8, size: usize, align: usize);
     #[rustc_reallocator]
     #[rustc_nounwind]
-    #[cfg_attr(not(bootstrap), rustc_std_internal_symbol)]
+    #[rustc_std_internal_symbol]
     fn __rust_realloc(ptr: *mut u8, old_size: usize, align: usize, new_size: usize) -> *mut u8;
     #[rustc_allocator_zeroed]
     #[rustc_nounwind]
-    #[cfg_attr(not(bootstrap), rustc_std_internal_symbol)]
+    #[rustc_std_internal_symbol]
     fn __rust_alloc_zeroed(size: usize, align: usize) -> *mut u8;
 
-    #[cfg_attr(not(bootstrap), rustc_std_internal_symbol)]
+    #[rustc_std_internal_symbol]
     static __rust_no_alloc_shim_is_unstable: u8;
 }
 
@@ -360,7 +360,7 @@ unsafe extern "Rust" {
     // This is the magic symbol to call the global alloc error handler. rustc generates
     // it to call `__rg_oom` if there is a `#[alloc_error_handler]`, or to call the
     // default implementations below (`__rdl_oom`) otherwise.
-    #[cfg_attr(not(bootstrap), rustc_std_internal_symbol)]
+    #[rustc_std_internal_symbol]
     fn __rust_alloc_error_handler(size: usize, align: usize) -> !;
 }
 
@@ -427,7 +427,7 @@ pub mod __alloc_error_handler {
         unsafe extern "Rust" {
             // This symbol is emitted by rustc next to __rust_alloc_error_handler.
             // Its value depends on the -Zoom={panic,abort} compiler option.
-            #[cfg_attr(not(bootstrap), rustc_std_internal_symbol)]
+            #[rustc_std_internal_symbol]
             static __rust_alloc_error_handler_should_panic: u8;
         }
 

Diff for: core/Cargo.toml

@@ -32,8 +32,6 @@ check-cfg = [
     'cfg(bootstrap)',
     'cfg(no_fp_fmt_parse)',
     'cfg(stdarch_intel_sde)',
-    # #[cfg(bootstrap)]
-    'cfg(target_feature, values("vector-enhancements-1"))',
     # core use #[path] imports to portable-simd `core_simd` crate
     # and to stdarch `core_arch` crate which messes-up with Cargo list
     # of declared features, we therefor expect any feature cfg

Diff for: core/src/clone.rs

@@ -216,7 +216,7 @@ pub macro Clone($item:item) {
 /// Use closures allow captured values to be automatically used.
 /// This is similar to have a closure that you would call `.use` over each captured value.
 #[unstable(feature = "ergonomic_clones", issue = "132290")]
-#[cfg_attr(not(bootstrap), lang = "use_cloned")]
+#[lang = "use_cloned"]
 pub trait UseCloned: Clone {
     // Empty.
 }

Diff for: core/src/fmt/mod.rs

@@ -1515,19 +1515,6 @@ unsafe fn run(fmt: &mut Formatter<'_>, arg: &rt::Placeholder, args: &[rt::Argume
         // which guarantees the indexes are always within bounds.
         unsafe { (getcount(args, &arg.width), getcount(args, &arg.precision)) };
 
-    #[cfg(bootstrap)]
-    let options =
-        *FormattingOptions { flags: flags::ALWAYS_SET | arg.flags << 21, width: 0, precision: 0 }
-            .align(match arg.align {
-                rt::Alignment::Left => Some(Alignment::Left),
-                rt::Alignment::Right => Some(Alignment::Right),
-                rt::Alignment::Center => Some(Alignment::Center),
-                rt::Alignment::Unknown => None,
-            })
-            .fill(arg.fill)
-            .width(width)
-            .precision(precision);
-    #[cfg(not(bootstrap))]
     let options = FormattingOptions { flags: arg.flags, width, precision };
 
     // Extract the correct argument
@@ -1544,21 +1531,6 @@ unsafe fn run(fmt: &mut Formatter<'_>, arg: &rt::Placeholder, args: &[rt::Argume
     unsafe { value.fmt(fmt) }
 }
 
-#[cfg(bootstrap)]
-unsafe fn getcount(args: &[rt::Argument<'_>], cnt: &rt::Count) -> Option<u16> {
-    match *cnt {
-        rt::Count::Is(n) => Some(n as u16),
-        rt::Count::Implied => None,
-        rt::Count::Param(i) => {
-            debug_assert!(i < args.len());
-            // SAFETY: cnt and args come from the same Arguments,
-            // which guarantees this index is always within bounds.
-            unsafe { args.get_unchecked(i).as_u16() }
-        }
-    }
-}
-
-#[cfg(not(bootstrap))]
 unsafe fn getcount(args: &[rt::Argument<'_>], cnt: &rt::Count) -> u16 {
     match *cnt {
         rt::Count::Is(n) => n,

Diff for: core/src/fmt/rt.rs

@@ -11,10 +11,6 @@ use crate::ptr::NonNull;
 #[derive(Copy, Clone)]
 pub struct Placeholder {
     pub position: usize,
-    #[cfg(bootstrap)]
-    pub fill: char,
-    #[cfg(bootstrap)]
-    pub align: Alignment,
     pub flags: u32,
     pub precision: Count,
     pub width: Count,
@@ -23,38 +19,17 @@ pub struct Placeholder {
 #[cfg(bootstrap)]
 impl Placeholder {
     #[inline]
-    pub const fn new(
-        position: usize,
-        fill: char,
-        align: Alignment,
-        flags: u32,
-        precision: Count,
-        width: Count,
-    ) -> Self {
-        Self { position, fill, align, flags, precision, width }
+    pub const fn new(position: usize, flags: u32, precision: Count, width: Count) -> Self {
+        Self { position, flags, precision, width }
     }
 }
 
-#[cfg(bootstrap)]
-#[lang = "format_alignment"]
-#[derive(Copy, Clone, PartialEq, Eq)]
-pub enum Alignment {
-    Left,
-    Right,
-    Center,
-    Unknown,
-}
-
 /// Used by [width](https://doc.rust-lang.org/std/fmt/#width)
 /// and [precision](https://doc.rust-lang.org/std/fmt/#precision) specifiers.
 #[lang = "format_count"]
 #[derive(Copy, Clone)]
 pub enum Count {
     /// Specified with a literal number, stores the value
-    #[cfg(bootstrap)]
-    Is(usize),
-    /// Specified with a literal number, stores the value
-    #[cfg(not(bootstrap))]
     Is(u16),
     /// Specified using `$` and `*` syntaxes, stores the index into `args`
     Param(usize),

Diff for: core/src/intrinsics/mod.rs

@@ -2304,41 +2304,17 @@ pub unsafe fn truncf128(x: f128) -> f128;
 /// [`f16::round_ties_even`](../../std/primitive.f16.html#method.round_ties_even)
 #[rustc_intrinsic]
 #[rustc_nounwind]
-#[cfg(not(bootstrap))]
 pub fn round_ties_even_f16(x: f16) -> f16;
 
-/// To be removed on next bootstrap bump.
-#[cfg(bootstrap)]
-pub fn round_ties_even_f16(x: f16) -> f16 {
-    #[rustc_intrinsic]
-    #[rustc_nounwind]
-    unsafe fn rintf16(x: f16) -> f16;
-
-    // SAFETY: this intrinsic isn't actually unsafe
-    unsafe { rintf16(x) }
-}
-
 /// Returns the nearest integer to an `f32`. Rounds half-way cases to the number with an even
 /// least significant digit.
 ///
 /// The stabilized version of this intrinsic is
 /// [`f32::round_ties_even`](../../std/primitive.f32.html#method.round_ties_even)
 #[rustc_intrinsic]
 #[rustc_nounwind]
-#[cfg(not(bootstrap))]
 pub fn round_ties_even_f32(x: f32) -> f32;
 
-/// To be removed on next bootstrap bump.
-#[cfg(bootstrap)]
-pub fn round_ties_even_f32(x: f32) -> f32 {
-    #[rustc_intrinsic]
-    #[rustc_nounwind]
-    unsafe fn rintf32(x: f32) -> f32;
-
-    // SAFETY: this intrinsic isn't actually unsafe
-    unsafe { rintf32(x) }
-}
-
 /// Provided for compatibility with stdarch. DO NOT USE.
 #[inline(always)]
 pub unsafe fn rintf32(x: f32) -> f32 {
@@ -2352,20 +2328,8 @@ pub unsafe fn rintf32(x: f32) -> f32 {
 /// [`f64::round_ties_even`](../../std/primitive.f64.html#method.round_ties_even)
 #[rustc_intrinsic]
 #[rustc_nounwind]
-#[cfg(not(bootstrap))]
 pub fn round_ties_even_f64(x: f64) -> f64;
 
-/// To be removed on next bootstrap bump.
-#[cfg(bootstrap)]
-pub fn round_ties_even_f64(x: f64) -> f64 {
-    #[rustc_intrinsic]
-    #[rustc_nounwind]
-    unsafe fn rintf64(x: f64) -> f64;
-
-    // SAFETY: this intrinsic isn't actually unsafe
-    unsafe { rintf64(x) }
-}
-
 /// Provided for compatibility with stdarch. DO NOT USE.
 #[inline(always)]
 pub unsafe fn rintf64(x: f64) -> f64 {
@@ -2379,20 +2343,8 @@ pub unsafe fn rintf64(x: f64) -> f64 {
 /// [`f128::round_ties_even`](../../std/primitive.f128.html#method.round_ties_even)
 #[rustc_intrinsic]
 #[rustc_nounwind]
-#[cfg(not(bootstrap))]
 pub fn round_ties_even_f128(x: f128) -> f128;
 
-/// To be removed on next bootstrap bump.
-#[cfg(bootstrap)]
-pub fn round_ties_even_f128(x: f128) -> f128 {
-    #[rustc_intrinsic]
-    #[rustc_nounwind]
-    unsafe fn rintf128(x: f128) -> f128;
-
-    // SAFETY: this intrinsic isn't actually unsafe
-    unsafe { rintf128(x) }
-}
-
 /// Returns the nearest integer to an `f16`. Rounds half-way cases away from zero.
 ///
 /// The stabilized version of this intrinsic is

Diff for: core/src/macros/mod.rs

@@ -1753,7 +1753,6 @@ pub(crate) mod builtin {
         reason = "`type_alias_impl_trait` has open design concerns"
     )]
     #[rustc_builtin_macro]
-    #[cfg(not(bootstrap))]
     pub macro define_opaque($($tt:tt)*) {
         /* compiler built-in */
     }

Diff for: core/src/pat.rs

@@ -25,15 +25,15 @@ macro_rules! pattern_type {
 )]
 pub trait RangePattern {
     /// Trait version of the inherent `MIN` assoc const.
-    #[cfg_attr(not(bootstrap), lang = "RangeMin")]
+    #[lang = "RangeMin"]
     const MIN: Self;
 
     /// Trait version of the inherent `MIN` assoc const.
-    #[cfg_attr(not(bootstrap), lang = "RangeMax")]
+    #[lang = "RangeMax"]
     const MAX: Self;
 
     /// A compile-time helper to subtract 1 for exclusive ranges.
-    #[cfg_attr(not(bootstrap), lang = "RangeSub")]
+    #[lang = "RangeSub"]
     #[track_caller]
     fn sub_one(self) -> Self;
 }

Diff for: core/src/pin.rs

@@ -1943,7 +1943,7 @@ unsafe impl<T: ?Sized> PinCoerceUnsized for *mut T {}
 #[stable(feature = "pin_macro", since = "1.68.0")]
 #[rustc_macro_transparency = "semitransparent"]
 #[allow_internal_unstable(unsafe_pin_internals)]
-#[cfg_attr(not(bootstrap), rustc_macro_edition_2021)]
+#[rustc_macro_edition_2021]
 pub macro pin($value:expr $(,)?) {
     // This is `Pin::new_unchecked(&mut { $value })`, so, for starters, let's
     // review such a hypothetical macro (that any user-code could define):

Diff for: core/src/prelude/v1.rs

@@ -117,5 +117,4 @@ pub use crate::macros::builtin::deref;
     issue = "63063",
     reason = "`type_alias_impl_trait` has open design concerns"
 )]
-#[cfg(not(bootstrap))]
 pub use crate::macros::builtin::define_opaque;

Diff for: coretests/tests/pin_macro.rs

@@ -38,7 +38,6 @@ fn rust_2024_expr() {
 }
 
 #[test]
-#[cfg(not(bootstrap))]
 fn temp_lifetime() {
     // Check that temporary lifetimes work as in Rust 2021.
     // Regression test for https://github.com/rust-lang/rust/issues/138596

Diff for: panic_unwind/src/lib.rs

@@ -79,11 +79,11 @@ cfg_if::cfg_if! {
 unsafe extern "C" {
     /// Handler in std called when a panic object is dropped outside of
     /// `catch_unwind`.
-    #[cfg_attr(not(bootstrap), rustc_std_internal_symbol)]
+    #[rustc_std_internal_symbol]
     fn __rust_drop_panic() -> !;
 
     /// Handler in std called when a foreign exception is caught.
-    #[cfg_attr(not(bootstrap), rustc_std_internal_symbol)]
+    #[rustc_std_internal_symbol]
     fn __rust_foreign_exception() -> !;
 }
 

Diff for: proc_macro/src/bridge/mod.rs

@@ -9,7 +9,6 @@
 #![deny(unsafe_code)]
 // proc_macros anyway don't work on wasm hosts so while both sides of this bridge can
 // be built with different versions of rustc, the wasm ABI changes don't really matter.
-#![cfg_attr(bootstrap, allow(unknown_lints))]
 #![allow(wasm_c_abi)]
 
 use std::hash::Hash;

Diff for: std/src/alloc.rs

@@ -348,7 +348,7 @@ fn default_alloc_error_hook(layout: Layout) {
     unsafe extern "Rust" {
         // This symbol is emitted by rustc next to __rust_alloc_error_handler.
         // Its value depends on the -Zoom={panic,abort} compiler option.
-        #[cfg_attr(not(bootstrap), rustc_std_internal_symbol)]
+        #[rustc_std_internal_symbol]
         static __rust_alloc_error_handler_should_panic: u8;
     }
 

Diff for: std/src/backtrace.rs

@@ -432,7 +432,7 @@ mod helper {
     use super::*;
     pub(super) type LazyResolve = impl (FnOnce() -> Capture) + Send + Sync + UnwindSafe;
 
-    #[cfg_attr(not(bootstrap), define_opaque(LazyResolve))]
+    #[define_opaque(LazyResolve)]
     pub(super) fn lazy_resolve(mut capture: Capture) -> LazyResolve {
         move || {
             // Use the global backtrace lock to synchronize this as it's a

Diff for: std/src/panicking.rs

@@ -55,14 +55,14 @@ pub static EMPTY_PANIC: fn(&'static str) -> ! =
 // hook up these functions, but it is not this day!
 #[allow(improper_ctypes)]
 unsafe extern "C" {
-    #[cfg_attr(not(bootstrap), rustc_std_internal_symbol)]
+    #[rustc_std_internal_symbol]
     fn __rust_panic_cleanup(payload: *mut u8) -> *mut (dyn Any + Send + 'static);
 }
 
 unsafe extern "Rust" {
     /// `PanicPayload` lazily performs allocation only when needed (this avoids
     /// allocations when using the "abort" panic runtime).
-    #[cfg_attr(not(bootstrap), rustc_std_internal_symbol)]
+    #[rustc_std_internal_symbol]
     fn __rust_start_panic(payload: &mut dyn PanicPayload) -> u32;
 }
 

Diff for: std/src/prelude/v1.rs

@@ -109,7 +109,6 @@ pub use core::prelude::v1::deref;
     issue = "63063",
     reason = "`type_alias_impl_trait` has open design concerns"
 )]
-#[cfg(not(bootstrap))]
 pub use core::prelude::v1::define_opaque;
 
 // The file so far is equivalent to core/src/prelude/v1.rs. It is duplicated