Enable passing String and custom struct boxed slices across ABI and implement TryFrom<JsValue> for custom structs

crates/backend/src/codegen.rs

@@ -148,6 +148,7 @@ impl ToTokens for ast::Struct {
         let name_chars = name_str.chars().map(|c| c as u32);
         let new_fn = Ident::new(&shared::new_function(&name_str), Span::call_site());
         let free_fn = Ident::new(&shared::free_function(&name_str), Span::call_site());
+        let unwrap_fn = Ident::new(&shared::unwrap_function(&name_str), Span::call_site());
         let free_fn_const = Ident::new(&format!("{}__const", free_fn), free_fn.span());
         (quote! {
             #[automatically_derived]
@@ -266,6 +267,90 @@ impl ToTokens for ast::Struct {
                 #[inline]
                 fn is_none(abi: &Self::Abi) -> bool { *abi == 0 }
             }
+
+            #[allow(clippy::all)]
+            impl wasm_bindgen::__rt::core::convert::TryFrom<wasm_bindgen::JsValue> for #name {
+                type Error = ();
+
+                fn try_from(value: wasm_bindgen::JsValue)
+                    -> wasm_bindgen::__rt::std::result::Result<Self, Self::Error> {
+                    let js_ptr = wasm_bindgen::convert::IntoWasmAbi::into_abi(value);
+
+                    #[link(wasm_import_module = "__wbindgen_placeholder__")]
+                    #[cfg(all(target_arch = "wasm32", not(target_os = "emscripten")))]
+                    extern "C" {
+                        fn #unwrap_fn(ptr: u32) -> u32;
+                    }
+
+                    #[cfg(not(all(target_arch = "wasm32", not(target_os = "emscripten"))))]
+                    unsafe fn #unwrap_fn(_: u32) -> u32 {
+                        panic!("cannot convert from JsValue outside of the wasm target")
+                    }
+
+                    let ptr;
+                    unsafe {
+                        ptr = #unwrap_fn(js_ptr);
+                    }
+
+                    if(ptr == 0) {
+                        wasm_bindgen::__rt::std::result::Result::Err(())
+                    } else {
+                        unsafe {
+                            wasm_bindgen::__rt::std::result::Result::Ok(
+                                <Self as wasm_bindgen::convert::FromWasmAbi>::from_abi(ptr)
+                            )
+                        }
+                    }
+                }
+            }
+
+            impl wasm_bindgen::describe::WasmDescribeVector for #name {
+                fn describe_vector() {
+                    use wasm_bindgen::__rt::std::boxed::Box;
+                    <Box<[#name]> as wasm_bindgen::convert::JsValueVector>::describe();
+                }
+            }
+
+            impl wasm_bindgen::convert::VectorIntoWasmAbi for #name {
+                type Abi = <
+                    wasm_bindgen::__rt::std::boxed::Box<[#name]>
+                    as wasm_bindgen::convert::JsValueVector
+                >::ToAbi;
+
+                fn vector_into_abi(
+                    vector: wasm_bindgen::__rt::std::boxed::Box<[#name]>
+                ) -> Self::Abi {
+                    use wasm_bindgen::__rt::std::boxed::Box;
+
+                    <Box<[#name]> as wasm_bindgen::convert::JsValueVector>::into_abi(vector)
+                }
+            }
+
+            impl wasm_bindgen::convert::OptionVectorIntoWasmAbi for #name {
+                fn vector_none() -> <
+                    wasm_bindgen::__rt::std::boxed::Box<[#name]>
+                    as wasm_bindgen::convert::JsValueVector
+                >::ToAbi {
+                    use wasm_bindgen::__rt::std::boxed::Box;
+                    <Box<[#name]> as wasm_bindgen::convert::JsValueVector>::none()
+                }
+            }
+
+            impl wasm_bindgen::convert::VectorFromWasmAbi for #name {
+                type Abi = <
+                    wasm_bindgen::__rt::std::boxed::Box<[#name]>
+                    as wasm_bindgen::convert::JsValueVector
+                >::FromAbi;
+
+                unsafe fn vector_from_abi(
+                    js: Self::Abi
+                ) -> wasm_bindgen::__rt::std::boxed::Box<[#name]> {
+                    use wasm_bindgen::__rt::std::boxed::Box;
+
+                    <Box<[#name]> as wasm_bindgen::convert::JsValueVector>::from_abi(js)
+                }
+            }
+
         })
         .to_tokens(tokens);
 

crates/cli-support/src/js/mod.rs

@@ -65,6 +65,7 @@ pub struct ExportedClass {
     typescript: String,
     has_constructor: bool,
     wrap_needed: bool,
+    unwrap_needed: bool,
     /// Whether to generate helper methods for inspecting the class
     is_inspectable: bool,
     /// All readable properties of the class
@@ -844,6 +845,20 @@ impl<'a> Context<'a> {
             ));
         }
 
+        if class.unwrap_needed {
+            dst.push_str(&format!(
+                "
+                static __unwrap(jsValue) {{
+                    if (!(jsValue instanceof {})) {{
+                        return 0;
+                    }}
+                    return jsValue.__destroy_into_raw();
+                }}
+                ",
+                name,
+            ));
+        }
+
         if self.config.weak_refs {
             self.global(&format!(
                 "const {}Finalization = new FinalizationRegistry(ptr => wasm.{}(ptr));",
@@ -2089,6 +2104,10 @@ impl<'a> Context<'a> {
         require_class(&mut self.exported_classes, name).wrap_needed = true;
     }
 
+    fn require_class_unwrap(&mut self, name: &str) {
+        require_class(&mut self.exported_classes, name).unwrap_needed = true;
+    }
+
     fn add_module_import(&mut self, module: String, name: &str, actual: &str) {
         let rename = if name == actual {
             None
@@ -2918,6 +2937,14 @@ impl<'a> Context<'a> {
                 assert!(!variadic);
                 self.invoke_intrinsic(intrinsic, args, prelude)
             }
+
+            AuxImport::UnwrapExportedClass(class) => {
+                assert!(kind == AdapterJsImportKind::Normal);
+                assert!(!variadic);
+                assert_eq!(args.len(), 1);
+                self.require_class_unwrap(class);
+                Ok(format!("{}.__unwrap({})", class, args[0]))
+            }
         }
     }
 

crates/cli-support/src/wit/mod.rs

@@ -858,17 +858,40 @@ impl<'a> Context<'a> {
         self.aux.structs.push(aux);
 
         let wrap_constructor = wasm_bindgen_shared::new_function(struct_.name);
-        if let Some((import_id, _id)) = self.function_imports.get(&wrap_constructor).cloned() {
+        self.add_aux_import_to_import_map(
+            &wrap_constructor,
+            vec![Descriptor::I32],
+            Descriptor::Externref,
+            AuxImport::WrapInExportedClass(struct_.name.to_string()),
+        )?;
+
+        let unwrap_fn = wasm_bindgen_shared::unwrap_function(struct_.name);
+        self.add_aux_import_to_import_map(
+            &unwrap_fn,
+            vec![Descriptor::Externref],
+            Descriptor::I32,
+            AuxImport::UnwrapExportedClass(struct_.name.to_string()),
+        )?;
+
+        Ok(())
+    }
+
+    fn add_aux_import_to_import_map(
+        &mut self,
+        fn_name: &String,
+        arguments: Vec<Descriptor>,
+        ret: Descriptor,
+        aux_import: AuxImport,
+    ) -> Result<(), Error> {
+        if let Some((import_id, _id)) = self.function_imports.get(fn_name).cloned() {
             let signature = Function {
                 shim_idx: 0,
-                arguments: vec![Descriptor::I32],
-                ret: Descriptor::Externref,
+                arguments,
+                ret,
                 inner_ret: None,
             };
             let id = self.import_adapter(import_id, signature, AdapterJsImportKind::Normal)?;
-            self.aux
-                .import_map
-                .insert(id, AuxImport::WrapInExportedClass(struct_.name.to_string()));
+            self.aux.import_map.insert(id, aux_import);
         }
 
         Ok(())

crates/cli-support/src/wit/nonstandard.rs

@@ -310,6 +310,11 @@ pub enum AuxImport {
     /// This is an intrinsic function expected to be implemented with a JS glue
     /// shim. Each intrinsic has its own expected signature and implementation.
     Intrinsic(Intrinsic),
+
+    /// This import is a generated shim which will attempt to unwrap JsValue to an
+    /// instance of the given exported class. The class name is one that is
+    /// exported from the Rust/wasm.
+    UnwrapExportedClass(String),
 }
 
 /// Values that can be imported verbatim to hook up to an import.

crates/cli-support/src/wit/section.rs

@@ -357,6 +357,9 @@ fn check_standard_import(import: &AuxImport) -> Result<(), Error> {
             format!("wasm-bindgen specific intrinsic `{}`", intrinsic.name())
         }
         AuxImport::Closure { .. } => format!("creating a `Closure` wrapper"),
+        AuxImport::UnwrapExportedClass(name) => {
+            format!("unwrapping a pointer from a `{}` js class wrapper", name)
+        }
     };
     bail!("import of {} requires JS glue", item);
 }

crates/shared/src/lib.rs

@@ -157,6 +157,13 @@ pub fn free_function(struct_name: &str) -> String {
     return name;
 }
 
+pub fn unwrap_function(struct_name: &str) -> String {
+    let mut name = format!("__wbg_");
+    name.extend(struct_name.chars().flat_map(|s| s.to_lowercase()));
+    name.push_str("_unwrap");
+    return name;
+}
+
 pub fn free_function_export_name(function_name: &str) -> String {
     function_name.to_string()
 }

src/convert/impls.rs

@@ -4,8 +4,16 @@ use core::mem::{self, ManuallyDrop};
 use crate::convert::traits::WasmAbi;
 use crate::convert::{FromWasmAbi, IntoWasmAbi, RefFromWasmAbi};
 use crate::convert::{OptionFromWasmAbi, OptionIntoWasmAbi, ReturnWasmAbi};
+use crate::describe::{self, WasmDescribe};
 use crate::{Clamped, JsError, JsValue};
 
+if_std! {
+    use std::boxed::Box;
+    use std::convert::{TryFrom, TryInto};
+    use std::vec::Vec;
+    use crate::convert::JsValueVector;
+}
+
 unsafe impl WasmAbi for () {}
 
 #[repr(C)]
@@ -465,6 +473,43 @@ impl<T: IntoWasmAbi, E: Into<JsValue>> ReturnWasmAbi for Result<T, E> {
     }
 }
 
+if_std! {
+    impl<T> JsValueVector for Box<[T]> where
+        T: Into<JsValue> + TryFrom<JsValue>,
+        <T as TryFrom<JsValue>>::Error: core::fmt::Debug {
+        type ToAbi = <Box<[JsValue]> as IntoWasmAbi>::Abi;
+        type FromAbi = <Box<[JsValue]> as FromWasmAbi>::Abi;
+
+        fn describe() {
+            describe::inform(describe::VECTOR);
+            JsValue::describe();
+        }
+
+        fn into_abi(self) -> Self::ToAbi {
+            let js_vals: Box::<[JsValue]> = self
+                .into_vec()
+                .into_iter()
+                .map(|x| x.into())
+                .collect();
+
+            IntoWasmAbi::into_abi(js_vals)
+        }
+
+        fn none() -> Self::ToAbi {
+            <Box<[JsValue]> as OptionIntoWasmAbi>::none()
+        }
+
+        unsafe fn from_abi(js: Self::FromAbi) -> Self {
+            let js_vals = <Vec<JsValue> as FromWasmAbi>::from_abi(js);
+
+            js_vals
+                .into_iter()
+                .filter_map(|x| x.try_into().ok())
+                .collect()
+        }
+    }
+}
+
 impl IntoWasmAbi for JsError {
     type Abi = <JsValue as IntoWasmAbi>::Abi;