Simplify ErrBox-to-class mapping & hook it up to core json ops (#7195)

1 files changed, 12 insertions, 21 deletions

diff --git a/core/core_isolate.rs b/core/core_isolate.rs
index f4acbd1ac..a60ce6a82 100644
--- a/core/core_isolate.rs
+++ b/core/core_isolate.rs
@@ -87,16 +87,7 @@ impl StartupData<'_> {
 
 type JSErrorCreateFn = dyn Fn(JSError) -> ErrBox;
 
-pub trait RustErrToJsonFn: for<'e> Fn(&'e ErrBox) -> Box<[u8]> {}
-impl<F> RustErrToJsonFn for F where for<'e> F: Fn(&'e ErrBox) -> Box<[u8]> {}
-
-fn rust_err_to_json(e: &ErrBox) -> Box<[u8]> {
-  let value = json!({
-    "kind": "Error",
-    "message": e.to_string()
-  });
-  serde_json::to_vec(&value).unwrap().into_boxed_slice()
-}
+pub type GetErrorClassFn = &'static dyn for<'e> Fn(&'e ErrBox) -> &'static str;
 
 /// Objects that need to live as long as the isolate
 #[derive(Default)]
@@ -134,7 +125,7 @@ pub struct CoreIsolateState {
   pub(crate) js_macrotask_cb: Option<v8::Global<v8::Function>>,
   pub(crate) pending_promise_exceptions: HashMap<i32, v8::Global<v8::Value>>,
   pub(crate) js_error_create_fn: Box<JSErrorCreateFn>,
-  pub rust_err_to_json_fn: &'static dyn RustErrToJsonFn,
+  pub get_error_class_fn: GetErrorClassFn,
   pub(crate) shared: SharedQueue,
   pending_ops: FuturesUnordered<PendingOpFuture>,
   pending_unref_ops: FuturesUnordered<PendingOpFuture>,
@@ -319,7 +310,7 @@ impl CoreIsolate {
       js_recv_cb: None,
       js_macrotask_cb: None,
       js_error_create_fn: Box::new(JSError::create),
-      rust_err_to_json_fn: &rust_err_to_json,
+      get_error_class_fn: &|_| "Error",
       shared: SharedQueue::new(RECOMMENDED_SIZE),
       pending_ops: FuturesUnordered::new(),
       pending_unref_ops: FuturesUnordered::new(),
@@ -457,7 +448,7 @@ impl CoreIsolate {
       move |state: &mut CoreIsolateState, bufs: &mut [ZeroCopyBuf]| -> Op {
         let value = serde_json::from_slice(&bufs[0]).unwrap();
         let result = op(state, value, &mut bufs[1..]);
-        let buf = serialize_result(None, result);
+        let buf = serialize_result(None, result, state.get_error_class_fn);
         Op::Sync(buf)
       };
 
@@ -475,11 +466,13 @@ impl CoreIsolate {
     let core_op = move |state: &mut CoreIsolateState,
                         bufs: &mut [ZeroCopyBuf]|
           -> Op {
+      let get_error_class_fn = state.get_error_class_fn;
       let value: serde_json::Value = serde_json::from_slice(&bufs[0]).unwrap();
       let promise_id = value.get("promiseId").unwrap().as_u64().unwrap();
       let fut = op(state, value, &mut bufs[1..]);
-      let fut2 =
-        fut.map(move |result| serialize_result(Some(promise_id), result));
+      let fut2 = fut.map(move |result| {
+        serialize_result(Some(promise_id), result, get_error_class_fn)
+      });
       Op::Async(Box::pin(fut2))
     };
 
@@ -546,13 +539,14 @@ where
 fn serialize_result(
   promise_id: Option<u64>,
   result: Result<Value, ErrBox>,
+  get_error_class_fn: GetErrorClassFn,
 ) -> Buf {
   let value = match result {
     Ok(v) => json!({ "ok": v, "promiseId": promise_id }),
     Err(err) => json!({
       "promiseId": promise_id ,
       "err": {
-        "kind": "Error",
+        "className": (get_error_class_fn)(&err),
         "message": err.to_string(),
       }
     }),
@@ -681,11 +675,8 @@ impl CoreIsolateState {
     self.js_error_create_fn = Box::new(f);
   }
 
-  pub fn set_rust_err_to_json_fn(
-    &mut self,
-    f: &'static (impl for<'e> Fn(&'e ErrBox) -> Box<[u8]> + 'static),
-  ) {
-    self.rust_err_to_json_fn = f;
+  pub fn set_get_error_class_fn(&mut self, f: GetErrorClassFn) {
+    self.get_error_class_fn = f;
   }
 
   pub fn dispatch_op<'s>(