rename begin_panic

Author: Kivooeo

RELEASES.md

@@ -876,7 +876,7 @@ Compatibility Notes
     ```
     thread 'main' panicked at 'hello world', map-panic.rs:2:50
     stack backtrace:
-       0: std::panicking::begin_panic
+       0: std::panicking::panic_with_payload
                  at /rustc/a55dd71d5fb0ec5a6a3a9e8c27b2127ba491ce52/library/std/src/panicking.rs:616:12
        1: map_panic::main::{{closure}}
                  at ./map-panic.rs:2:50

compiler/rustc_const_eval/src/check_consts/check.rs

@@ -827,11 +827,11 @@ impl<'tcx> Visitor<'tcx> for Checker<'_, 'tcx> {
 
                 // At this point, we are calling a function, `callee`, whose `DefId` is known...
 
-                // `begin_panic` and `#[rustc_const_panic_str]` functions accept generic
+                // `panic_with_payload` and `#[rustc_const_panic_str]` functions accept generic
                 // types other than str. Check to enforce that only str can be used in
                 // const-eval.
 
-                // const-eval of the `begin_panic` fn assumes the argument is `&str`
+                // const-eval of the `panic_with_payload` fn assumes the argument is `&str`
                 if tcx.is_lang_item(callee, LangItem::BeginPanic) {
                     match args[0].node.ty(&self.ccx.body.local_decls, tcx).kind() {
                         ty::Ref(_, ty, _) if ty.is_str() => {}

compiler/rustc_hir/src/lang_items.rs

@@ -320,7 +320,7 @@ language_item_table! {
     PanicAsyncGenFnResumedDrop, sym::panic_const_async_gen_fn_resumed_drop, panic_const_async_gen_fn_resumed_drop, Target::Fn, GenericRequirement::None;
     PanicGenFnNoneDrop, sym::panic_const_gen_fn_none_drop, panic_const_gen_fn_none_drop, Target::Fn, GenericRequirement::None;
     /// libstd panic entry point. Necessary for const eval to be able to catch it
-    BeginPanic,              sym::begin_panic,         begin_panic_fn,             Target::Fn,             GenericRequirement::None;
+    BeginPanic,              sym::panic_with_payload,         begin_panic_fn,             Target::Fn,             GenericRequirement::None;
 
     // Lang items needed for `format_args!()`.
     FormatArgument,          sym::format_argument,     format_argument,            Target::Struct,         GenericRequirement::None;

compiler/rustc_span/src/symbol.rs

@@ -550,7 +550,7 @@ symbols! {
         avx512f,
         await_macro,
         bang,
-        begin_panic,
+        panic_with_payload,
         bench,
         bevy_ecs,
         bikeshed_guaranteed_no_drop,

library/std/src/panic.rs

@@ -215,10 +215,10 @@ impl fmt::Display for PanicHookInfo<'_> {
 #[rustc_macro_transparency = "semitransparent"]
 pub macro panic_2015 {
     () => ({
-        $crate::rt::begin_panic("explicit panic")
+        $crate::rt::panic_with_payload("explicit panic")
     }),
     ($msg:expr $(,)?) => ({
-        $crate::rt::begin_panic($msg);
+        $crate::rt::panic_with_payload($msg);
     }),
     // Special-case the single-argument case for const_panic.
     ("{}", $arg:expr $(,)?) => ({
@@ -257,7 +257,7 @@ pub use crate::panicking::{set_hook, take_hook};
 #[track_caller]
 #[cfg_attr(not(test), rustc_diagnostic_item = "panic_any")]
 pub fn panic_any<M: 'static + Any + Send>(msg: M) -> ! {
-    crate::panicking::begin_panic(msg);
+    crate::panicking::panic_with_payload(msg);
 }
 
 #[stable(feature = "catch_unwind", since = "1.9.0")]

library/std/src/panicking.rs

@@ -29,7 +29,7 @@ use crate::{fmt, intrinsics, process, thread};
 
 // This forces codegen of the function called by panic!() inside the std crate, rather than in
 // downstream crates. Primarily this is useful for rustc's codegen tests, which rely on noticing
-// complete removal of panic from generated IR. Since begin_panic is inline(never), it's only
+// complete removal of panic from generated IR. Since panic_with_payload is inline(never), it's only
 // codegen'd once per crate-graph so this pushes that to std rather than our codegen test crates.
 //
 // (See https://github.com/rust-lang/rust/pull/123244 for more info on why).
@@ -41,7 +41,7 @@ use crate::{fmt, intrinsics, process, thread};
 #[allow(dead_code)]
 #[used(compiler)]
 pub static EMPTY_PANIC: fn(&'static str) -> ! =
-    begin_panic::<&'static str> as fn(&'static str) -> !;
+    panic_with_payload::<&'static str> as fn(&'static str) -> !;
 
 // Binary interface to the panic runtime that the standard library depends on.
 //
@@ -650,7 +650,7 @@ pub fn begin_panic_handler(info: &core::panic::PanicInfo<'_>) -> ! {
         fn take_box(&mut self) -> *mut (dyn Any + Send) {
             // 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).
+            // panic_with_payload below).
             let contents = mem::take(self.fill());
             Box::into_raw(Box::new(contents))
         }
@@ -717,15 +717,15 @@ pub fn begin_panic_handler(info: &core::panic::PanicInfo<'_>) -> ! {
 /// panic!() and assert!(). In particular, this is the only entry point that supports
 /// arbitrary payloads, not just format strings.
 #[unstable(feature = "libstd_sys_internals", reason = "used by the panic! macro", issue = "none")]
-#[cfg_attr(not(any(test, doctest)), lang = "begin_panic")]
+#[cfg_attr(not(any(test, doctest)), lang = "panic_with_payload")]
 // lang item for CTFE panic support
 // 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), cold, optimize(size))]
 #[cfg_attr(feature = "panic_immediate_abort", inline)]
 #[track_caller]
 #[rustc_do_not_const_check] // hooked by const-eval
-pub const fn begin_panic<M: Any + Send>(msg: M) -> ! {
+pub const fn panic_with_payload<M: Any + Send>(msg: M) -> ! {
     if cfg!(feature = "panic_immediate_abort") {
         intrinsics::abort()
     }

library/std/src/rt.rs

@@ -17,7 +17,7 @@
 #![allow(unused_macros)]
 
 #[rustfmt::skip]
-pub use crate::panicking::{begin_panic, panic_count};
+pub use crate::panicking::{panic_with_payload, panic_count};
 pub use core::panicking::{panic_display, panic_fmt};
 
 #[rustfmt::skip]

src/doc/rustc-dev-guide/src/compiler-debugging.md

@@ -71,7 +71,7 @@ stack backtrace:
    2: std::panicking::default_hook::{{closure}}
    3: std::panicking::default_hook
    4: std::panicking::rust_panic_with_hook
-   5: std::panicking::begin_panic
+   5: std::panicking::panic_with_payload
    (~~~~ LINES REMOVED BY ME FOR BREVITY ~~~~)
   32: rustc_typeck::check_crate
   33: <std::thread::local::LocalKey<T>>::with

src/tools/clippy/clippy_lints/src/fallible_impl_from.rs

@@ -103,7 +103,7 @@ fn lint_impl_body(cx: &LateContext<'_>, item_def_id: hir::OwnerId, impl_span: Sp
     {
         let impl_item_def_id = impl_item.def_id.expect_local();
 
-        // check the body for `begin_panic` or `unwrap`
+        // check the body for `panic_with_payload` or `unwrap`
         let body = cx.tcx.hir_body_owned_by(impl_item_def_id);
         let mut fpu = FindPanicUnwrap {
             lcx: cx,

src/tools/rust-analyzer/bench_data/numerous_macro_rules

@@ -439,7 +439,7 @@ macro_rules! __ra_macro_fixture437 {($t :  ty , $pmap :  expr , $smap :  expr )=
 macro_rules! __ra_macro_fixture438 {()=>{# [ inline ] fn  is_ascii (&  self )->  bool { self .  is_ascii ()}# [ inline ] fn  to_ascii_uppercase (&  self )->  Self ::  Owned { self .  to_ascii_uppercase ()}# [ inline ] fn  to_ascii_lowercase (&  self )->  Self ::  Owned { self .  to_ascii_lowercase ()}# [ inline ] fn  eq_ignore_ascii_case (&  self ,  o : &  Self )->  bool { self .  eq_ignore_ascii_case ( o )}# [ inline ] fn  make_ascii_uppercase (&  mut  self ){ self .  make_ascii_uppercase (); }# [ inline ] fn  make_ascii_lowercase (&  mut  self ){ self .  make_ascii_lowercase (); }}; }
 macro_rules! __ra_macro_fixture439 {()=>($crate ::  vec ::  Vec ::  new ()); ($elem :  expr ; $n :  expr )=>($crate ::  vec ::  from_elem ($elem , $n )); ($($x :  expr ),+ $(,)?)=>(< [_]>::  into_vec ( box [$($x ),+])); }
 macro_rules! __ra_macro_fixture440 {($left :  expr , $right :  expr $(,)?)=>({ match (&$left , &$right ){( left_val ,  right_val )=>{ if ! (*  left_val == *  right_val ){ panic ! ( r#"assertion failed: `(left == right)`\n  left: `{:?}`,\n right: `{:?}`"# , &*  left_val , &*  right_val )}}}}); ($left :  expr , $right :  expr , $($arg :  tt )+)=>({ match (& ($left ), & ($right )){( left_val ,  right_val )=>{ if ! (*  left_val == *  right_val ){ panic ! ( r#"assertion failed: `(left == right)`\n  left: `{:?}`,\n right: `{:?}`: {}"# , &*  left_val , &*  right_val , $crate ::  format_args ! ($($arg )+))}}}}); }
-macro_rules! __ra_macro_fixture441 {()=>({$crate ::  panic ! ( "explicit panic" )}); ($msg :  expr $(,)?)=>({$crate ::  rt ::  begin_panic ($msg )}); ($fmt :  expr , $($arg :  tt )+)=>({$crate ::  rt ::  begin_panic_fmt (&$crate ::  format_args ! ($fmt , $($arg )+))}); }
+macro_rules! __ra_macro_fixture441 {()=>({$crate ::  panic ! ( "explicit panic" )}); ($msg :  expr $(,)?)=>({$crate ::  rt ::  panic_with_payload ($msg )}); ($fmt :  expr , $($arg :  tt )+)=>({$crate ::  rt ::  begin_panic_fmt (&$crate ::  format_args ! ($fmt , $($arg )+))}); }
 macro_rules! __ra_macro_fixture442 {($expression :  expr , $($pattern :  pat )|+ $(if $guard :  expr )? $(,)?)=>{ match $expression {$($pattern )|+ $(if $guard )? => true , _ => false }}}
 macro_rules! __ra_macro_fixture443 {()=>{# [ inline ] fn  load_consume (&  self )->  Self ::  Val { self .  load ( Ordering ::  Acquire )}}; }
 macro_rules! __ra_macro_fixture444 {($($tt :  tt )*)=>{$($tt )* }}