use core::ffi::c_void;
use std::cell::Cell;
use std::collections::HashSet;
use std::sync::atomic::{AtomicPtr, Ordering};
use std::sync::{Mutex, OnceLock};
use crate::capi;
use crate::glue;
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u32)]
pub enum ErrKind {
PumpCallback = 1,
Listener = 2,
UnhandledRejection = 3,
Reported = 4,
}
impl ErrKind {
fn tag(self) -> &'static str {
match self {
ErrKind::PumpCallback => "[js:uncaught]",
ErrKind::Listener => "[js:listener]",
ErrKind::UnhandledRejection => "[js:unhandled-rejection]",
ErrKind::Reported => "[js:uncaught]",
}
}
}
static HANDLER: AtomicPtr<c_void> = AtomicPtr::new(core::ptr::null_mut());
pub fn set_handler(handler: *const c_void) {
HANDLER.store(handler as *mut c_void, Ordering::Release);
}
thread_local! {
static REPORTING: Cell<bool> = const { Cell::new(false) };
}
pub(crate) unsafe fn report(g: *mut c_void, exc: u64, kind: ErrKind) {
if REPORTING.with(|r| r.replace(true)) {
return; }
let h = HANDLER.load(Ordering::Acquire);
if h.is_null() {
let (header, stack) = describe(g, exc);
if stack.is_empty() {
eprintln!("{} {header}", kind.tag());
} else {
eprintln!("{} {header}\n{stack}", kind.tag());
}
} else {
let f: unsafe extern "C" fn(*mut c_void, u64) = core::mem::transmute(h);
f(g, exc);
}
REPORTING.with(|r| r.set(false));
}
pub(crate) unsafe fn describe(g: *mut c_void, exc: u64) -> (String, String) {
let mut msg_v = 0u64;
let mut stack_v = 0u64;
glue::rjs_error_info(g, exc, &mut msg_v, &mut stack_v);
let stack = read_string(g, stack_v);
let name = read_string_prop(g, exc, "name");
let msg = read_string_prop(g, exc, "message");
let header = match (name.is_empty(), msg.is_empty()) {
(false, false) => format!("{name}: {msg}"),
(false, true) => name,
(true, false) => msg,
(true, true) => {
let mut s = 0u64;
if glue::rjs_to_string(g, exc, &mut s) == 0 { read_string(g, s) } else { String::new() }
}
};
(header, stack)
}
unsafe fn read_string_prop(g: *mut c_void, obj: u64, key: &str) -> String {
const KIND_STRING: u32 = 5;
let atom = glue::rjs_atom8(g, key.as_ptr(), key.len());
if atom.is_null() {
return String::new();
}
let mut v = 0u64;
let rc = glue::rjs_get(g, obj, atom, &mut v);
glue::rjs_atom_free(g, atom);
if rc != 0 || glue::rjs_kind(g, v) != KIND_STRING {
return String::new();
}
read_string(g, v)
}
unsafe fn read_string(g: *mut c_void, v: u64) -> String {
let mut info = crate::glue::RjsStr::default();
if glue::rjs_string_info(g, v, &mut info) != 0 || info.len == 0 {
return String::new();
}
if info.is8bit != 0 {
let bytes = core::slice::from_raw_parts(info.ptr as *const u8, info.len as usize);
bytes.iter().map(|&b| b as char).collect()
} else {
let units = core::slice::from_raw_parts(info.ptr as *const u16, info.len as usize);
String::from_utf16_lossy(units)
}
}
#[crate::host_fn]
unsafe fn on_unhandled_rejection(g: *mut c_void, cf: *mut c_void) -> u64 {
let args = crate::api::HostArgs::new(cf);
let reason = args.arg(1).0;
report(g, reason, ErrKind::UnhandledRejection);
let mut pending = 0u64;
glue::rjs_exception_pending(g, &mut pending);
crate::api::Value::undefined().0
}
fn installed() -> &'static Mutex<HashSet<usize>> {
static SET: OnceLock<Mutex<HashSet<usize>>> = OnceLock::new();
SET.get_or_init(|| Mutex::new(HashSet::new()))
}
pub(crate) fn forget(gone: crate::context::Gone) {
installed().lock().unwrap().remove(&gone.key);
}
#[cfg(test)]
pub(crate) fn rejection_armed(g: *mut c_void) -> bool {
installed().lock().unwrap().contains(&(g as usize))
}
pub unsafe fn install_rejection(g: *mut c_void) -> i32 {
crate::context::ensure(g);
if !installed().lock().unwrap().insert(g as usize) {
return 0;
}
let name: Vec<u16> = "onUnhandledRejection".encode_utf16().collect();
let mut f = 0u64;
let rc = glue::rjs_function_create(
g,
name.as_ptr(),
name.len(),
2,
on_unhandled_rejection as *const c_void,
&mut f,
);
if rc != 0 {
return rc;
}
capi::JSValueProtect(g, f as usize as capi::JSValueRef);
let mut exc: capi::JSValueRef = core::ptr::null();
capi::JSGlobalContextSetUnhandledRejectionCallback(g, f as usize as capi::JSObjectRef, &mut exc);
if !exc.is_null() {
return crate::ffi::REDJS_EXCEPTION;
}
0
}
#[cfg(test)]
mod tests {
use super::*;
use crate::api::Context;
use std::collections::HashMap;
fn reports() -> &'static Mutex<HashMap<usize, Vec<String>>> {
static R: OnceLock<Mutex<HashMap<usize, Vec<String>>>> = OnceLock::new();
R.get_or_init(|| Mutex::new(HashMap::new()))
}
unsafe extern "C" fn record(g: *mut c_void, exc: u64) {
let (header, stack) = describe(g, exc);
reports().lock().unwrap().entry(g as usize).or_default().push(format!("{header}\u{1}{stack}"));
}
fn ctx() -> Context {
let c = Context::new();
set_handler(record as *const c_void);
c
}
fn taken(c: &Context) -> Vec<String> {
c.drain_microtasks();
reports().lock().unwrap().remove(&(c.raw() as usize)).unwrap_or_default()
}
fn headers(v: &[String]) -> Vec<&str> {
v.iter().map(|s| s.split('\u{1}').next().unwrap()).collect()
}
#[test]
fn an_unawaited_async_throw_is_reported() {
let c = ctx();
c.eval("(async () => { throw new Error('async boom'); })();").unwrap();
let got = taken(&c);
assert_eq!(headers(&got), vec!["Error: async boom"], "got {got:?}");
}
#[test]
fn a_bare_promise_rejection_is_reported() {
let c = ctx();
c.eval("Promise.reject(new TypeError('bare boom'));").unwrap();
let got = taken(&c);
assert_eq!(headers(&got), vec!["TypeError: bare boom"], "got {got:?}");
}
#[test]
fn a_handled_rejection_is_not_reported() {
let c = ctx();
c.eval("Promise.reject(new Error('caught')).catch(() => {});").unwrap();
assert_eq!(taken(&c), Vec::<String>::new(), "a .catch()-ed rejection must stay silent");
c.eval("Promise.reject(new Error('loud'));").unwrap();
assert_eq!(headers(&taken(&c)), vec!["Error: loud"]);
}
#[test]
fn an_awaited_throw_inside_a_try_is_not_reported() {
let c = ctx();
c.eval("(async () => { try { await Promise.reject(new Error('handled')); } catch (e) {} })();").unwrap();
assert_eq!(taken(&c), Vec::<String>::new());
}
#[test]
fn the_report_carries_the_message_and_the_stack_separately() {
let c = ctx();
c.eval_named("function boom() { throw new Error('has a message'); }\nPromise.resolve().then(boom);", "game/main.js")
.unwrap();
let got = taken(&c);
assert_eq!(got.len(), 1, "got {got:?}");
let (header, stack) = got[0].split_once('\u{1}').unwrap();
assert_eq!(header, "Error: has a message");
assert!(stack.contains("boom"), "stack should name the frame, got {stack:?}");
assert!(!stack.contains("has a message"), "JSC stacks carry no message — if this fires, the join above is now double-printing");
}
#[test]
fn a_non_error_reason_still_reports() {
let c = ctx();
c.eval("Promise.reject(42); Promise.reject('a string'); Promise.reject({ nope: 1 }); Promise.reject(); Promise.reject(null);")
.unwrap();
let got = taken(&c);
assert_eq!(
headers(&got),
vec!["42", "a string", "[object Object]", "undefined", "null"],
"got {got:?}"
);
}
#[test]
fn a_rejection_from_a_pumped_callback_is_reported_too() {
let c = ctx();
unsafe { crate::ffi::redjs_web_install(c.raw()) };
c.eval("requestAnimationFrame(async () => { throw new Error('frame boom'); });").unwrap();
unsafe { crate::ffi::redjs_pump(c.raw(), 7, core::ptr::null_mut()) };
assert_eq!(headers(&taken(&c)), vec!["Error: frame boom"]);
}
}