Generate TypeScript return types for async functions (rustwasm#2665)

* Generate TypeScript return types for `async` functions

* Fix tests to respect returning only `Result<T, JsValue>`

* Fix smoke test

* add `simple_async_fn` to `typescript-tests`

* cleanup and set JsDoc comment correctly for `Promise<void>`

* clean up now that `ts_ret_ty` is complete w/ Promise

* add `.d.ts` reference tests

* add async reference tests

* don't test `.js` and `.wat` in async reference tests

.gitignore

@@ -6,7 +6,6 @@ node_modules
 package-lock.json
 npm-shrinkwrap.json
 yarn.lock
-*.d.ts
 /publish
 /publish.exe
 .vscode

crates/backend/src/codegen.rs

@@ -459,9 +459,10 @@ impl TryToTokens for ast::Export {
         // For an `async` function we always run it through `future_to_promise`
         // since we're returning a promise to JS, and this will implicitly
         // require that the function returns a `Future<Output = Result<...>>`
-        let (ret_ty, ret_expr) = if self.function.r#async {
+        let (ret_ty, inner_ret_ty, ret_expr) = if self.function.r#async {
             if self.start {
                 (
+                    quote! { () },
                     quote! { () },
                     quote! {
                         wasm_bindgen_futures::spawn_local(async move {
@@ -472,6 +473,7 @@ impl TryToTokens for ast::Export {
             } else {
                 (
                     quote! { wasm_bindgen::JsValue },
+                    quote! { #syn_ret },
                     quote! {
                         wasm_bindgen_futures::future_to_promise(async move {
                             <#syn_ret as wasm_bindgen::__rt::IntoJsResult>::into_js_result(#ret.await)
@@ -481,17 +483,19 @@ impl TryToTokens for ast::Export {
             }
         } else if self.start {
             (
+                quote! { () },
                 quote! { () },
                 quote! { <#syn_ret as wasm_bindgen::__rt::Start>::start(#ret) },
             )
         } else {
-            (quote! { #syn_ret }, quote! { #ret })
+            (quote! { #syn_ret }, quote! { #syn_ret }, quote! { #ret })
         };
 
         let projection = quote! { <#ret_ty as wasm_bindgen::convert::ReturnWasmAbi> };
         let convert_ret = quote! { #projection::return_abi(#ret_expr) };
         let describe_ret = quote! {
             <#ret_ty as WasmDescribe>::describe();
+            <#inner_ret_ty as WasmDescribe>::describe();
         };
         let nargs = self.function.arguments.len() as u32;
         let attrs = &self.function.rust_attrs;
@@ -1171,6 +1175,7 @@ impl<'a> ToTokens for DescribeImport<'a> {
                 inform(#nargs);
                 #(<#argtys as WasmDescribe>::describe();)*
                 #inform_ret
+                #inform_ret
             },
             attrs: f.function.rust_attrs.clone(),
         }

crates/backend/src/encode.rs

@@ -205,6 +205,7 @@ fn shared_function<'a>(func: &'a ast::Function, _intern: &'a Interner) -> Functi
         .collect::<Vec<_>>();
     Function {
         arg_names,
+        asyncness: func.r#async,
         name: &func.name,
         generate_typescript: func.generate_typescript,
     }

crates/cli-support/src/descriptor.rs

@@ -76,6 +76,7 @@ pub struct Function {
     pub arguments: Vec<Descriptor>,
     pub shim_idx: u32,
     pub ret: Descriptor,
+    pub inner_ret: Option<Descriptor>,
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
@@ -237,6 +238,7 @@ impl Function {
             arguments,
             shim_idx,
             ret: Descriptor::_decode(data, false),
+            inner_ret: Some(Descriptor::_decode(data, false)),
         }
     }
 }

crates/cli-support/src/intrinsic.rs

@@ -45,6 +45,7 @@ macro_rules! intrinsics {
                                 shim_idx: 0,
                                 arguments: vec![$($arg),*],
                                 ret: $ret,
+                                inner_ret: None
                             }
                         }
                     )*

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

@@ -101,6 +101,7 @@ impl<'a, 'b> Builder<'a, 'b> {
         adapter: &Adapter,
         instructions: &[InstructionData],
         explicit_arg_names: &Option<Vec<String>>,
+        asyncness: bool,
     ) -> Result<JsFunction, Error> {
         if self
             .cx
@@ -223,8 +224,9 @@ impl<'a, 'b> Builder<'a, 'b> {
         let (ts_sig, ts_arg_tys, ts_ret_ty) = self.typescript_signature(
             &function_args,
             &arg_tys,
-            &adapter.results,
+            &adapter.inner_results,
             &mut might_be_optional_field,
+            asyncness,
         );
         let js_doc = self.js_doc_comments(&function_args, &arg_tys, &ts_ret_ty);
         Ok(JsFunction {
@@ -250,6 +252,7 @@ impl<'a, 'b> Builder<'a, 'b> {
         arg_tys: &[&AdapterType],
         result_tys: &[AdapterType],
         might_be_optional_field: &mut bool,
+        asyncness: bool,
     ) -> (String, Vec<String>, Option<String>) {
         // Build up the typescript signature as well
         let mut omittable = true;
@@ -298,6 +301,9 @@ impl<'a, 'b> Builder<'a, 'b> {
                 1 => adapter2ts(&result_tys[0], &mut ret),
                 _ => ret.push_str("[any]"),
             }
+            if asyncness {
+                ret = format!("Promise<{}>", ret);
+            }
             ts.push_str(&ret);
             ts_ret = Some(ret);
         }

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

@@ -2325,9 +2325,11 @@ impl<'a> Context<'a> {
         });
         builder.catch(catch);
         let mut arg_names = &None;
+        let mut asyncness = false;
         match kind {
             Kind::Export(export) => {
                 arg_names = &export.arg_names;
+                asyncness = export.asyncness;
                 match &export.kind {
                     AuxExportKind::Function(_) => {}
                     AuxExportKind::StaticFunction { .. } => {}
@@ -2352,7 +2354,7 @@ impl<'a> Context<'a> {
             catch,
             log_error,
         } = builder
-            .process(&adapter, instrs, arg_names)
+            .process(&adapter, instrs, arg_names, asyncness)
             .with_context(|| match kind {
                 Kind::Export(e) => format!("failed to generate bindings for `{}`", e.debug_name),
                 Kind::Import(i) => {

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

@@ -188,6 +188,7 @@ impl<'a> Context<'a> {
                     shim_idx: 0,
                     arguments: vec![Descriptor::I32; 3],
                     ret: Descriptor::Externref,
+                    inner_ret: None,
                 };
                 let id = self.import_adapter(*id, signature, AdapterJsImportKind::Normal)?;
                 // Synthesize the two integer pointers we pass through which
@@ -455,6 +456,7 @@ impl<'a> Context<'a> {
                 debug_name: wasm_name,
                 comments: concatenate_comments(&export.comments),
                 arg_names: Some(export.function.arg_names),
+                asyncness: export.function.asyncness,
                 kind,
                 generate_typescript: export.function.generate_typescript,
             },
@@ -720,6 +722,7 @@ impl<'a> Context<'a> {
                 arguments: Vec::new(),
                 shim_idx: 0,
                 ret: descriptor,
+                inner_ret: None,
             },
             AdapterJsImportKind::Normal,
         )?;
@@ -748,6 +751,7 @@ impl<'a> Context<'a> {
                 arguments: vec![Descriptor::Ref(Box::new(Descriptor::Externref))],
                 shim_idx: 0,
                 ret: Descriptor::Boolean,
+                inner_ret: None,
             },
             AdapterJsImportKind::Normal,
         )?;
@@ -797,13 +801,15 @@ impl<'a> Context<'a> {
                 arguments: vec![Descriptor::I32],
                 shim_idx: 0,
                 ret: descriptor.clone(),
+                inner_ret: None,
             };
             let getter_id = self.export_adapter(getter_id, getter_descriptor)?;
             self.aux.export_map.insert(
                 getter_id,
                 AuxExport {
                     debug_name: format!("getter for `{}::{}`", struct_.name, field.name),
                     arg_names: None,
+                    asyncness: false,
                     comments: concatenate_comments(&field.comments),
                     kind: AuxExportKind::Getter {
                         class: struct_.name.to_string(),
@@ -824,13 +830,15 @@ impl<'a> Context<'a> {
                 arguments: vec![Descriptor::I32, descriptor],
                 shim_idx: 0,
                 ret: Descriptor::Unit,
+                inner_ret: None,
             };
             let setter_id = self.export_adapter(setter_id, setter_descriptor)?;
             self.aux.export_map.insert(
                 setter_id,
                 AuxExport {
                     debug_name: format!("setter for `{}::{}`", struct_.name, field.name),
                     arg_names: None,
+                    asyncness: false,
                     comments: concatenate_comments(&field.comments),
                     kind: AuxExportKind::Setter {
                         class: struct_.name.to_string(),
@@ -855,6 +863,7 @@ impl<'a> Context<'a> {
                 shim_idx: 0,
                 arguments: vec![Descriptor::I32],
                 ret: Descriptor::Externref,
+                inner_ret: None,
             };
             let id = self.import_adapter(import_id, signature, AdapterJsImportKind::Normal)?;
             self.aux
@@ -981,6 +990,7 @@ impl<'a> Context<'a> {
             let id = self.adapters.append(
                 params,
                 results,
+                vec![],
                 AdapterKind::Import {
                     module: import.module.clone(),
                     name: import.name.clone(),
@@ -1015,6 +1025,7 @@ impl<'a> Context<'a> {
                 self.adapters.append(
                     params,
                     results,
+                    vec![],
                     AdapterKind::Local {
                         instructions: Vec::new(),
                     },
@@ -1066,6 +1077,7 @@ impl<'a> Context<'a> {
                 debug_name: format!("standard export {:?}", id),
                 comments: String::new(),
                 arg_names: None,
+                asyncness: false,
                 kind,
                 generate_typescript: true,
             };
@@ -1204,6 +1216,7 @@ impl<'a> Context<'a> {
         let f = args.cx.adapters.append(
             args.output,
             ret.input,
+            vec![],
             AdapterKind::Import {
                 module: import_module,
                 name: import_name,
@@ -1237,10 +1250,12 @@ impl<'a> Context<'a> {
         } else {
             ret.output
         };
-        let id = args
-            .cx
-            .adapters
-            .append(args.input, results, AdapterKind::Local { instructions });
+        let id = args.cx.adapters.append(
+            args.input,
+            results,
+            vec![],
+            AdapterKind::Local { instructions },
+        );
         args.cx.adapters.implements.push((import_id, core_id, id));
         Ok(f)
     }
@@ -1279,6 +1294,15 @@ impl<'a> Context<'a> {
         }
 
         // ... then the returned value being translated back
+
+        let inner_ret_output = if signature.inner_ret.is_some() {
+            let mut inner_ret = args.cx.instruction_builder(true);
+            inner_ret.outgoing(&signature.inner_ret.unwrap())?;
+            inner_ret.output
+        } else {
+            vec![]
+        };
+
         let mut ret = args.cx.instruction_builder(true);
         ret.outgoing(&signature.ret)?;
         let uses_retptr = ret.input.len() > 1;
@@ -1334,10 +1358,12 @@ impl<'a> Context<'a> {
         }
         instructions.extend(ret.instructions);
 
-        Ok(ret
-            .cx
-            .adapters
-            .append(args.input, ret.output, AdapterKind::Local { instructions }))
+        Ok(ret.cx.adapters.append(
+            args.input,
+            ret.output,
+            inner_ret_output,
+            AdapterKind::Local { instructions },
+        ))
     }
 
     fn instruction_builder<'b>(&'b mut self, return_position: bool) -> InstructionBuilder<'b, 'a> {

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

@@ -71,6 +71,8 @@ pub struct AuxExport {
     /// Argument names in Rust forwarded here to configure the names that show
     /// up in TypeScript bindings.
     pub arg_names: Option<Vec<String>>,
+    /// Whether this is an async function, to configure the TypeScript return value.
+    pub asyncness: bool,
     /// What kind of function this is and where it shows up
     pub kind: AuxExportKind,
     /// Whether typescript bindings should be generated for this export.

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

@@ -26,6 +26,7 @@ pub struct Adapter {
     pub id: AdapterId,
     pub params: Vec<AdapterType>,
     pub results: Vec<AdapterType>,
+    pub inner_results: Vec<AdapterType>,
     pub kind: AdapterKind,
 }
 
@@ -368,6 +369,7 @@ impl NonstandardWitSection {
         &mut self,
         params: Vec<AdapterType>,
         results: Vec<AdapterType>,
+        inner_results: Vec<AdapterType>,
         kind: AdapterKind,
     ) -> AdapterId {
         let id = AdapterId(self.adapters.len());
@@ -377,6 +379,7 @@ impl NonstandardWitSection {
                 id,
                 params,
                 results,
+                inner_results,
                 kind,
             },
         );

crates/cli/tests/reference.rs

@@ -66,12 +66,14 @@ fn runtest(test: &Path) -> Result<()> {
 
             [dependencies]
             wasm-bindgen = {{ path = '{}' }}
+            wasm-bindgen-futures = {{ path = '{}/crates/futures' }}
 
             [lib]
             crate-type = ['cdylib']
             path = '{}'
         ",
         repo_root().display(),
+        repo_root().display(),
         test.display(),
     );
     let interface_types = contents.contains("// interface-types");
@@ -93,11 +95,7 @@ fn runtest(test: &Path) -> Result<()> {
         .join("reference_test.wasm");
 
     let mut bindgen = Command::cargo_bin("wasm-bindgen")?;
-    bindgen
-        .arg("--out-dir")
-        .arg(td.path())
-        .arg(&wasm)
-        .arg("--no-typescript");
+    bindgen.arg("--out-dir").arg(td.path()).arg(&wasm);
     if contents.contains("// enable-externref") {
         bindgen.env("WASM_BINDGEN_EXTERNREF", "1");
     }
@@ -112,10 +110,14 @@ fn runtest(test: &Path) -> Result<()> {
         let wat = sanitize_wasm(&wasm)?;
         assert_same(&wat, &test.with_extension("wat"))?;
     } else {
-        let js = fs::read_to_string(td.path().join("reference_test_bg.js"))?;
-        assert_same(&js, &test.with_extension("js"))?;
-        let wat = sanitize_wasm(&td.path().join("reference_test_bg.wasm"))?;
-        assert_same(&wat, &test.with_extension("wat"))?;
+        if !contents.contains("async") {
+            let js = fs::read_to_string(td.path().join("reference_test_bg.js"))?;
+            assert_same(&js, &test.with_extension("js"))?;
+            let wat = sanitize_wasm(&td.path().join("reference_test_bg.wasm"))?;
+            assert_same(&wat, &test.with_extension("wat"))?;
+        }
+        let d_ts = fs::read_to_string(td.path().join("reference_test.d.ts"))?;
+        assert_same(&d_ts, &test.with_extension("d.ts"))?;
     }
 
     Ok(())

crates/cli/tests/reference/add.d.ts

@@ -0,0 +1,14 @@
+/* tslint:disable */
+/* eslint-disable */
+/**
+* @param {number} a
+* @param {number} b
+* @returns {number}
+*/
+export function add_u32(a: number, b: number): number;
+/**
+* @param {number} a
+* @param {number} b
+* @returns {number}
+*/
+export function add_i32(a: number, b: number): number;

crates/cli/tests/reference/anyref-empty.d.ts

@@ -0,0 +1,2 @@
+/* tslint:disable */
+/* eslint-disable */