Implement new panic!() behaviour for Rust 2021.

Author: m-ou-se

compiler/rustc_builtin_macros/src/lib.rs

@@ -34,6 +34,7 @@ mod global_allocator;
 mod global_asm;
 mod llvm_asm;
 mod log_syntax;
+mod panic;
 mod source_util;
 mod test;
 mod trace_macros;
@@ -82,6 +83,8 @@ pub fn register_builtin_macros(resolver: &mut dyn ResolverExpand, edition: Editi
         log_syntax: log_syntax::expand_log_syntax,
         module_path: source_util::expand_mod,
         option_env: env::expand_option_env,
+        core_panic_macro: panic::expand_panic,
+        std_panic_macro: panic::expand_panic,
         stringify: source_util::expand_stringify,
         trace_macros: trace_macros::expand_trace_macros,
     }

compiler/rustc_builtin_macros/src/panic.rs

@@ -0,0 +1,39 @@
+use rustc_ast::ptr::P;
+use rustc_ast::tokenstream::{DelimSpan, TokenStream};
+use rustc_ast::*;
+use rustc_expand::base::*;
+use rustc_span::symbol::sym;
+use rustc_span::Span;
+
+pub fn expand_panic<'cx>(
+    cx: &'cx mut ExtCtxt<'_>,
+    sp: Span,
+    tts: TokenStream,
+) -> Box<dyn MacResult + 'cx> {
+    let panic = if sp.rust_2021() { sym::panic_2021 } else { sym::panic_2015 };
+
+    let sp = cx.with_call_site_ctxt(sp);
+
+    MacEager::expr(
+        cx.expr(
+            sp,
+            ExprKind::MacCall(MacCall {
+                path: Path {
+                    span: sp,
+                    segments: cx
+                        .std_path(&[sym::panic, panic])
+                        .into_iter()
+                        .map(|ident| PathSegment::from_ident(ident))
+                        .collect(),
+                    tokens: None,
+                },
+                args: P(MacArgs::Delimited(
+                    DelimSpan::from_single(sp),
+                    MacDelimiter::Parenthesis,
+                    tts,
+                )),
+                prior_type_ascription: None,
+            }),
+        ),
+    )
+}

compiler/rustc_lint/src/panic_fmt.rs

@@ -19,10 +19,9 @@ declare_lint! {
     ///
     /// ### Explanation
     ///
-    /// `panic!("{}")` panics with the message `"{}"`, as a `panic!()` invocation
-    /// with a single argument does not use `format_args!()`.
-    /// A future edition of Rust will interpret this string as format string,
-    /// which would break this.
+    /// In Rust 2018 and earlier, `panic!("{}")` panics with the message `"{}"`,
+    /// as a `panic!()` invocation with a single argument does not use `format_args!()`.
+    /// Rust 2021 interprets this string as format string, which breaks this.
     PANIC_FMT,
     Warn,
     "detect braces in single-argument panic!() invocations",
@@ -50,8 +49,8 @@ fn check_panic<'tcx>(cx: &LateContext<'tcx>, f: &'tcx hir::Expr<'tcx>, arg: &'tc
         if let ast::LitKind::Str(sym, _) = lit.node {
             let mut expn = f.span.ctxt().outer_expn_data();
             if let Some(id) = expn.macro_def_id {
-                if cx.tcx.is_diagnostic_item(sym::std_panic_macro, id)
-                    || cx.tcx.is_diagnostic_item(sym::core_panic_macro, id)
+                if cx.tcx.is_diagnostic_item(sym::std_panic_2015_macro, id)
+                    || cx.tcx.is_diagnostic_item(sym::core_panic_2015_macro, id)
                 {
                     let fmt = sym.as_str();
                     if !fmt.contains(&['{', '}'][..]) {

compiler/rustc_span/src/symbol.rs

@@ -398,6 +398,7 @@ symbols! {
         copysignf64,
         core,
         core_intrinsics,
+        core_panic_2015_macro,
         core_panic_macro,
         cosf32,
         cosf64,
@@ -794,6 +795,8 @@ symbols! {
         owned_box,
         packed,
         panic,
+        panic_2015,
+        panic_2021,
         panic_abort,
         panic_bounds_check,
         panic_handler,
@@ -1095,6 +1098,7 @@ symbols! {
         staticlib,
         std,
         std_inject,
+        std_panic_2015_macro,
         std_panic_macro,
         stmt,
         stmt_expr_attributes,

library/core/src/macros/mod.rs

@@ -1,3 +1,4 @@
+#[cfg(bootstrap)]
 #[doc(include = "panic.md")]
 #[macro_export]
 #[allow_internal_unstable(core_panic)]
@@ -18,6 +19,19 @@ macro_rules! panic {
     );
 }
 
+#[cfg(not(bootstrap))]
+#[doc(include = "panic.md")]
+#[macro_export]
+#[rustc_builtin_macro = "core_panic_macro"]
+#[allow_internal_unstable(edition_panic)]
+#[stable(feature = "core", since = "1.6.0")]
+#[rustc_diagnostic_item = "core_panic_macro"]
+macro_rules! panic {
+    // Expands to either `$crate::panic_2015` or `$crate::panic_2021`
+    // depending on the edition of the caller.
+    ($($arg:tt)*) => { /* compiler built-in */ };
+}
+
 /// Asserts that two expressions are equal to each other (using [`PartialEq`]).
 ///
 /// On panic, this macro will print the values of the expressions with their

library/core/src/panic.rs

@@ -5,6 +5,40 @@
 use crate::any::Any;
 use crate::fmt;
 
+#[doc(hidden)]
+#[unstable(feature = "edition_panic", issue = "none", reason = "use panic!() instead")]
+#[allow_internal_unstable(core_panic)]
+#[rustc_diagnostic_item = "core_panic_2015_macro"]
+#[rustc_macro_transparency = "semitransparent"]
+pub macro panic_2015 {
+    () => (
+        $crate::panicking::panic("explicit panic")
+    ),
+    ($msg:literal $(,)?) => (
+        $crate::panicking::panic($msg)
+    ),
+    ($msg:expr $(,)?) => (
+        $crate::panicking::panic_str($msg)
+    ),
+    ($fmt:expr, $($arg:tt)+) => (
+        $crate::panicking::panic_fmt($crate::format_args!($fmt, $($arg)+))
+    ),
+}
+
+#[doc(hidden)]
+#[unstable(feature = "edition_panic", issue = "none", reason = "use panic!() instead")]
+#[allow_internal_unstable(core_panic)]
+#[rustc_diagnostic_item = "core_panic_2021_macro"]
+#[rustc_macro_transparency = "semitransparent"]
+pub macro panic_2021 {
+    () => (
+        $crate::panicking::panic("explicit panic")
+    ),
+    ($($t:tt)+) => (
+        $crate::panicking::panic_fmt($crate::format_args!($($t)+))
+    ),
+}
+
 /// A struct providing information about a panic.
 ///
 /// `PanicInfo` structure is passed to a panic hook set by the [`set_hook`]

library/std/src/lib.rs

@@ -258,6 +258,7 @@
 #![feature(dropck_eyepatch)]
 #![feature(duration_constants)]
 #![feature(duration_zero)]
+#![feature(edition_panic)]
 #![feature(exact_size_is_empty)]
 #![feature(exhaustive_patterns)]
 #![feature(extend_one)]

library/std/src/macros.rs

@@ -4,6 +4,7 @@
 //! library. Each macro is available for use when linking against the standard
 //! library.
 
+#[cfg(bootstrap)]
 #[doc(include = "../../core/src/macros/panic.md")]
 #[macro_export]
 #[stable(feature = "rust1", since = "1.0.0")]
@@ -17,6 +18,19 @@ macro_rules! panic {
     });
 }
 
+#[cfg(not(bootstrap))]
+#[doc(include = "../../core/src/macros/panic.md")]
+#[macro_export]
+#[rustc_builtin_macro = "std_panic_macro"]
+#[stable(feature = "rust1", since = "1.0.0")]
+#[allow_internal_unstable(edition_panic)]
+#[cfg_attr(not(test), rustc_diagnostic_item = "std_panic_macro")]
+macro_rules! panic {
+    // Expands to either `$crate::panic_2015` or `$crate::panic_2021`
+    // depending on the edition of the caller.
+    ($($arg:tt)*) => { /* compiler built-in */ };
+}
+
 /// Prints to the standard output.
 ///
 /// Equivalent to the [`println!`] macro except that a newline is not printed at

library/std/src/panic.rs

@@ -17,6 +17,36 @@ use crate::sync::{Arc, Mutex, RwLock};
 use crate::task::{Context, Poll};
 use crate::thread::Result;
 
+#[doc(hidden)]
+#[unstable(feature = "edition_panic", issue = "none", reason = "use panic!() instead")]
+#[allow_internal_unstable(libstd_sys_internals)]
+#[cfg_attr(not(test), rustc_diagnostic_item = "std_panic_2015_macro")]
+#[rustc_macro_transparency = "semitransparent"]
+pub macro panic_2015 {
+    () => ({
+        $crate::rt::begin_panic("explicit panic")
+    }),
+    ($msg:expr $(,)?) => ({
+        $crate::rt::begin_panic($msg)
+    }),
+    ($fmt:expr, $($arg:tt)+) => ({
+        $crate::rt::begin_panic_fmt(&$crate::format_args!($fmt, $($arg)+))
+    }),
+}
+
+#[doc(hidden)]
+#[unstable(feature = "edition_panic", issue = "none", reason = "use panic!() instead")]
+#[allow_internal_unstable(libstd_sys_internals)]
+#[rustc_macro_transparency = "semitransparent"]
+pub macro panic_2021 {
+    () => ({
+        $crate::rt::begin_panic("explicit panic")
+    }),
+    ($($t:tt)+) => ({
+        $crate::rt::begin_panic_fmt(&$crate::format_args!($($t)+))
+    }),
+}
+
 #[stable(feature = "panic_hooks", since = "1.10.0")]
 pub use crate::panicking::{set_hook, take_hook};