Forward error messages when converting to js types

Author: siefkenj

tests/wasm.rs

@@ -1,3 +1,5 @@
+use core::panic;
+
 use serde::{Deserialize, Serialize};
 use tsify_next::Tsify;
 use wasm_bindgen::prelude::*;
@@ -35,7 +37,9 @@ function validate(value, validation) {
     validation(value); 
 }
 
-module.exports = { validate };
+function noop(value) {}
+
+module.exports = { validate, noop };
 "#)]
 extern "C" {
     #[wasm_bindgen(catch, js_name = "validate")]
@@ -49,6 +53,9 @@ extern "C" {
         value: SimpleData,
         validation: &dyn Fn(&SimpleData),
     ) -> Result<(), JsValue>;
+
+    #[wasm_bindgen(catch, js_name = "noop")]
+    pub fn do_not_serialize(value: CantBeSerialized) -> Result<(), JsValue>;
 }
 
 #[wasm_bindgen_test]
@@ -68,3 +75,29 @@ fn test_convert_simple_value_type() {
     })
     .unwrap_throw();
 }
+
+// Test that the error message encountered during serialization is propagated to the caller
+#[derive(Debug, PartialEq, Deserialize, Tsify, Clone)]
+#[tsify(into_wasm_abi)]
+struct CantBeSerialized {
+    value: i32,
+}
+
+impl Serialize for CantBeSerialized {
+    fn serialize<S>(&self, _serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        Err(serde::ser::Error::custom(
+            "This type can't be serialized NO_SERIALIZE",
+        ))
+    }
+}
+
+#[wasm_bindgen_test]
+#[should_panic(expected = "NO_SERIALIZE")]
+fn test_data_that_cant_be_serialized_throws_an_appropriate_error() {
+    let val = CantBeSerialized { value: 42 };
+
+    let _ = do_not_serialize(val);
+}

tsify-next-macros/src/wasm_bindgen.rs

@@ -101,7 +101,20 @@ fn expand_into_wasm_abi(cont: &Container) -> TokenStream {
 
             #[inline]
             fn into_abi(self) -> Self::Abi {
-                self.into_js().unwrap_throw().into_abi()
+                // wasm_bindgen doesn't forward the error message from the `into_js` result.
+                // https://github.com/rustwasm/wasm-bindgen/issues/2732
+                // Until that issue is fixed, we don't directly use `unwrap_throw()` and instead build our
+                // own error message.
+                // Convert to `self.into_js().unwrap_throw().into_abi()` when fixed.
+                match self.into_js() {
+                    Ok(js) => js.into_abi(),
+                    Err(err) => {
+                        let loc = core::panic::Location::caller();
+                        let msg = format!("(Converting type failed) {} ({}:{}:{})", err, loc.file(), loc.line(), loc.column());
+                        // In theory, `wasm_bindgen::throw_str(&msg)` should work, but the error emitted by `wasm_bindgen::throw_str` cannot be picked up by `#[should_panic(expect = ...)]` in tests, so we use a regular panic.
+                        panic!("{}", msg);
+                    }
+                }
             }
         }
 
@@ -115,7 +128,20 @@ fn expand_into_wasm_abi(cont: &Container) -> TokenStream {
         impl #impl_generics From<#ident #ty_generics> for JsValue #where_clause {
             #[inline]
             fn from(value: #ident #ty_generics) -> Self {
-                value.into_js().unwrap_throw().into()
+                // wasm_bindgen doesn't forward the error message from the `into_js` result.
+                // https://github.com/rustwasm/wasm-bindgen/issues/2732
+                // Until that issue is fixed, we don't directly use `unwrap_throw()` and instead build our
+                // own error message.
+                // Convert to `value.into_js().unwrap_throw().into()` when fixed.
+                match value.into_js() {
+                    Ok(js) => js.into(),
+                    Err(err) => {
+                        let loc = core::panic::Location::caller();
+                        let msg = format!("(Converting type failed) {} ({}:{}:{})", err, loc.file(), loc.line(), loc.column());
+                        // In theory, `wasm_bindgen::throw_str(&msg)` should work, but the error emitted by `wasm_bindgen::throw_str` cannot be picked up by `#[should_panic(expect = ...)]` in tests, so we use a regular panic.
+                        panic!("{}", msg);
+                    }
+                }
             }
         }
     }