Export "C" async functions may return a Result or a normal type.

This adds a helper trait `FromJsValue`.

Author: rodrigorc

crates/backend/src/codegen.rs

@@ -973,8 +973,11 @@ impl TryToTokens for ast::ImportFunction {
             Some(ref ty) => {
                 if self.function.r#async {
                     abi_ret = quote! { js_sys::Promise };
-                    convert_ret = quote! {
-                        wasm_bindgen_futures::JsFuture::from(#ret_ident).await
+                    let future = quote! { wasm_bindgen_futures::JsFuture::from(#ret_ident).await };
+                    convert_ret = if self.catch {
+                        quote! { Ok(<#ty as wasm_bindgen::FromJsValue>::from_js_value(#future?)) }
+                    } else {
+                        quote! { <#ty as wasm_bindgen::FromJsValue>::from_js_value(#future.expect("uncaught exception")) }
                     };
                 } else {
                     abi_ret = quote! {
@@ -988,18 +991,22 @@ impl TryToTokens for ast::ImportFunction {
             }
             None => {
                 if self.function.r#async {
-                    bail_span!(
-                        self.rust_name,
-                        "an imported async function must return a Result<JsValue, JsValue>"
-                        );
+                    abi_ret = quote! { js_sys::Promise };
+                    let future = quote! { wasm_bindgen_futures::JsFuture::from(#ret_ident).await };
+                    convert_ret = if self.catch {
+                        quote! { #future?; Ok(()) }
+                    } else {
+                        quote! { #future.expect("uncaught exception"); }
+                    };
+                } else {
+                    abi_ret = quote! { () };
+                    convert_ret = quote! { () };
                 }
-                abi_ret = quote! { () };
-                convert_ret = quote! { () };
             }
         }
 
         let mut exceptional_ret = quote!();
-        if self.catch {
+        if self.catch && !self.function.r#async {
             convert_ret = quote! { Ok(#convert_ret) };
             exceptional_ret = quote! {
                 wasm_bindgen::__rt::take_last_exception()?;

src/lib.rs

@@ -479,6 +479,17 @@ macro_rules! numbers {
                 JsValue::from_f64(n.into())
             }
         }
+
+        impl FromJsValue for $n {
+            #[inline]
+            fn from_js_value(j: JsValue) -> $n {
+                match j.as_f64() {
+                    Some(x) => x as $n,
+                    None => $n::default()
+                }
+            }
+        }
+
     )*)
 }
 
@@ -1172,3 +1183,41 @@ impl<T> DerefMut for Clamped<T> {
         &mut self.0
     }
 }
+
+/// A trait to convert a JsValue into another type.
+pub trait FromJsValue {
+    fn from_js_value(j: JsValue) -> Self;
+}
+
+impl<T: JsCast> FromJsValue for T {
+    fn from_js_value(j: JsValue) -> T {
+        T::unchecked_from_js(j)
+    }
+}
+
+impl<T: FromJsValue> FromJsValue for Option<T> {
+    fn from_js_value(j: JsValue) -> Option<T> {
+        if j.is_null() || j.is_undefined() {
+            None
+        } else {
+            Some(T::from_js_value(j))
+        }
+    }
+}
+
+if_std! {
+    impl FromJsValue for String {
+        fn from_js_value(j: JsValue) -> String {
+            match j.as_string() {
+                Some(s) => s,
+                None => String::new(),
+            }
+        }
+    }
+}
+
+impl FromJsValue for bool {
+    fn from_js_value(j: JsValue) -> bool {
+        j.is_truthy()
+    }
+}