Fix the test failure, add comment, and refactor a little bit

src/libcore/lib.rs

@@ -160,11 +160,6 @@ pub mod array;
 pub mod sync;
 pub mod cell;
 pub mod char;
-// FIXME: remove when SNAP
-#[cfg(stage0)]
-#[path = "panicking_stage0.rs"]
-pub mod panicking;
-#[cfg(not(stage0))]
 pub mod panicking;
 pub mod iter;
 pub mod option;

src/libcore/macros.rs

@@ -19,7 +19,7 @@ macro_rules! panic {
     ($msg:expr) => ({
         static _MSG_FILE_LINE_COL: (&'static str, &'static str, u32, u32) =
             ($msg, file!(), line!(), column!());
-        $crate::panicking::panic_new(&_MSG_FILE_LINE_COL)
+        $crate::panicking::panic(&_MSG_FILE_LINE_COL)
     });
     ($fmt:expr, $($arg:tt)*) => ({
         // The leading _'s are to avoid dead code warnings if this is
@@ -28,7 +28,7 @@ macro_rules! panic {
         // `#[forbid(dead_code)]` and which cannot be overridden.
         static _MSG_FILE_LINE_COL: (&'static str, u32, u32) =
             (file!(), line!(), column!());
-        $crate::panicking::panic_fmt_new(format_args!($fmt, $($arg)*), &_MSG_FILE_LINE_COL)
+        $crate::panicking::panic_fmt(format_args!($fmt, $($arg)*), &_MSG_FILE_LINE_COL)
     });
 }
 

src/libcore/panicking.rs

@@ -38,13 +38,8 @@
 
 use fmt;
 
-#[cold] #[inline(never)]
-pub fn panic_new(expr_file_line_col: &(&'static str, &'static str, u32, u32)) -> ! {
-    panic(&expr_file_line_col)
-}
-
 #[cold] #[inline(never)] // this is the slow path, always
-#[lang = "panic"]
+#[cfg_attr(not(stage0), lang = "panic")]
 pub fn panic(expr_file_line_col: &(&'static str, &'static str, u32, u32)) -> ! {
     // Use Arguments::new_v1 instead of format_args!("{}", expr) to potentially
     // reduce size overhead. The format_args! macro uses str's Display trait to
@@ -56,17 +51,33 @@ pub fn panic(expr_file_line_col: &(&'static str, &'static str, u32, u32)) -> ! {
     panic_fmt(fmt::Arguments::new_v1(&[expr], &[]), &(file, line, col))
 }
 
+// FIXME: remove when SNAP
 #[cold] #[inline(never)]
-#[lang = "panic_bounds_check"]
+#[cfg(stage0)]
+#[lang = "panic"]
+pub fn panic_old(expr_file_line: &(&'static str, &'static str, u32)) -> ! {
+    let (expr, file, line) = *expr_file_line;
+    let expr_file_line_col = (expr, file, line, 0);
+    panic(&expr_file_line_col)
+}
+
+#[cold] #[inline(never)]
+#[cfg_attr(not(stage0), lang = "panic_bounds_check")]
 fn panic_bounds_check(file_line_col: &(&'static str, u32, u32),
                      index: usize, len: usize) -> ! {
     panic_fmt(format_args!("index out of bounds: the len is {} but the index is {}",
                            len, index), file_line_col)
 }
 
+// FIXME: remove when SNAP
 #[cold] #[inline(never)]
-pub fn panic_fmt_new(fmt: fmt::Arguments, file_line_col: &(&'static str, u32, u32)) -> ! {
-    panic_fmt(fmt, &file_line_col)
+#[cfg(stage0)]
+#[lang = "panic_bounds_check"]
+fn panic_bounds_check_old(file_line: &(&'static str, u32),
+                     index: usize, len: usize) -> ! {
+    let (file, line) = *file_line;
+    panic_fmt(format_args!("index out of bounds: the len is {} but the index is {}",
+                           len, index), &(file, line, 0))
 }
 
 #[cold] #[inline(never)]

src/libstd/panicking.rs

@@ -315,6 +315,7 @@ impl<'a> Location<'a> {
     /// # Examples
     ///
     /// ```should_panic
+    /// #![feature(panic_col)]
     /// use std::panic;
     ///
     /// panic::set_hook(Box::new(|panic_info| {
@@ -327,7 +328,7 @@ impl<'a> Location<'a> {
     ///
     /// panic!("Normal panic");
     /// ```
-    #[unstable(feature = "panic_col", issue = "42939")]
+    #[unstable(feature = "panic_col", reason = "recently added", issue = "42939")]
     pub fn column(&self) -> u32 {
         self.col
     }
@@ -520,7 +521,21 @@ pub fn begin_panic_fmt(msg: &fmt::Arguments,
     begin_panic_new(s, file_line_col)
 }
 
-// FIXME: remove begin_panic and rename begin_panic_new to begin_panic when SNAP
+// FIXME: In PR #42938, we have added the column as info passed to the panic
+// handling code. For this, we want to break the ABI of begin_panic.
+// This is not possible to do directly, as the stage0 compiler is hardcoded
+// to emit a call to begin_panic in src/libsyntax/ext/build.rs, only
+// with the file and line number being passed, but not the colum number.
+// By changing the compiler source, we can only affect behaviour of higher
+// stages. We need to perform the switch over two stage0 replacements, using
+// a temporary function begin_panic_new while performing the switch:
+// 0. Right now, we tell stage1 onward to emit a call to begin_panic_new.
+// 1. In the first SNAP, stage0 calls begin_panic_new with the new ABI,
+//    begin_panic stops being used. Now we can change begin_panic to
+//    the new ABI, and start emitting calls to begin_panic in higher
+//    stages again, this time with the new ABI.
+// 2. After the second SNAP, stage0 calls begin_panic with the new ABI,
+//    and we can remove the temporary begin_panic_new function.
 
 /// This is the entry point of panicking for panic!() and assert!().
 #[unstable(feature = "libstd_sys_internals",