Snap cfgs

Author: Mark-Simulacrum

src/libcore/array/mod.rs

@@ -14,10 +14,8 @@ use crate::hash::{Hash, self};
 use crate::marker::Unsize;
 use crate::slice::{Iter, IterMut};
 
-#[cfg(not(bootstrap))]
 mod iter;
 
-#[cfg(not(bootstrap))]
 #[unstable(feature = "array_value_iter", issue = "65798")]
 pub use iter::IntoIter;
 

src/libcore/convert.rs

@@ -557,7 +557,6 @@ impl<T> From<T> for T {
 ///
 /// [#64715]: https://github.com/rust-lang/rust/issues/64715
 #[stable(feature = "convert_infallible", since = "1.34.0")]
-#[cfg(not(bootstrap))]
 #[rustc_reservation_impl="permitting this impl would forbid us from adding \
 `impl<T> From<!> for T` later; see rust-lang/rust#64715 for details"]
 impl<T> From<!> for T {

src/libcore/intrinsics.rs

@@ -697,7 +697,6 @@ extern "rust-intrinsic" {
     pub fn panic_if_uninhabited<T>();
 
     /// Gets a reference to a static `Location` indicating where it was called.
-    #[cfg(not(bootstrap))]
     pub fn caller_location() -> &'static crate::panic::Location<'static>;
 
     /// Creates a value initialized to zero.
@@ -1346,7 +1345,6 @@ extern "rust-intrinsic" {
     pub fn nontemporal_store<T>(ptr: *mut T, val: T);
 
     /// See documentation of `<*const T>::offset_from` for details.
-    #[cfg(not(bootstrap))]
     pub fn ptr_offset_from<T>(ptr: *const T, base: *const T) -> isize;
 }
 

src/libcore/lib.rs

@@ -121,7 +121,6 @@
 #![feature(hexagon_target_feature)]
 #![feature(const_int_conversion)]
 #![feature(const_transmute)]
-#![cfg_attr(bootstrap, feature(non_exhaustive))]
 #![feature(structural_match)]
 #![feature(abi_unadjusted)]
 #![feature(adx_target_feature)]

src/libcore/macros.rs

@@ -1,30 +1,6 @@
 /// Panics the current thread.
 ///
 /// For details, see `std::macros`.
-#[cfg(bootstrap)]
-#[macro_export]
-#[allow_internal_unstable(core_panic, panic_internals)]
-#[stable(feature = "core", since = "1.6.0")]
-macro_rules! panic {
-    () => (
-        $crate::panic!("explicit panic")
-    );
-    ($msg:expr) => ({
-        $crate::panicking::panic(&($msg, $crate::file!(), $crate::line!(), $crate::column!()))
-    });
-    ($msg:expr,) => (
-        $crate::panic!($msg)
-    );
-    ($fmt:expr, $($arg:tt)+) => ({
-        $crate::panicking::panic_fmt($crate::format_args!($fmt, $($arg)+),
-                                     &($crate::file!(), $crate::line!(), $crate::column!()))
-    });
-}
-
-/// Panics the current thread.
-///
-/// For details, see `std::macros`.
-#[cfg(not(bootstrap))]
 #[macro_export]
 #[allow_internal_unstable(core_panic,
     // FIXME(anp, eddyb) `core_intrinsics` is used here to allow calling

src/libcore/marker.rs

@@ -146,7 +146,6 @@ pub trait Unsize<T: ?Sized> {
 ///
 /// [RFC1445]: https://github.com/rust-lang/rfcs/blob/master/text/1445-restrict-constants-in-patterns.md
 /// [issue 63438]: https://github.com/rust-lang/rust/issues/63438
-#[cfg(not(bootstrap))]
 #[unstable(feature = "structural_match", issue = "31434")]
 #[rustc_on_unimplemented(message="the type `{Self}` does not `#[derive(PartialEq)]`")]
 #[lang = "structural_peq"]
@@ -197,7 +196,6 @@ pub trait StructuralPartialEq {
 /// 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.
-#[cfg(not(bootstrap))]
 #[unstable(feature = "structural_match", issue = "31434")]
 #[rustc_on_unimplemented(message="the type `{Self}` does not `#[derive(Eq)]`")]
 #[lang = "structural_teq"]
@@ -517,11 +515,9 @@ macro_rules! impls{
             }
         }
 
-        #[cfg(not(bootstrap))]
         #[unstable(feature = "structural_match", issue = "31434")]
         impl<T: ?Sized> StructuralPartialEq for $t<T> { }
 
-        #[cfg(not(bootstrap))]
         #[unstable(feature = "structural_match", issue = "31434")]
         impl<T: ?Sized> StructuralEq for $t<T> { }
         )

src/libcore/ops/try.rs

@@ -5,20 +5,7 @@
 /// extracting those success or failure values from an existing instance and
 /// creating a new instance from a success or failure value.
 #[unstable(feature = "try_trait", issue = "42327")]
-#[cfg_attr(bootstrap, rustc_on_unimplemented(
-   on(all(
-       any(from_method="from_error", from_method="from_ok"),
-       from_desugaring="QuestionMark"),
-      message="the `?` operator can only be used in a \
-               function that returns `Result` or `Option` \
-               (or another type that implements `{Try}`)",
-      label="cannot use the `?` operator in a function that returns `{Self}`"),
-   on(all(from_method="into_result", from_desugaring="QuestionMark"),
-      message="the `?` operator can only be applied to values \
-               that implement `{Try}`",
-      label="the `?` operator cannot be applied to type `{Self}`")
-))]
-#[cfg_attr(not(bootstrap), rustc_on_unimplemented(
+#[rustc_on_unimplemented(
 on(all(
 any(from_method="from_error", from_method="from_ok"),
 from_desugaring="QuestionMark"),
@@ -30,7 +17,7 @@ on(all(from_method="into_result", from_desugaring="QuestionMark"),
 message="the `?` operator can only be applied to values \
                that implement `{Try}`",
 label="the `?` operator cannot be applied to type `{Self}`")
-))]
+)]
 #[doc(alias = "?")]
 pub trait Try {
     /// The type of this value when viewed as successful.

src/libcore/panic.rs

@@ -167,7 +167,7 @@ impl fmt::Display for PanicInfo<'_> {
 ///
 /// panic!("Normal panic");
 /// ```
-#[cfg_attr(not(bootstrap), lang = "panic_location")]
+#[lang = "panic_location"]
 #[derive(Debug)]
 #[stable(feature = "panic_hooks", since = "1.10.0")]
 pub struct Location<'a> {

src/libcore/panicking.rs

@@ -31,28 +31,6 @@
 use crate::fmt;
 use crate::panic::{Location, PanicInfo};
 
-#[cfg(bootstrap)]
-#[cold]
-// never inline unless panic_immediate_abort to avoid code
-// bloat at the call sites as much as possible
-#[cfg_attr(not(feature="panic_immediate_abort"),inline(never))]
-#[lang = "panic"]
-pub fn panic(expr_file_line_col: &(&'static str, &'static str, u32, u32)) -> ! {
-    if cfg!(feature = "panic_immediate_abort") {
-        unsafe { super::intrinsics::abort() }
-    }
-
-    // Use Arguments::new_v1 instead of format_args!("{}", expr) to potentially
-    // reduce size overhead. The format_args! macro uses str's Display trait to
-    // write expr, which calls Formatter::pad, which must accommodate string
-    // truncation and padding (even though none is used here). Using
-    // Arguments::new_v1 may allow the compiler to omit Formatter::pad from the
-    // output binary, saving up to a few kilobytes.
-    let (expr, file, line, col) = *expr_file_line_col;
-    panic_fmt(fmt::Arguments::new_v1(&[expr], &[]), &(file, line, col))
-}
-
-#[cfg(not(bootstrap))]
 #[cold]
 // never inline unless panic_immediate_abort to avoid code
 // bloat at the call sites as much as possible
@@ -72,21 +50,6 @@ pub fn panic(expr: &str, location: &Location<'_>) -> ! {
     panic_fmt(fmt::Arguments::new_v1(&[expr], &[]), location)
 }
 
-#[cfg(bootstrap)]
-#[cold]
-#[cfg_attr(not(feature="panic_immediate_abort"),inline(never))]
-#[lang = "panic_bounds_check"]
-fn panic_bounds_check(file_line_col: &(&'static str, u32, u32),
-                     index: usize, len: usize) -> ! {
-    if cfg!(feature = "panic_immediate_abort") {
-        unsafe { super::intrinsics::abort() }
-    }
-
-    panic_fmt(format_args!("index out of bounds: the len is {} but the index is {}",
-                           len, index), file_line_col)
-}
-
-#[cfg(not(bootstrap))]
 #[cold]
 #[cfg_attr(not(feature="panic_immediate_abort"),inline(never))]
 #[lang = "panic_bounds_check"]
@@ -101,28 +64,6 @@ fn panic_bounds_check(location: &Location<'_>, index: usize, len: usize) -> ! {
     )
 }
 
-#[cfg(bootstrap)]
-#[cold]
-#[cfg_attr(not(feature="panic_immediate_abort"),inline(never))]
-#[cfg_attr(    feature="panic_immediate_abort" ,inline)]
-pub fn panic_fmt(fmt: fmt::Arguments<'_>, file_line_col: &(&'static str, u32, u32)) -> ! {
-    if cfg!(feature = "panic_immediate_abort") {
-        unsafe { super::intrinsics::abort() }
-    }
-
-    // NOTE This function never crosses the FFI boundary; it's a Rust-to-Rust call
-    extern "Rust" {
-        #[lang = "panic_impl"]
-        fn panic_impl(pi: &PanicInfo<'_>) -> !;
-    }
-
-    let (file, line, col) = *file_line_col;
-    let location = Location::internal_constructor(file, line, col);
-    let pi = PanicInfo::internal_constructor(Some(&fmt), &location);
-    unsafe { panic_impl(&pi) }
-}
-
-#[cfg(not(bootstrap))]
 #[cold]
 #[cfg_attr(not(feature="panic_immediate_abort"),inline(never))]
 #[cfg_attr(    feature="panic_immediate_abort" ,inline)]

src/libcore/ptr/mod.rs

@@ -1301,7 +1301,6 @@ impl<T: ?Sized> *const T {
     /// }
     /// ```
     #[unstable(feature = "ptr_offset_from", issue = "41079")]
-    #[cfg(not(bootstrap))]
     #[rustc_const_unstable(feature = "const_ptr_offset_from")]
     #[inline]
     pub const unsafe fn offset_from(self, origin: *const T) -> isize where T: Sized {
@@ -1313,21 +1312,6 @@ impl<T: ?Sized> *const T {
         intrinsics::ptr_offset_from(self, origin)
     }
 
-    #[unstable(feature = "ptr_offset_from", issue = "41079")]
-    #[inline]
-    #[cfg(bootstrap)]
-    /// bootstrap
-    pub unsafe fn offset_from(self, origin: *const T) -> isize where T: Sized {
-        let pointee_size = mem::size_of::<T>();
-        assert!(0 < pointee_size && pointee_size <= isize::max_value() as usize);
-
-        // This is the same sequence that Clang emits for pointer subtraction.
-        // It can be neither `nsw` nor `nuw` because the input is treated as
-        // unsigned but then the output is treated as signed, so neither works.
-        let d = isize::wrapping_sub(self as _, origin as _);
-        intrinsics::exact_div(d, pointee_size as _)
-    }
-
     /// Calculates the distance between two pointers. The returned value is in
     /// units of T: the distance in bytes is divided by `mem::size_of::<T>()`.
     ///