update cfg(bootstrap)

Author: cuviper

alloc/src/boxed.rs

@@ -237,23 +237,13 @@ pub struct Box<
 /// the newly allocated memory. This is an intrinsic to avoid unnecessary copies.
 ///
 /// This is the surface syntax for `box <expr>` expressions.
-#[cfg(not(bootstrap))]
 #[rustc_intrinsic]
 #[rustc_intrinsic_must_be_overridden]
 #[unstable(feature = "liballoc_internals", issue = "none")]
 pub fn box_new<T>(_x: T) -> Box<T> {
     unreachable!()
 }
 
-/// Transition function for the next bootstrap bump.
-#[cfg(bootstrap)]
-#[unstable(feature = "liballoc_internals", issue = "none")]
-#[inline(always)]
-pub fn box_new<T>(x: T) -> Box<T> {
-    #[rustc_box]
-    Box::new(x)
-}
-
 impl<T> Box<T> {
     /// Allocates memory on the heap and then places `x` into it.
     ///

core/src/contracts.rs

@@ -1,5 +1,4 @@
 //! Unstable module containing the unstable contracts lang items and attribute macros.
-#![cfg(not(bootstrap))]
 
 pub use crate::macros::builtin::{contracts_ensures as ensures, contracts_requires as requires};
 

core/src/intrinsics/mod.rs

@@ -78,11 +78,7 @@ pub mod simd;
 use crate::sync::atomic::{self, AtomicBool, AtomicI32, AtomicIsize, AtomicU32, Ordering};
 
 #[stable(feature = "drop_in_place", since = "1.8.0")]
-#[cfg_attr(bootstrap, rustc_allowed_through_unstable_modules)]
-#[cfg_attr(
-    not(bootstrap),
-    rustc_allowed_through_unstable_modules = "import this function via `std::ptr` instead"
-)]
+#[rustc_allowed_through_unstable_modules = "import this function via `std::ptr` instead"]
 #[deprecated(note = "no longer an intrinsic - use `ptr::drop_in_place` directly", since = "1.52.0")]
 #[inline]
 pub unsafe fn drop_in_place<T: ?Sized>(to_drop: *mut T) {
@@ -1901,11 +1897,7 @@ pub const fn forget<T: ?Sized>(_: T) {
 /// }
 /// ```
 #[stable(feature = "rust1", since = "1.0.0")]
-#[cfg_attr(bootstrap, rustc_allowed_through_unstable_modules)]
-#[cfg_attr(
-    not(bootstrap),
-    rustc_allowed_through_unstable_modules = "import this function via `std::mem` instead"
-)]
+#[rustc_allowed_through_unstable_modules = "import this function via `std::mem` instead"]
 #[rustc_const_stable(feature = "const_transmute", since = "1.56.0")]
 #[rustc_diagnostic_item = "transmute"]
 #[rustc_nounwind]
@@ -3260,7 +3252,7 @@ pub const fn three_way_compare<T: Copy>(_lhs: T, _rhss: T) -> crate::cmp::Orderi
 /// Otherwise it's immediate UB.
 #[rustc_const_unstable(feature = "disjoint_bitor", issue = "135758")]
 #[rustc_nounwind]
-#[cfg_attr(not(bootstrap), rustc_intrinsic)]
+#[rustc_intrinsic]
 #[cfg_attr(miri, track_caller)] // even without panics, this helps for Miri backtraces
 #[miri::intrinsic_fallback_is_spec] // the fallbacks all `assume` to tell Miri
 pub const unsafe fn disjoint_bitor<T: ~const fallback::DisjointBitOr>(a: T, b: T) -> T {
@@ -4071,7 +4063,6 @@ pub const unsafe fn const_deallocate(_ptr: *mut u8, _size: usize, _align: usize)
 /// of not prematurely commiting at compile-time to whether contract
 /// checking is turned on, so that we can specify contracts in libstd
 /// and let an end user opt into turning them on.
-#[cfg(not(bootstrap))]
 #[rustc_const_unstable(feature = "contracts_internals", issue = "128044" /* compiler-team#759 */)]
 #[unstable(feature = "contracts_internals", issue = "128044" /* compiler-team#759 */)]
 #[inline(always)]
@@ -4087,7 +4078,6 @@ pub const fn contract_checks() -> bool {
 ///
 /// By default, if `contract_checks` is enabled, this will panic with no unwind if the condition
 /// returns false.
-#[cfg(not(bootstrap))]
 #[unstable(feature = "contracts_internals", issue = "128044" /* compiler-team#759 */)]
 #[lang = "contract_check_requires"]
 #[rustc_intrinsic]
@@ -4102,7 +4092,6 @@ pub fn contract_check_requires<C: Fn() -> bool>(cond: C) {
 ///
 /// By default, if `contract_checks` is enabled, this will panic with no unwind if the condition
 /// returns false.
-#[cfg(not(bootstrap))]
 #[unstable(feature = "contracts_internals", issue = "128044" /* compiler-team#759 */)]
 #[rustc_intrinsic]
 pub fn contract_check_ensures<'a, Ret, C: Fn(&'a Ret) -> bool>(ret: &'a Ret, cond: C) {
@@ -4401,11 +4390,7 @@ pub const fn ptr_metadata<P: ptr::Pointee<Metadata = M> + ?Sized, M>(_ptr: *cons
 /// [`Vec::append`]: ../../std/vec/struct.Vec.html#method.append
 #[doc(alias = "memcpy")]
 #[stable(feature = "rust1", since = "1.0.0")]
-#[cfg_attr(bootstrap, rustc_allowed_through_unstable_modules)]
-#[cfg_attr(
-    not(bootstrap),
-    rustc_allowed_through_unstable_modules = "import this function via `std::mem` instead"
-)]
+#[rustc_allowed_through_unstable_modules = "import this function via `std::mem` instead"]
 #[rustc_const_stable(feature = "const_intrinsic_copy", since = "1.83.0")]
 #[inline(always)]
 #[cfg_attr(miri, track_caller)] // even without panics, this helps for Miri backtraces
@@ -4509,11 +4494,7 @@ pub const unsafe fn copy_nonoverlapping<T>(src: *const T, dst: *mut T, count: us
 /// ```
 #[doc(alias = "memmove")]
 #[stable(feature = "rust1", since = "1.0.0")]
-#[cfg_attr(bootstrap, rustc_allowed_through_unstable_modules)]
-#[cfg_attr(
-    not(bootstrap),
-    rustc_allowed_through_unstable_modules = "import this function via `std::mem` instead"
-)]
+#[rustc_allowed_through_unstable_modules = "import this function via `std::mem` instead"]
 #[rustc_const_stable(feature = "const_intrinsic_copy", since = "1.83.0")]
 #[inline(always)]
 #[cfg_attr(miri, track_caller)] // even without panics, this helps for Miri backtraces
@@ -4596,11 +4577,7 @@ pub const unsafe fn copy<T>(src: *const T, dst: *mut T, count: usize) {
 /// ```
 #[doc(alias = "memset")]
 #[stable(feature = "rust1", since = "1.0.0")]
-#[cfg_attr(bootstrap, rustc_allowed_through_unstable_modules)]
-#[cfg_attr(
-    not(bootstrap),
-    rustc_allowed_through_unstable_modules = "import this function via `std::mem` instead"
-)]
+#[rustc_allowed_through_unstable_modules = "import this function via `std::mem` instead"]
 #[rustc_const_stable(feature = "const_ptr_write", since = "1.83.0")]
 #[inline(always)]
 #[cfg_attr(miri, track_caller)] // even without panics, this helps for Miri backtraces

core/src/lib.rs

@@ -247,7 +247,6 @@ pub mod autodiff {
     pub use crate::macros::builtin::autodiff;
 }
 
-#[cfg(not(bootstrap))]
 #[unstable(feature = "contracts", issue = "128044")]
 pub mod contracts;
 

core/src/macros/mod.rs

@@ -196,95 +196,6 @@ pub macro assert_matches {
     },
 }
 
-/// A macro for defining `#[cfg]` match-like statements.
-///
-/// It is similar to the `if/elif` C preprocessor macro by allowing definition of a cascade of
-/// `#[cfg]` cases, emitting the implementation which matches first.
-///
-/// This allows you to conveniently provide a long list `#[cfg]`'d blocks of code
-/// without having to rewrite each clause multiple times.
-///
-/// Trailing `_` wildcard match arms are **optional** and they indicate a fallback branch when
-/// all previous declarations do not evaluate to true.
-///
-/// # Example
-///
-/// ```
-/// #![feature(cfg_match)]
-///
-/// cfg_match! {
-///     cfg(unix) => {
-///         fn foo() { /* unix specific functionality */ }
-///     }
-///     cfg(target_pointer_width = "32") => {
-///         fn foo() { /* non-unix, 32-bit functionality */ }
-///     }
-///     _ => {
-///         fn foo() { /* fallback implementation */ }
-///     }
-/// }
-/// ```
-#[cfg(bootstrap)]
-#[unstable(feature = "cfg_match", issue = "115585")]
-#[rustc_diagnostic_item = "cfg_match"]
-pub macro cfg_match {
-    // with a final wildcard
-    (
-        $(cfg($initial_meta:meta) => { $($initial_tokens:tt)* })+
-        _ => { $($extra_tokens:tt)* }
-    ) => {
-        cfg_match! {
-            @__items ();
-            $((($initial_meta) ($($initial_tokens)*)),)+
-            (() ($($extra_tokens)*)),
-        }
-    },
-
-    // without a final wildcard
-    (
-        $(cfg($extra_meta:meta) => { $($extra_tokens:tt)* })*
-    ) => {
-        cfg_match! {
-            @__items ();
-            $((($extra_meta) ($($extra_tokens)*)),)*
-        }
-    },
-
-    // Internal and recursive macro to emit all the items
-    //
-    // Collects all the previous cfgs in a list at the beginning, so they can be
-    // negated. After the semicolon is all the remaining items.
-    (@__items ($($_:meta,)*);) => {},
-    (
-        @__items ($($no:meta,)*);
-        (($($yes:meta)?) ($($tokens:tt)*)),
-        $($rest:tt,)*
-    ) => {
-        // Emit all items within one block, applying an appropriate #[cfg]. The
-        // #[cfg] will require all `$yes` matchers specified and must also negate
-        // all previous matchers.
-        #[cfg(all(
-            $($yes,)?
-            not(any($($no),*))
-        ))]
-        cfg_match! { @__identity $($tokens)* }
-
-        // Recurse to emit all other items in `$rest`, and when we do so add all
-        // our `$yes` matchers to the list of `$no` matchers as future emissions
-        // will have to negate everything we just matched as well.
-        cfg_match! {
-            @__items ($($no,)* $($yes,)?);
-            $($rest,)*
-        }
-    },
-
-    // Internal macro to make __apply work out right for different match types,
-    // because of how macros match/expand stuff.
-    (@__identity $($tokens:tt)*) => {
-        $($tokens)*
-    }
-}
-
 /// A macro for defining `#[cfg]` match-like statements.
 ///
 /// It is similar to the `if/elif` C preprocessor macro by allowing definition of a cascade of
@@ -324,7 +235,6 @@ pub macro cfg_match {
 ///     _ => { "Behind every successful diet is an unwatched pizza" }
 /// }};
 /// ```
-#[cfg(not(bootstrap))]
 #[unstable(feature = "cfg_match", issue = "115585")]
 #[rustc_diagnostic_item = "cfg_match"]
 pub macro cfg_match {
@@ -1782,7 +1692,6 @@ pub(crate) mod builtin {
     /// The attribute carries an argument token-tree which is
     /// eventually parsed as a unary closure expression that is
     /// invoked on a reference to the return value.
-    #[cfg(not(bootstrap))]
     #[unstable(feature = "contracts", issue = "128044")]
     #[allow_internal_unstable(contracts_internals)]
     #[rustc_builtin_macro]
@@ -1795,7 +1704,6 @@ pub(crate) mod builtin {
     /// The attribute carries an argument token-tree which is
     /// eventually parsed as an boolean expression with access to the
     /// function's formal parameters
-    #[cfg(not(bootstrap))]
     #[unstable(feature = "contracts", issue = "128044")]
     #[allow_internal_unstable(contracts_internals)]
     #[rustc_builtin_macro]

core/src/marker.rs

@@ -467,7 +467,7 @@ impl<T: ?Sized> Copy for &T {}
 ///
 /// Bikeshed name for now.
 #[unstable(feature = "bikeshed_guaranteed_no_drop", issue = "none")]
-#[cfg_attr(not(bootstrap), lang = "bikeshed_guaranteed_no_drop")]
+#[lang = "bikeshed_guaranteed_no_drop"]
 pub trait BikeshedGuaranteedNoDrop {}
 
 /// Types for which it is safe to share references between threads.
@@ -1313,7 +1313,6 @@ pub macro CoercePointee($item:item) {
 ///
 /// This trait is not intended to be implemented by users or used other than
 /// validation, so it should never be stabilized.
-#[cfg(not(bootstrap))]
 #[lang = "coerce_pointee_validated"]
 #[unstable(feature = "coerce_pointee_validated", issue = "none")]
 #[doc(hidden)]

core/src/panicking.rs

@@ -294,7 +294,7 @@ fn panic_misaligned_pointer_dereference(required: usize, found: usize) -> ! {
 #[cfg_attr(not(feature = "panic_immediate_abort"), inline(never), cold, optimize(size))]
 #[cfg_attr(feature = "panic_immediate_abort", inline)]
 #[track_caller]
-#[cfg_attr(not(bootstrap), lang = "panic_null_pointer_dereference")] // needed by codegen for panic on null pointer deref
+#[lang = "panic_null_pointer_dereference"] // needed by codegen for panic on null pointer deref
 #[rustc_nounwind] // `CheckNull` MIR pass requires this function to never unwind
 fn panic_null_pointer_dereference() -> ! {
     if cfg!(feature = "panic_immediate_abort") {

core/src/range.rs

@@ -50,7 +50,7 @@ pub use crate::ops::{
 /// assert_eq!(Range::from(3..5), Range { start: 3, end: 5 });
 /// assert_eq!(3 + 4 + 5, Range::from(3..6).into_iter().sum());
 /// ```
-#[cfg_attr(not(bootstrap), lang = "RangeCopy")]
+#[lang = "RangeCopy"]
 #[derive(Clone, Copy, Default, PartialEq, Eq, Hash)]
 #[unstable(feature = "new_range_api", issue = "125687")]
 pub struct Range<Idx> {
@@ -216,7 +216,7 @@ impl<T> From<legacy::Range<T>> for Range<T> {
 /// assert_eq!(RangeInclusive::from(3..=5), RangeInclusive { start: 3, end: 5 });
 /// assert_eq!(3 + 4 + 5, RangeInclusive::from(3..=5).into_iter().sum());
 /// ```
-#[cfg_attr(not(bootstrap), lang = "RangeInclusiveCopy")]
+#[lang = "RangeInclusiveCopy"]
 #[derive(Clone, Copy, PartialEq, Eq, Hash)]
 #[unstable(feature = "new_range_api", issue = "125687")]
 pub struct RangeInclusive<Idx> {
@@ -408,7 +408,7 @@ impl<T> From<legacy::RangeInclusive<T>> for RangeInclusive<T> {
 /// assert_eq!(RangeFrom::from(2..), core::range::RangeFrom { start: 2 });
 /// assert_eq!(2 + 3 + 4, RangeFrom::from(2..).into_iter().take(3).sum());
 /// ```
-#[cfg_attr(not(bootstrap), lang = "RangeFromCopy")]
+#[lang = "RangeFromCopy"]
 #[derive(Clone, Copy, PartialEq, Eq, Hash)]
 #[unstable(feature = "new_range_api", issue = "125687")]
 pub struct RangeFrom<Idx> {

coretests/tests/lib.rs

@@ -153,10 +153,7 @@ mod intrinsics;
 mod io;
 mod iter;
 mod lazy;
-#[cfg(not(bootstrap))]
 mod macros;
-#[cfg(bootstrap)]
-mod macros_bootstrap;
 mod manually_drop;
 mod mem;
 mod net;