add error source to panic info

Author: DebugSteven

library/core/src/panic/panic_info.rs

@@ -1,4 +1,5 @@
 use crate::any::Any;
+use crate::error::Error;
 use crate::fmt;
 use crate::panic::Location;
 
@@ -30,6 +31,7 @@ use crate::panic::Location;
 pub struct PanicInfo<'a> {
     payload: &'a (dyn Any + Send),
     message: Option<&'a fmt::Arguments<'a>>,
+    source: Option<&'a (dyn Error + 'static)>,
     location: &'a Location<'a>,
     can_unwind: bool,
 }
@@ -45,10 +47,11 @@ impl<'a> PanicInfo<'a> {
     pub fn internal_constructor(
         message: Option<&'a fmt::Arguments<'a>>,
         location: &'a Location<'a>,
+        source: Option<&'a (dyn Error + 'static)>,
         can_unwind: bool,
     ) -> Self {
         struct NoPayload;
-        PanicInfo { location, message, payload: &NoPayload, can_unwind }
+        PanicInfo { location, message, payload: &NoPayload, source, can_unwind }
     }
 
     #[unstable(
@@ -62,6 +65,12 @@ impl<'a> PanicInfo<'a> {
         self.payload = info;
     }
 
+    #[unstable(feature = "error_in_panic", issue = "none")]
+    /// FIXME
+    pub fn source(&self) -> Option<&(dyn Error + 'static)> {
+        self.source
+    }
+
     /// Returns the payload associated with the panic.
     ///
     /// This will commonly, but not always, be a `&'static str` or [`String`].

library/core/src/panicking.rs

@@ -26,6 +26,7 @@
     issue = "none"
 )]
 
+use crate::error::Error;
 use crate::fmt;
 use crate::panic::{Location, PanicInfo};
 
@@ -50,6 +51,18 @@ const _: () = assert!(cfg!(panic = "abort"), "panic_immediate_abort requires -C
 #[rustc_do_not_const_check] // hooked by const-eval
 #[rustc_const_unstable(feature = "core_panic", issue = "none")]
 pub const fn panic_fmt(fmt: fmt::Arguments<'_>) -> ! {
+    panic_source(fmt, None)
+}
+
+#[cold]
+// If panic_immediate_abort, inline the abort call,
+// otherwise avoid inlining because of it is cold path.
+#[cfg_attr(not(feature = "panic_immediate_abort"), inline(never))]
+#[cfg_attr(feature = "panic_immediate_abort", inline)]
+#[track_caller]
+#[rustc_do_not_const_check] // hooked by const-eval
+#[rustc_const_unstable(feature = "core_panic", issue = "none")]
+pub const fn panic_source(fmt: fmt::Arguments<'_>, source: Option<& (dyn Error + 'static)>) -> ! {
     if cfg!(feature = "panic_immediate_abort") {
         super::intrinsics::abort()
     }
@@ -61,7 +74,7 @@ pub const fn panic_fmt(fmt: fmt::Arguments<'_>) -> ! {
         fn panic_impl(pi: &PanicInfo<'_>) -> !;
     }
 
-    let pi = PanicInfo::internal_constructor(Some(&fmt), Location::caller(), true);
+    let pi = PanicInfo::internal_constructor(Some(&fmt), Location::caller(), source, true);
 
     // SAFETY: `panic_impl` is defined in safe Rust code and thus is safe to call.
     unsafe { panic_impl(&pi) }
@@ -90,7 +103,9 @@ pub fn panic_nounwind_fmt(fmt: fmt::Arguments<'_>) -> ! {
     }
 
     // PanicInfo with the `can_unwind` flag set to false forces an abort.
-    let pi = PanicInfo::internal_constructor(Some(&fmt), Location::caller(), false);
+    let pieces = [msg];
+    let fmt = fmt::Arguments::new_v1(&pieces, &[]);
+    let pi = PanicInfo::internal_constructor(Some(&fmt), Location::caller(), None, false);
 
     // SAFETY: `panic_impl` is defined in safe Rust code and thus is safe to call.
     unsafe { panic_impl(&pi) }

library/std/src/lib.rs

@@ -278,6 +278,7 @@
 #![feature(duration_constants)]
 #![feature(error_generic_member_access)]
 #![feature(error_in_core)]
+#![feature(error_in_panic)]
 #![feature(error_iter)]
 #![feature(exact_size_is_empty)]
 #![feature(exclusive_wrapper)]

library/std/src/panicking.rs

@@ -13,6 +13,7 @@ use crate::panic::BacktraceStyle;
 use core::panic::{BoxMeUp, Location, PanicInfo};
 
 use crate::any::Any;
+use crate::error::Error;
 use crate::fmt;
 use crate::intrinsics;
 use crate::mem::{self, ManuallyDrop};
@@ -258,7 +259,9 @@ fn default_hook(info: &PanicInfo<'_>) {
 
     let write = |err: &mut dyn crate::io::Write| {
         let _ = writeln!(err, "thread '{name}' panicked at '{msg}', {location}");
-
+        if info.source().is_some() {
+            writeln!(err, "fun is not allowed");
+        }
         static FIRST_PANIC: AtomicBool = AtomicBool::new(true);
 
         match backtrace {
@@ -574,15 +577,17 @@ pub fn begin_panic_handler(info: &PanicInfo<'_>) -> ! {
     }
 
     let loc = info.location().unwrap(); // The current implementation always returns Some
+    let source = info.source();
     let msg = info.message().unwrap(); // The current implementation always returns Some
     crate::sys_common::backtrace::__rust_end_short_backtrace(move || {
         if let Some(msg) = msg.as_str() {
-            rust_panic_with_hook(&mut StrPanicPayload(msg), info.message(), loc, info.can_unwind());
+            rust_panic_with_hook(&mut StrPanicPayload(msg), info.message(), loc, source, info.can_unwind());
         } else {
             rust_panic_with_hook(
                 &mut PanicPayload::new(msg),
                 info.message(),
                 loc,
+                source,
                 info.can_unwind(),
             );
         }
@@ -608,7 +613,7 @@ pub const fn begin_panic<M: Any + Send>(msg: M) -> ! {
 
     let loc = Location::caller();
     return crate::sys_common::backtrace::__rust_end_short_backtrace(move || {
-        rust_panic_with_hook(&mut PanicPayload::new(msg), None, loc, true)
+        rust_panic_with_hook(&mut PanicPayload::new(msg), None, loc, None, true)
     });
 
     struct PanicPayload<A> {
@@ -653,6 +658,7 @@ fn rust_panic_with_hook(
     payload: &mut dyn BoxMeUp,
     message: Option<&fmt::Arguments<'_>>,
     location: &Location<'_>,
+    source: Option<& (dyn Error + 'static)>,
     can_unwind: bool,
 ) -> ! {
     let (must_abort, panics) = panic_count::increase();
@@ -670,13 +676,13 @@ fn rust_panic_with_hook(
         } else {
             // Unfortunately, this does not print a backtrace, because creating
             // a `Backtrace` will allocate, which we must to avoid here.
-            let panicinfo = PanicInfo::internal_constructor(message, location, can_unwind);
+            let panicinfo = PanicInfo::internal_constructor(message, location, source, can_unwind);
             rtprintpanic!("{panicinfo}\npanicked after panic::always_abort(), aborting.\n");
         }
         crate::sys::abort_internal();
     }
 
-    let mut info = PanicInfo::internal_constructor(message, location, can_unwind);
+    let mut info = PanicInfo::internal_constructor(message, location, source, can_unwind);
     let hook = HOOK.read().unwrap_or_else(PoisonError::into_inner);
     match *hook {
         // Some platforms (like wasm) know that printing to stderr won't ever actually

src/test/ui/error-trait/error-in-panic.rs

@@ -0,0 +1,33 @@
+// run-fail
+// check-run-results
+
+#![allow(unused_imports)]
+#![feature(core_panic)]
+#![feature(error_in_core)]
+
+extern crate core;
+
+use core::panicking::panic_source;
+use core::error;
+
+#[derive (Debug)]
+struct MyErr;
+
+use std::fmt;
+impl fmt::Display for MyErr {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> Result<(), std::fmt::Error> {
+        write!(f, "my source error message")
+    }
+}
+
+impl error::Error for MyErr {
+
+}
+
+fn main() {
+    std::env::set_var("RUST_BACKTRACE", "full");
+    let source = MyErr;
+    //FIXME make the function do the Some wrapping for us
+    panic_source(format_args!("here's my panic error message"), Some(&source));
+
+}