Step all bootstrap cfgs forward

Mark-Simulacrum · Mark-Simulacrum · commit 9a5034a20ed8 · 2024-02-08T07:44:34.000-05:00
This also takes care of other bootstrap-related changes.
diff --git a/compiler/rustc_index_macros/src/lib.rs b/compiler/rustc_index_macros/src/lib.rs
@@ -31,17 +31,17 @@ mod newtype;
 /// - `#[max = 0xFFFF_FFFD]`: specifies the max value, which allows niche
 ///   optimizations. The default max value is 0xFFFF_FF00.
 /// - `#[gate_rustc_only]`: makes parts of the generated code nightly-only.
-///
-/// `SpecOptionPartialEq` is specialized by this macro, so using it requires enabling
-/// `#![feature(min_specialization)]` for the crate.
 #[proc_macro]
 #[cfg_attr(
     feature = "nightly",
-    allow_internal_unstable(step_trait, rustc_attrs, trusted_step, spec_option_partial_eq)
+    allow_internal_unstable(
+        step_trait,
+        rustc_attrs,
+        trusted_step,
+        spec_option_partial_eq,
+        min_specialization
+    )
 )]
-// FIXME: Remove the above comment about `min_specialization` once bootstrap is bumped,
-// and the corresponding one on SpecOptionPartialEq
-#[cfg_attr(all(feature = "nightly", not(bootstrap)), allow_internal_unstable(min_specialization))]
 pub fn newtype_index(input: TokenStream) -> TokenStream {
     newtype::newtype(input)
 }
diff --git a/compiler/rustc_lint/src/lib.rs b/compiler/rustc_lint/src/lib.rs
@@ -34,7 +34,7 @@
 #![feature(if_let_guard)]
 #![feature(iter_order_by)]
 #![feature(let_chains)]
-#![cfg_attr(not(bootstrap), feature(trait_upcasting))]
+#![feature(trait_upcasting)]
 #![feature(min_specialization)]
 #![feature(rustc_attrs)]
 #![deny(rustc::untranslatable_diagnostic)]
diff --git a/compiler/rustc_middle/src/lib.rs b/compiler/rustc_middle/src/lib.rs
@@ -49,7 +49,7 @@
 #![feature(associated_type_bounds)]
 #![feature(rustc_attrs)]
 #![feature(control_flow_enum)]
-#![cfg_attr(not(bootstrap), feature(trait_upcasting))]
+#![feature(trait_upcasting)]
 #![feature(try_blocks)]
 #![feature(decl_macro)]
 #![feature(extract_if)]
diff --git a/library/core/src/async_iter/async_iter.rs b/library/core/src/async_iter/async_iter.rs
@@ -47,7 +47,7 @@ pub trait AsyncIterator {
     /// Rust's usual rules apply: calls must never cause undefined behavior
     /// (memory corruption, incorrect use of `unsafe` functions, or the like),
     /// regardless of the async iterator's state.
-    #[cfg_attr(not(bootstrap), lang = "async_iterator_poll_next")]
+    #[lang = "async_iterator_poll_next"]
     fn poll_next(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<Self::Item>>;
 
     /// Returns the bounds on the remaining length of the async iterator.
@@ -145,7 +145,7 @@ pub trait IntoAsyncIterator {
     type IntoAsyncIter: AsyncIterator<Item = Self::Item>;
 
     /// Converts `self` into an async iterator
-    #[cfg_attr(not(bootstrap), lang = "into_async_iter_into_iter")]
+    #[lang = "into_async_iter_into_iter"]
     fn into_async_iter(self) -> Self::IntoAsyncIter;
 }
 
diff --git a/library/core/src/intrinsics.rs b/library/core/src/intrinsics.rs
@@ -2567,18 +2567,9 @@ extern "rust-intrinsic" {
     /// matter what*.
     #[rustc_const_unstable(feature = "is_val_statically_known", issue = "none")]
     #[rustc_nounwind]
-    #[cfg(not(bootstrap))]
     pub fn is_val_statically_known<T: Copy>(arg: T) -> bool;
 }
 
-// FIXME: Seems using `unstable` here completely ignores `rustc_allow_const_fn_unstable`
-// and thus compiling stage0 core doesn't work.
-#[rustc_const_stable(feature = "is_val_statically_known", since = "0.0.0")]
-#[cfg(bootstrap)]
-pub const unsafe fn is_val_statically_known<T: Copy>(_arg: T) -> bool {
-    false
-}
-
 // Some functions are defined here because they accidentally got made
 // available in this module on stable. See <https://github.com/rust-lang/rust/issues/15702>.
 // (`transmute` also falls into this category, but it cannot be wrapped due to the
diff --git a/library/core/src/intrinsics/mir.rs b/library/core/src/intrinsics/mir.rs
@@ -105,7 +105,6 @@
 //! }
 //!
 //! #[custom_mir(dialect = "runtime", phase = "optimized")]
-#![cfg_attr(bootstrap, doc = "#[cfg(any())]")] // disable the following function in doctests when `bootstrap` is set
 //! fn push_and_pop<T>(v: &mut Vec<T>, value: T) {
 //!     mir!(
 //!         let _unused;
@@ -357,7 +356,6 @@ define!("mir_unwind_resume",
 
 define!("mir_storage_live", fn StorageLive<T>(local: T));
 define!("mir_storage_dead", fn StorageDead<T>(local: T));
-#[cfg(not(bootstrap))]
 define!("mir_assume", fn Assume(operand: bool));
 define!("mir_deinit", fn Deinit<T>(place: T));
 define!("mir_checked", fn Checked<T>(binop: T) -> (T, bool));
diff --git a/library/core/src/lib.rs b/library/core/src/lib.rs
@@ -111,7 +111,6 @@
 //
 // Library features:
 // tidy-alphabetical-start
-#![cfg_attr(not(bootstrap), feature(offset_of_nested))]
 #![feature(char_indices_offset)]
 #![feature(const_align_of_val)]
 #![feature(const_align_of_val_raw)]
@@ -181,6 +180,7 @@
 #![feature(maybe_uninit_uninit_array)]
 #![feature(non_null_convenience)]
 #![feature(offset_of_enum)]
+#![feature(offset_of_nested)]
 #![feature(panic_internals)]
 #![feature(ptr_alignment_type)]
 #![feature(ptr_metadata)]
diff --git a/library/core/src/marker.rs b/library/core/src/marker.rs
@@ -225,77 +225,6 @@ marker_impls! {
         {T: ?Sized} &T,
 }
 
-/// Required trait for constants used in pattern matches.
-///
-/// Any type that derives `Eq` automatically implements this trait, *regardless*
-/// of whether its type parameters implement `Eq`.
-///
-/// This is a hack to work around a limitation in our type system.
-///
-/// # Background
-///
-/// We want to require that types of consts used in pattern matches
-/// have the attribute `#[derive(PartialEq, Eq)]`.
-///
-/// In a more ideal world, we could check that requirement by just checking that
-/// the given type implements both the `StructuralPartialEq` trait *and*
-/// the `Eq` trait. However, you can have ADTs that *do* `derive(PartialEq, Eq)`,
-/// and be a case that we want the compiler to accept, and yet the constant's
-/// type fails to implement `Eq`.
-///
-/// Namely, a case like this:
-///
-/// ```rust
-/// #[derive(PartialEq, Eq)]
-/// struct Wrap<X>(X);
-///
-/// fn higher_order(_: &()) { }
-///
-/// const CFN: Wrap<fn(&())> = Wrap(higher_order);
-///
-/// #[allow(pointer_structural_match)]
-/// fn main() {
-///     match CFN {
-///         CFN => {}
-///         _ => {}
-///     }
-/// }
-/// ```
-///
-/// (The problem in the above code is that `Wrap<fn(&())>` does not implement
-/// `PartialEq`, nor `Eq`, because `for<'a> fn(&'a _)` does not implement those
-/// traits.)
-///
-/// Therefore, we cannot rely on naive check for `StructuralPartialEq` and
-/// mere `Eq`.
-///
-/// As a hack to work around this, we use two separate traits injected by each
-/// of the two derives (`#[derive(PartialEq)]` and `#[derive(Eq)]`) and check
-/// that both of them are present as part of structural-match checking.
-#[unstable(feature = "structural_match", issue = "31434")]
-#[diagnostic::on_unimplemented(message = "the type `{Self}` does not `#[derive(Eq)]`")]
-#[lang = "structural_teq"]
-#[cfg(bootstrap)]
-pub trait StructuralEq {
-    // Empty.
-}
-
-// FIXME: Remove special cases of these types from the compiler pattern checking code and always check `T: StructuralEq` instead
-marker_impls! {
-    #[unstable(feature = "structural_match", issue = "31434")]
-    #[cfg(bootstrap)]
-    StructuralEq for
-        usize, u8, u16, u32, u64, u128,
-        isize, i8, i16, i32, i64, i128,
-        bool,
-        char,
-        str /* Technically requires `[u8]: StructuralEq` */,
-        (),
-        {T, const N: usize} [T; N],
-        {T} [T],
-        {T: ?Sized} &T,
-}
-
 /// Types whose values can be duplicated simply by copying bits.
 ///
 /// By default, variable bindings have 'move semantics.' In other
@@ -860,10 +789,6 @@ impl<T: ?Sized> Default for PhantomData<T> {
 #[unstable(feature = "structural_match", issue = "31434")]
 impl<T: ?Sized> StructuralPartialEq for PhantomData<T> {}
 
-#[unstable(feature = "structural_match", issue = "31434")]
-#[cfg(bootstrap)]
-impl<T: ?Sized> StructuralEq for PhantomData<T> {}
-
 /// Compiler-internal trait used to indicate the type of enum discriminants.
 ///
 /// This trait is automatically implemented for every type and does not add any
@@ -1041,22 +966,8 @@ pub trait PointerLike {}
 #[unstable(feature = "adt_const_params", issue = "95174")]
 #[diagnostic::on_unimplemented(message = "`{Self}` can't be used as a const parameter type")]
 #[allow(multiple_supertrait_upcastable)]
-#[cfg(not(bootstrap))]
 pub trait ConstParamTy: StructuralPartialEq + Eq {}
 
-/// A marker for types which can be used as types of `const` generic parameters.
-///
-/// These types must have a proper equivalence relation (`Eq`) and it must be automatically
-/// derived (`StructuralPartialEq`). There's a hard-coded check in the compiler ensuring
-/// that all fields are also `ConstParamTy`, which implies that recursively, all fields
-/// are `StructuralPartialEq`.
-#[lang = "const_param_ty"]
-#[unstable(feature = "adt_const_params", issue = "95174")]
-#[rustc_on_unimplemented(message = "`{Self}` can't be used as a const parameter type")]
-#[allow(multiple_supertrait_upcastable)]
-#[cfg(bootstrap)]
-pub trait ConstParamTy: StructuralEq + StructuralPartialEq + Eq {}
-
 /// Derive macro generating an impl of the trait `ConstParamTy`.
 #[rustc_builtin_macro]
 #[unstable(feature = "adt_const_params", issue = "95174")]
diff --git a/library/core/src/mem/mod.rs b/library/core/src/mem/mod.rs
@@ -1393,19 +1393,9 @@ impl<T> SizedTypeProperties for T {}
 ///
 /// assert_eq!(mem::offset_of!(Option<&u8>, Some.0), 0);
 /// ```
-#[cfg(not(bootstrap))]
 #[stable(feature = "offset_of", since = "1.77.0")]
 #[allow_internal_unstable(builtin_syntax, hint_must_use)]
 pub macro offset_of($Container:ty, $($fields:expr)+ $(,)?) {
     // The `{}` is for better error messages
     crate::hint::must_use({builtin # offset_of($Container, $($fields)+)})
 }
-
-#[cfg(bootstrap)]
-#[stable(feature = "offset_of", since = "1.77.0")]
-#[allow_internal_unstable(builtin_syntax, hint_must_use)]
-#[allow(missing_docs)]
-pub macro offset_of($Container:ty, $($fields:tt).+ $(,)?) {
-    // The `{}` is for better error messages
-    crate::hint::must_use({builtin # offset_of($Container, $($fields).+)})
-}
diff --git a/library/core/src/num/nonzero.rs b/library/core/src/num/nonzero.rs
@@ -4,8 +4,6 @@ use crate::cmp::Ordering;
 use crate::fmt;
 use crate::hash::{Hash, Hasher};
 use crate::intrinsics;
-#[cfg(bootstrap)]
-use crate::marker::StructuralEq;
 use crate::marker::StructuralPartialEq;
 use crate::ops::{BitOr, BitOrAssign, Div, Neg, Rem};
 use crate::ptr;
@@ -583,10 +581,6 @@ macro_rules! nonzero_integer {
         #[$stability]
         impl Eq for $Ty {}
 
-        #[unstable(feature = "structural_match", issue = "31434")]
-        #[cfg(bootstrap)]
-        impl StructuralEq for $Ty {}
-
         #[$stability]
         impl PartialOrd for $Ty {
             #[inline]
diff --git a/library/core/src/ops/async_function.rs b/library/core/src/ops/async_function.rs
@@ -8,7 +8,7 @@ use crate::marker::Tuple;
 #[rustc_paren_sugar]
 #[fundamental]
 #[must_use = "async closures are lazy and do nothing unless called"]
-#[cfg_attr(not(bootstrap), lang = "async_fn")]
+#[lang = "async_fn"]
 pub trait AsyncFn<Args: Tuple>: AsyncFnMut<Args> {
     /// Future returned by [`AsyncFn::async_call`].
     #[unstable(feature = "async_fn_traits", issue = "none")]
@@ -28,7 +28,7 @@ pub trait AsyncFn<Args: Tuple>: AsyncFnMut<Args> {
 #[rustc_paren_sugar]
 #[fundamental]
 #[must_use = "async closures are lazy and do nothing unless called"]
-#[cfg_attr(not(bootstrap), lang = "async_fn_mut")]
+#[lang = "async_fn_mut"]
 pub trait AsyncFnMut<Args: Tuple>: AsyncFnOnce<Args> {
     /// Future returned by [`AsyncFnMut::async_call_mut`].
     #[unstable(feature = "async_fn_traits", issue = "none")]
@@ -48,7 +48,7 @@ pub trait AsyncFnMut<Args: Tuple>: AsyncFnOnce<Args> {
 #[rustc_paren_sugar]
 #[fundamental]
 #[must_use = "async closures are lazy and do nothing unless called"]
-#[cfg_attr(not(bootstrap), lang = "async_fn_once")]
+#[lang = "async_fn_once"]
 pub trait AsyncFnOnce<Args: Tuple> {
     /// Future returned by [`AsyncFnOnce::async_call_once`].
     #[unstable(feature = "async_fn_traits", issue = "none")]
diff --git a/library/core/src/ops/coroutine.rs b/library/core/src/ops/coroutine.rs
@@ -111,7 +111,7 @@ pub trait Coroutine<R = ()> {
     /// been returned previously. While coroutine literals in the language are
     /// guaranteed to panic on resuming after `Complete`, this is not guaranteed
     /// for all implementations of the `Coroutine` trait.
-    #[cfg_attr(not(bootstrap), lang = "coroutine_resume")]
+    #[lang = "coroutine_resume"]
     fn resume(self: Pin<&mut Self>, arg: R) -> CoroutineState<Self::Yield, Self::Return>;
 }
 
diff --git a/library/core/src/option.rs b/library/core/src/option.rs
@@ -2155,7 +2155,6 @@ impl<T: PartialEq> PartialEq for Option<T> {
 ///
 /// Once that's fixed, `Option` should go back to deriving `PartialEq`, as
 /// it used to do before <https://github.com/rust-lang/rust/pull/103556>.
-/// The comment regarding this trait on the `newtype_index` macro should be removed if this is done.
 #[unstable(feature = "spec_option_partial_eq", issue = "none", reason = "exposed only for rustc")]
 #[doc(hidden)]
 pub trait SpecOptionPartialEq: Sized {
diff --git a/library/core/src/slice/mod.rs b/library/core/src/slice/mod.rs
@@ -1951,10 +1951,7 @@ impl<T> [T] {
     /// }
     /// ```
     #[unstable(feature = "slice_split_at_unchecked", reason = "new API", issue = "76014")]
-    #[rustc_const_stable(
-        feature = "const_slice_split_at_unchecked",
-        since = "1.77.0"
-    )]
+    #[rustc_const_stable(feature = "const_slice_split_at_unchecked", since = "1.77.0")]
     #[inline]
     #[must_use]
     pub const unsafe fn split_at_unchecked(&self, mid: usize) -> (&[T], &[T]) {
diff --git a/library/core/src/tuple.rs b/library/core/src/tuple.rs
@@ -61,14 +61,6 @@ macro_rules! tuple_impls {
             {}
         }
 
-        maybe_tuple_doc! {
-            $($T)+ @
-            #[unstable(feature = "structural_match", issue = "31434")]
-            #[cfg(bootstrap)]
-            impl<$($T),+> crate::marker::StructuralEq for ($($T,)+)
-            {}
-        }
-
         maybe_tuple_doc! {
             $($T)+ @
             #[stable(feature = "rust1", since = "1.0.0")]
diff --git a/library/core/tests/lib.rs b/library/core/tests/lib.rs
@@ -59,7 +59,7 @@
 #![feature(noop_waker)]
 #![feature(numfmt)]
 #![feature(num_midpoint)]
-#![cfg_attr(not(bootstrap), feature(offset_of_nested))]
+#![feature(offset_of_nested)]
 #![feature(isqrt)]
 #![feature(step_trait)]
 #![feature(str_internals)]
@@ -112,7 +112,7 @@
 #![feature(slice_flatten)]
 #![feature(error_generic_member_access)]
 #![feature(error_in_core)]
-#![cfg_attr(not(bootstrap), feature(trait_upcasting))]
+#![feature(trait_upcasting)]
 #![feature(utf8_chunks)]
 #![feature(is_ascii_octdigit)]
 #![feature(get_many_mut)]
diff --git a/library/panic_unwind/src/seh.rs b/library/panic_unwind/src/seh.rs
@@ -262,7 +262,7 @@ cfg_if::cfg_if! {
 }
 
 // FIXME: Use `SyncUnsafeCell` instead of allowing `static_mut_ref` lint
-#[cfg_attr(not(bootstrap), allow(static_mut_ref))]
+#[allow(static_mut_ref)]
 pub unsafe fn panic(data: Box<dyn Any + Send>) -> u32 {
     use core::intrinsics::atomic_store_seqcst;
 
@@ -325,7 +325,7 @@ pub unsafe fn panic(data: Box<dyn Any + Send>) -> u32 {
 }
 
 // FIXME: Use `SyncUnsafeCell` instead of allowing `static_mut_ref` lint
-#[cfg_attr(not(bootstrap), allow(static_mut_ref))]
+#[allow(static_mut_ref)]
 pub unsafe fn cleanup(payload: *mut u8) -> Box<dyn Any + Send> {
     // A null payload here means that we got here from the catch (...) of
     // __rust_try. This happens when a non-Rust foreign exception is caught.
diff --git a/library/std/src/lib.rs b/library/std/src/lib.rs
@@ -266,12 +266,12 @@
 //
 // Language features:
 // tidy-alphabetical-start
-#![cfg_attr(not(bootstrap), feature(cfg_sanitizer_cfi))]
 #![feature(alloc_error_handler)]
 #![feature(allocator_internals)]
 #![feature(allow_internal_unsafe)]
 #![feature(allow_internal_unstable)]
 #![feature(c_unwind)]
+#![feature(cfg_sanitizer_cfi)]
 #![feature(cfg_target_thread_local)]
 #![feature(cfi_encoding)]
 #![feature(concat_idents)]
diff --git a/library/std/src/panicking.rs b/library/std/src/panicking.rs
@@ -338,7 +338,7 @@ pub mod panic_count {
 #[cfg(not(feature = "panic_immediate_abort"))]
 #[unstable(feature = "update_panic_count", issue = "none")]
 // FIXME: Use `SyncUnsafeCell` instead of allowing `static_mut_ref` lint
-#[cfg_attr(not(bootstrap), allow(static_mut_ref))]
+#[allow(static_mut_ref)]
 pub mod panic_count {
     use crate::cell::Cell;
     use crate::sync::atomic::{AtomicUsize, Ordering};
diff --git a/library/std/src/sys/pal/common/thread_local/fast_local.rs b/library/std/src/sys/pal/common/thread_local/fast_local.rs
diff --git a/library/std/src/sys/pal/common/thread_local/static_local.rs b/library/std/src/sys/pal/common/thread_local/static_local.rs
diff --git a/library/std/src/sys/pal/unix/thread_local_dtor.rs b/library/std/src/sys/pal/unix/thread_local_dtor.rs
diff --git a/library/std/src/thread/local.rs b/library/std/src/thread/local.rs
diff --git a/src/bootstrap/src/lib.rs b/src/bootstrap/src/lib.rs
diff --git a/src/tools/coverage-dump/src/covfun.rs b/src/tools/coverage-dump/src/covfun.rs
diff --git a/src/tools/miri/src/lib.rs b/src/tools/miri/src/lib.rs
