Better model panics

crates/fj-proc/src/lib.rs

@@ -2,7 +2,11 @@ mod expand;
 mod parse;
 
 use proc_macro::TokenStream;
-use syn::{parse_macro_input, FnArg, ItemFn};
+use proc_macro2::{Ident, Span};
+use syn::{
+ parse_macro_input, punctuated::Punctuated, token::Paren, Expr, ExprCall,
+ ExprPath, FnArg, ItemFn, PathArguments, PathSegment, Stmt,
+};
 
 /// Define a function-based model.
 ///
@@ -91,13 +95,67 @@ pub fn model(_: TokenStream, input: TokenStream) -> TokenStream {
 
  match parse::parse(&item) {
  Ok(init) => {
- let item = without_param_attrs(item);
+ let mut item = without_param_attrs(item);
+
+ // Yes, all of this is to add `fj::abi::initialize_panic_handling();` to the top of the function.
+ item.block.stmts.insert(
+ 0,
+ Stmt::Semi(
+ Expr::Call(ExprCall {
+ attrs: vec![],
+ func: Box::new(Expr::Path(ExprPath {
+ attrs: vec![],
+ qself: None,
+ path: syn::Path {
+ leading_colon: None,
+ segments: {
+ let mut segments = Punctuated::new();
+
+ segments.push(PathSegment {
+ ident: Ident::new(
+ "fj",
+ Span::call_site(),
+ ),
+ arguments: PathArguments::None,
+ });
+
+ segments.push(PathSegment {
+ ident: Ident::new(
+ "abi",
+ Span::call_site(),
+ ),
+ arguments: PathArguments::None,
+ });
+
+ segments.push(PathSegment {
+ ident: Ident::new(
+ "initialize_panic_handling",
+ Span::call_site(),
+ ),
+ arguments: PathArguments::None,
+ });
+
+ segments
+ },
+ },
+ })),
+ paren_token: Paren {
+ span: Span::call_site(),
+ },
+ args: Punctuated::new(),
+ }),
+ syn::token::Semi::default(),
+ ),
+ );
 
  let tokens = quote::quote! {
  #item
  #init
+
  };
 
+ eprintln!("TOKENS: {}", tokens);
+
  tokens.into()
  }
  Err(e) => e.into_compile_error().into(),

crates/fj/src/abi/mod.rs

@@ -43,7 +43,7 @@ mod host;
 mod metadata;
 mod model;
 
-use std::any::Any;
+use std::{any::Any, fmt::Display, panic, sync::Mutex};
 
 pub use self::{
  context::Context,
@@ -118,15 +118,89 @@ pub type ModelMetadataResult =
 ///
 pub const INIT_FUNCTION_NAME: &str = "fj_model_init";
 
-fn on_panic(payload: Box<dyn Any + Send>) -> crate::abi::ffi_safe::String {
- let msg: &str =
- if let Some(s) = payload.downcast_ref::<std::string::String>() {
- s.as_str()
- } else if let Some(s) = payload.downcast_ref::<&str>() {
- s
+// Contains details about a panic that we need to pass back to the application from the panic hook.
+struct PanicInfo {
+ message: Option<String>,
+ location: Option<Location>,
+}
+
+impl Display for PanicInfo {
+ fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+ let message = self
+ .message
+ .as_ref()
+ .map_or("No error given", |message| message.as_str());
+
+ write!(f, "\"{}\", ", message)?;
+
+ if let Some(location) = self.location.as_ref() {
+ write!(f, "{}", location)?;
+ } else {
+ write!(f, "no location given")?;
+ }
+
+ Ok(())
+ }
+}
+
+struct Location {
+ file: String,
+ line: u32,
+ column: u32,
+}
+
+impl Display for Location {
+ fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+ write!(f, "{}:{}:{}", self.file, self.line, self.column)
+ }
+}
+
+static LAST_PANIC: Mutex<Option<PanicInfo>> = Mutex::new(None);
+
+/// Capturing panics is something Rust really doesn't want you to do, and as such, they make it convoluted.
+/// This sets up all the machinery in the background to pull it off.
+///
+/// It's okay to call this multiple times.
+pub fn initialize_panic_handling() {
+ panic::set_hook(Box::new(|panic_info| {
+ let mut last_panic =
+ LAST_PANIC.lock().expect("Panic queue was poisoned."); // FIXME that can probably overflow the stack.
+ let message = if let Some(s) =
+ panic_info.payload().downcast_ref::<std::string::String>()
+ {
+ Some(s.as_str())
  } else {
- "A panic occurred"
- };
+ panic_info.payload().downcast_ref::<&str>().copied()
+ }
+ .map(|s| s.to_string());
 
- crate::abi::ffi_safe::String::from(msg.to_string())
+ let location = panic_info.location().map(|location| Location {
+ file: location.file().to_string(),
+ line: location.line(),
+ column: location.column(),
+ });
+
+ *last_panic = Some(PanicInfo { message, location });
+ }));
+}
+
+fn on_panic(_payload: Box<dyn Any + Send>) -> crate::abi::ffi_safe::String {
+ // The payload is technically no longer needed, but I left it there just in case a change to `catch_unwind` made
+ // it useful again.
+ if let Ok(mut panic_info) = LAST_PANIC.lock() {
+ if let Some(panic_info) = panic_info.take() {
+ crate::abi::ffi_safe::String::from(format!(
+ "Panic in model: {}",
+ panic_info
+ ))
+ } else {
+ crate::abi::ffi_safe::String::from(
+ "Panic in model: No details were given.".to_string(),
+ )
+ }
+ } else {
+ crate::abi::ffi_safe::String::from(
+ "Panic in model, but due to a poisoned panic queue the information could not be collected."
+ .to_string())
+ }
 }