Merge #960

960: Improve panic messages in init/terminate callbacks r=Bromeon a=Bromeon

Fixes #959.

Co-authored-by: Jan Haller <[email protected]>

Author: bors[bot]

gdnative-core/src/export/method.rs

@@ -876,11 +876,12 @@ unsafe extern "C" fn method_wrapper<C: NativeClass, F: Method<C>>(
     });
 
     result
-        .unwrap_or_else(|_| {
+        .unwrap_or_else(|e| {
             crate::log::error(
                 F::site().unwrap_or_default(),
                 "gdnative-core: method panicked (check stderr for output)",
             );
+            crate::private::print_panic_error(e);
             Variant::nil()
         })
         .leak()

gdnative-core/src/export/property/accessor.rs

@@ -252,8 +252,9 @@ where
                 }
             });
 
-            result.unwrap_or_else(|_| {
+            result.unwrap_or_else(|e| {
                 godot_error!("gdnative-core: property setter panicked (check stderr for output)");
+                crate::private::print_panic_error(e);
             })
         }
         set.set_func = Some(invoke::<SelfArg, C, F, T>);
@@ -324,8 +325,9 @@ where
                 }
             });
 
-            result.unwrap_or_else(|_| {
+            result.unwrap_or_else(|e| {
                 godot_error!("gdnative-core: property getter panicked (check stderr for output)");
+                crate::private::print_panic_error(e);
                 Variant::nil().leak()
             })
         }

gdnative-core/src/init/init_handle.rs

@@ -123,11 +123,12 @@ impl InitHandle {
                         })
                     })) {
                         Ok(val) => val,
-                        Err(_) => {
+                        Err(e) => {
                             godot_error!(
                                 "gdnative-core: error constructing {}: constructor panicked",
                                 class_registry::class_name_or_default::<C>(),
                             );
+                            crate::private::print_panic_error(e);
                             return ptr::null_mut();
                         }
                     };

gdnative-core/src/init/macros.rs

@@ -56,13 +56,9 @@ macro_rules! godot_nativescript_init {
                 }
             }
 
-            let __result = ::std::panic::catch_unwind(|| {
+            $crate::private::report_panics("nativescript_init", || {
                 $callback($crate::init::InitHandle::new(handle));
             });
-
-            if __result.is_err() {
-                $crate::godot_error!("gdnative-core: nativescript_init callback panicked");
-            }
         }
     };
 }
@@ -104,13 +100,10 @@ macro_rules! godot_gdnative_init {
                 return;
             }
 
-            let __result = ::std::panic::catch_unwind(|| {
-                let callback_options = $crate::init::InitializeInfo::new(options);
-                $callback(&callback_options)
+            $crate::private::report_panics("gdnative_init", || {
+                let init_info = $crate::init::InitializeInfo::new(options);
+                $callback(&init_info)
             });
-            if __result.is_err() {
-                $crate::godot_error!("gdnative-core: gdnative_init callback panicked");
-            }
         }
     };
 }
@@ -152,13 +145,10 @@ macro_rules! godot_gdnative_terminate {
                 return;
             }
 
-            let __result = ::std::panic::catch_unwind(|| {
+            $crate::private::report_panics("gdnative_terminate", || {
                 let term_info = $crate::init::TerminateInfo::new(options);
                 $callback(&term_info)
             });
-            if __result.is_err() {
-                $crate::godot_error!("gdnative-core: nativescript_init callback panicked");
-            }
 
             $crate::private::cleanup_internal_state();
         }

gdnative-core/src/private.rs

@@ -1,4 +1,5 @@
 use std::ffi::CString;
+use std::panic::{catch_unwind, UnwindSafe};
 
 use crate::sys;
 
@@ -181,6 +182,26 @@ unsafe fn report_init_error(
     }
 }
 
+#[inline]
+pub fn report_panics(context: &str, callback: impl FnOnce() + UnwindSafe) {
+    let __result = catch_unwind(callback);
+
+    if let Err(e) = __result {
+        godot_error!("gdnative-core: {} callback panicked", context);
+        print_panic_error(e);
+    }
+}
+
+pub(crate) fn print_panic_error(err: Box<dyn std::any::Any + Send>) {
+    if let Some(s) = err.downcast_ref::<String>() {
+        godot_error!("Panic message: {}", s);
+    } else if let Some(s) = err.downcast_ref::<&'static str>() {
+        godot_error!("Panic message: {}", s);
+    } else {
+        godot_error!("Panic message unknown, type {:?}", err.type_id());
+    }
+}
+
 pub mod godot_object {
     pub trait Sealed {}
 }