Auto merge of #51717 - Mark-Simulacrum:snap, r=alexcrichton

Bootstrap from 1.28.0 beta

2 files changed, 33 insertions, 72 deletions

diff --git a/src/libstd/lib.rs b/src/libstd/lib.rs
index caad924ea5b..d73cb1f8349 100644
--- a/src/libstd/lib.rs
+++ b/src/libstd/lib.rs
@@ -322,7 +322,7 @@
 #![feature(doc_keyword)]
 #![feature(float_internals)]
 #![feature(panic_info_message)]
-#![cfg_attr(not(stage0), feature(panic_implementation))]
+#![feature(panic_implementation)]
 
 #![default_lib_allocator]
 
@@ -332,9 +332,6 @@
 // `force_alloc_system` is *only* intended as a workaround for local rebuilds
 // with a rustc without jemalloc.
 // FIXME(#44236) shouldn't need MSVC logic
-#![cfg_attr(all(not(target_env = "msvc"),
-                any(all(stage0, not(test)), feature = "force_alloc_system")),
-            feature(global_allocator))]
 #[cfg(all(not(target_env = "msvc"),
           any(all(stage0, not(test)), feature = "force_alloc_system")))]
 #[global_allocator]
diff --git a/src/libstd/panicking.rs b/src/libstd/panicking.rs
index 0808efa2ece..46b6cf60705 100644
--- a/src/libstd/panicking.rs
+++ b/src/libstd/panicking.rs
@@ -319,18 +319,6 @@ pub fn panicking() -> bool {
 
 /// Entry point of panic from the libcore crate.
 #[cfg(not(test))]
-#[cfg(stage0)]
-#[lang = "panic_fmt"]
-pub extern fn rust_begin_panic(msg: fmt::Arguments,
-                               file: &'static str,
-                               line: u32,
-                               col: u32) -> ! {
-    begin_panic_fmt(&msg, &(file, line, col))
-}
-
-/// Entry point of panic from the libcore crate.
-#[cfg(not(test))]
-#[cfg(not(stage0))]
 #[panic_implementation]
 #[unwind(allowed)]
 pub fn rust_begin_panic(info: &PanicInfo) -> ! {
@@ -343,78 +331,54 @@ pub fn rust_begin_panic(info: &PanicInfo) -> ! {
 /// site as much as possible (so that `panic!()` has as low an impact
 /// on (e.g.) the inlining of other functions as possible), by moving
 /// the actual formatting into this shared place.
-#[cfg(stage0)]
 #[unstable(feature = "libstd_sys_internals",
            reason = "used by the panic! macro",
            issue = "0")]
 #[inline(never)] #[cold]
 pub fn begin_panic_fmt(msg: &fmt::Arguments,
                        file_line_col: &(&'static str, u32, u32)) -> ! {
-    // We do two allocations here, unfortunately. But (a) they're
-    // required with the current scheme, and (b) we don't handle
-    // panic + OOM properly anyway (see comment in begin_panic
-    // below).
-
-    rust_panic_with_hook(&mut PanicPayload::new(msg), Some(msg), file_line_col);
-}
-
-// NOTE(stage0) move into `continue_panic_fmt` on next stage0 update
-struct PanicPayload<'a> {
-    inner: &'a fmt::Arguments<'a>,
-    string: Option<String>,
+    let (file, line, col) = *file_line_col;
+    let info = PanicInfo::internal_constructor(
+        Some(msg),
+        Location::internal_constructor(file, line, col),
+    );
+    continue_panic_fmt(&info)
 }
 
-impl<'a> PanicPayload<'a> {
-    fn new(inner: &'a fmt::Arguments<'a>) -> PanicPayload<'a> {
-        PanicPayload { inner, string: None }
+fn continue_panic_fmt(info: &PanicInfo) -> ! {
+    struct PanicPayload<'a> {
+        inner: &'a fmt::Arguments<'a>,
+        string: Option<String>,
     }
 
-    fn fill(&mut self) -> &mut String {
-        use fmt::Write;
+    impl<'a> PanicPayload<'a> {
+        fn new(inner: &'a fmt::Arguments<'a>) -> PanicPayload<'a> {
+            PanicPayload { inner, string: None }
+        }
 
-        let inner = self.inner;
-        self.string.get_or_insert_with(|| {
-            let mut s = String::new();
-            drop(s.write_fmt(*inner));
-            s
-        })
-    }
-}
+        fn fill(&mut self) -> &mut String {
+            use fmt::Write;
 
-unsafe impl<'a> BoxMeUp for PanicPayload<'a> {
-    fn box_me_up(&mut self) -> *mut (Any + Send) {
-        let contents = mem::replace(self.fill(), String::new());
-        Box::into_raw(Box::new(contents))
+            let inner = self.inner;
+            self.string.get_or_insert_with(|| {
+                let mut s = String::new();
+                drop(s.write_fmt(*inner));
+                s
+            })
+        }
     }
 
-    fn get(&mut self) -> &(Any + Send) {
-        self.fill()
-    }
-}
+    unsafe impl<'a> BoxMeUp for PanicPayload<'a> {
+        fn box_me_up(&mut self) -> *mut (Any + Send) {
+            let contents = mem::replace(self.fill(), String::new());
+            Box::into_raw(Box::new(contents))
+        }
 
-/// The entry point for panicking with a formatted message.
-///
-/// This is designed to reduce the amount of code required at the call
-/// site as much as possible (so that `panic!()` has as low an impact
-/// on (e.g.) the inlining of other functions as possible), by moving
-/// the actual formatting into this shared place.
-#[cfg(not(stage0))]
-#[unstable(feature = "libstd_sys_internals",
-           reason = "used by the panic! macro",
-           issue = "0")]
-#[inline(never)] #[cold]
-pub fn begin_panic_fmt(msg: &fmt::Arguments,
-                       file_line_col: &(&'static str, u32, u32)) -> ! {
-    let (file, line, col) = *file_line_col;
-    let info = PanicInfo::internal_constructor(
-        Some(msg),
-        Location::internal_constructor(file, line, col),
-    );
-    continue_panic_fmt(&info)
-}
+        fn get(&mut self) -> &(Any + Send) {
+            self.fill()
+        }
+    }
 
-#[cfg(not(stage0))]
-fn continue_panic_fmt(info: &PanicInfo) -> ! {
     // We do two allocations here, unfortunately. But (a) they're
     // required with the current scheme, and (b) we don't handle
     // panic + OOM properly anyway (see comment in begin_panic