fix(clone): enhance error handling by supporting cause and errors in JsValueStore

Author: akshatnathani

core/runtime/src/clone/tests.rs

@@ -19,3 +19,56 @@ fn clones_error_objects() {
         ),
     ]);
 }
+
+#[test]
+fn clones_error_object_cause() {
+    run_test_actions([
+        TestAction::harness(),
+        TestAction::run(
+            r#"
+                const original = new Error("boom", { cause: { code: 7 } });
+                const cloned = structuredClone(original);
+
+                assert(cloned instanceof Error);
+                assert(cloned.cause !== original.cause);
+                assertEq(cloned.cause.code, 7);
+            "#,
+        ),
+    ]);
+}
+
+#[test]
+fn clones_aggregate_error_entries() {
+    run_test_actions([
+        TestAction::harness(),
+        TestAction::run(
+            r#"
+                const original = new AggregateError([new Error("inner")], "agg");
+                const cloned = structuredClone(original);
+
+                assert(cloned instanceof AggregateError);
+                assertEq(cloned.message, "agg");
+                assertEq(cloned.errors.length, 1);
+                assert(cloned.errors[0] instanceof Error);
+                assertEq(cloned.errors[0].message, "inner");
+            "#,
+        ),
+    ]);
+}
+
+#[test]
+fn clones_error_with_undefined_cause_property() {
+    run_test_actions([
+        TestAction::harness(),
+        TestAction::run(
+            r#"
+                const original = new Error("boom", { cause: undefined });
+                const cloned = structuredClone(original);
+
+                assert(Object.hasOwn(original, "cause"));
+                assert(Object.hasOwn(cloned, "cause"));
+                assertEq(cloned.cause, undefined);
+            "#,
+        ),
+    ]);
+}

core/runtime/src/message/tests.rs

@@ -96,6 +96,92 @@ fn basic_error_message() {
     );
 }
 
+#[test]
+fn basic_error_with_object_cause() {
+    let context = &mut Context::default();
+
+    let sender = OnMessageQueueSender::create(context);
+    message::register(sender, None, context).unwrap();
+
+    run_test_actions_with(
+        [
+            TestAction::harness(),
+            TestAction::run(
+                r#"
+                let latestMessage = null;
+                function onMessageQueue(message) {
+                    latestMessage = message;
+                }
+
+                const message = new Error("boom", { cause: { code: 7 } });
+                postMessage(message);
+                assert(latestMessage === null);
+            "#,
+            ),
+            TestAction::inspect_context(move |context| {
+                drop(future::block_on(future::poll_once(
+                    context
+                        .downcast_job_executor::<SimpleJobExecutor>()
+                        .expect("")
+                        .run_jobs_async(&RefCell::new(context)),
+                )));
+            }),
+            TestAction::run(
+                r#"
+                assert(latestMessage instanceof Error);
+                assert(latestMessage !== message);
+                assertEq(latestMessage.message, "boom");
+                assertEq(latestMessage.cause.code, 7);
+            "#,
+            ),
+        ],
+        context,
+    );
+}
+
+#[test]
+fn basic_error_with_undefined_cause_property() {
+    let context = &mut Context::default();
+
+    let sender = OnMessageQueueSender::create(context);
+    message::register(sender, None, context).unwrap();
+
+    run_test_actions_with(
+        [
+            TestAction::harness(),
+            TestAction::run(
+                r#"
+                let latestMessage = null;
+                function onMessageQueue(message) {
+                    latestMessage = message;
+                }
+
+                const message = new Error("boom", { cause: undefined });
+                postMessage(message);
+                assert(latestMessage === null);
+            "#,
+            ),
+            TestAction::inspect_context(move |context| {
+                drop(future::block_on(future::poll_once(
+                    context
+                        .downcast_job_executor::<SimpleJobExecutor>()
+                        .expect("")
+                        .run_jobs_async(&RefCell::new(context)),
+                )));
+            }),
+            TestAction::run(
+                r#"
+                assert(latestMessage instanceof Error);
+                assert(latestMessage !== message);
+                assert(Object.hasOwn(latestMessage, "cause"));
+                assertEq(latestMessage.cause, undefined);
+            "#,
+            ),
+        ],
+        context,
+    );
+}
+
 #[test]
 fn shared_multi_thread() {
     let (sender, receiver) = std::sync::mpsc::channel::<OnMessageQueueSender>();

core/runtime/src/store/from.rs

@@ -186,9 +186,13 @@ fn clone_regexp(
 
 fn clone_error(
     original: &JsObject,
+    transfer: &HashSet<JsObject>,
     seen: &mut SeenMap,
     context: &mut Context,
 ) -> JsResult<JsValueStore> {
+    let mut store = JsValueStore::empty();
+    seen.insert(original, store.clone());
+
     let native = JsError::from_opaque(JsValue::from(original.clone()))
         .try_native(context)
         .map_err(|_| unsupported_type())?;
@@ -215,17 +219,51 @@ fn clone_error(
 
     let name = to_optional_string("name", context)?;
     let stack = to_optional_string("stack", context)?;
-    let cause = to_optional_string("cause", context)?;
-
-    let stored = JsValueStore::new(ValueStoreInner::Error {
-        kind,
-        name: name.into(),
-        message: JsString::from(native.message()).into(),
-        stack: stack.into(),
-        cause: cause.into(),
-    });
-    seen.insert(original, stored.clone());
-    Ok(stored)
+
+    let cause = if original.has_own_property(js_string!("cause"), context)? {
+        let cause = original.get(js_string!("cause"), context)?;
+        Some(try_from_js_value(&cause, transfer, seen, context)?)
+    } else {
+        None
+    };
+
+    let errors = if matches!(kind, ErrorKind::Aggregate) {
+        let errors = original.get(js_string!("errors"), context)?;
+        if errors.is_undefined() {
+            Vec::new()
+        } else {
+            let Some(errors) = errors.as_object() else {
+                return Err(unsupported_type());
+            };
+
+            let errors = JsArray::from_object(errors).map_err(|_| unsupported_type())?;
+
+            let length = errors.length(context)?;
+            let length = usize::try_from(length).map_err(JsError::from_rust)?;
+            let mut values = Vec::with_capacity(length);
+            for i in 0..length {
+                let value = errors.get(i, context)?;
+                values.push(try_from_js_value(&value, transfer, seen, context)?);
+            }
+            values
+        }
+    } else {
+        Vec::new()
+    };
+
+    // SAFETY: This is safe as this function is the sole owner of the store.
+    unsafe {
+        store.replace(ValueStoreInner::Error {
+            kind,
+            name: name.into(),
+            message: JsString::from(native.message()).into(),
+            stack: stack.into(),
+            cause,
+            errors,
+        });
+    }
+
+    Ok(store)
 }
 
 fn try_from_map(
@@ -306,7 +344,7 @@ fn try_from_js_object_clone(
     } else if let Ok(ref date) = JsDate::from_object(object.clone()) {
         return clone_date(object, date, seen, context);
     } else if object.downcast_ref::<Error>().is_some() {
-        return clone_error(object, seen, context);
+        return clone_error(object, transfer, seen, context);
     } else if let Ok(ref regexp) = JsRegExp::from_object(object.clone()) {
         return clone_regexp(object, regexp, seen, context);
     } else if let Ok(_dataview) = JsDataView::from_object(object.clone()) {

core/runtime/src/store/mod.rs

@@ -101,7 +101,8 @@ enum ValueStoreInner {
         name: StringStore,
         message: StringStore,
         stack: StringStore,
-        cause: StringStore,
+        cause: Option<JsValueStore>,
+        errors: Vec<JsValueStore>,
     },
 
     /// Regular expression. We store the expression and its flags. Everything else

core/runtime/src/store/to.rs

@@ -20,7 +20,8 @@ type ErrorStoreFields<'a> = (
     &'a StringStore,
     &'a StringStore,
     &'a StringStore,
-    &'a StringStore,
+    &'a Option<JsValueStore>,
+    &'a [JsValueStore],
 );
 
 impl ReverseSeenMap {
@@ -167,7 +168,7 @@ fn try_into_js_error(
     seen: &mut ReverseSeenMap,
     context: &mut Context,
 ) -> JsResult<JsValue> {
-    let (kind, name, message, stack, cause) = error_data;
+    let (kind, name, message, stack, cause, errors) = error_data;
     let message = message.to_js_string().to_std_string_escaped();
     let native = match kind {
         ErrorKind::Aggregate => JsNativeError::aggregate(Vec::new()),
@@ -194,11 +195,26 @@ fn try_into_js_error(
         error.set(js_string!("stack"), stack, true, context)?;
     }
 
-    let cause = cause.to_js_string();
-    if !cause.is_empty() {
+    if let Some(cause) = cause {
+        let cause = try_value_into_js(cause, seen, context)?;
         error.set(js_string!("cause"), cause, true, context)?;
     }
 
+    if !errors.is_empty() {
+        let errors_array = JsArray::new(context)?;
+        for (index, value) in errors.iter().enumerate() {
+            let value = try_value_into_js(value, seen, context)?;
+            errors_array.set(index, value, true, context)?;
+        }
+
+        error.set(
+            js_string!("errors"),
+            JsValue::from(errors_array),
+            true,
+            context,
+        )?;
+    }
+
     Ok(JsValue::from(error))
 }
 
@@ -265,7 +281,13 @@ pub(super) fn try_value_into_js(
             message,
             stack,
             cause,
-        } => try_into_js_error(store, (kind, name, message, stack, cause), seen, context),
+            errors,
+        } => try_into_js_error(
+            store,
+            (kind, name, message, stack, cause, errors),
+            seen,
+            context,
+        ),
         ValueStoreInner::RegExp { source, flags } => {
             try_into_regexp(store, source, flags, seen, context)
         }