Get futures to work with emscripten mode

Author: google-yfyang

.cargo/config.toml

@@ -6,6 +6,7 @@ runner = 'cargo run -p wasm-bindgen-cli --bin wasm-bindgen-test-runner --'
 [target.'cfg(all(target_arch = "wasm32", target_os = "emscripten"))']
 rustflags = [
   "-Cllvm-args=-enable-emscripten-cxx-exceptions=0",
+  "-Clink-arg=-sERROR_ON_UNDEFINED_SYMBOLS=0",
   "-Clink-arg=-Wno-undefined",
   "-Crelocation-model=static",
 ]

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

@@ -9,6 +9,7 @@ use crate::wit::InstructionData;
 use crate::wit::{
     Adapter, AdapterId, AdapterKind, AdapterType, AuxFunctionArgumentData, Instruction,
 };
+use crate::OutputMode;
 use anyhow::{anyhow, bail, Error};
 use std::collections::HashSet;
 use std::fmt::Write;
@@ -130,7 +131,7 @@ impl<'a, 'b> Builder<'a, 'b> {
         debug_name: &str,
         ret_ty_override: &Option<String>,
         ret_desc: &Option<String>,
-        import_deps: &mut Vec<String>,
+        import_deps: &mut HashSet<String>,
     ) -> Result<JsFunction, Error> {
         if self
             .cx
@@ -257,15 +258,15 @@ impl<'a, 'b> Builder<'a, 'b> {
         };
 
         if self.catch {
-            js.cx.expose_handle_error()?;
+            js.cx.expose_handle_error(import_deps)?;
         }
 
         // Generate a try/catch block in debug mode which handles unexpected and
         // unhandled exceptions, typically used on imports. This currently just
         // logs what happened, but keeps the exception being thrown to propagate
         // elsewhere.
         if self.log_error {
-            js.cx.expose_log_error();
+            js.cx.expose_log_error(import_deps);
         }
 
         code.push_str(&call);
@@ -641,11 +642,11 @@ impl<'a, 'b> JsBuilder<'a, 'b> {
         self.prelude(&format!("_assertBoolean({});", arg));
     }
 
-    fn assert_optional_number(&mut self, arg: &str) {
+    fn assert_optional_number(&mut self, arg: &str, import_deps: &mut HashSet<String>) {
         if !self.cx.config.debug {
             return;
         }
-        self.cx.expose_is_like_none();
+        self.cx.expose_is_like_none(import_deps);
         self.prelude(&format!("if (!isLikeNone({})) {{", arg));
         self.assert_number(arg);
         self.prelude("}");
@@ -661,21 +662,21 @@ impl<'a, 'b> JsBuilder<'a, 'b> {
         self.prelude(&format!("_assertChar({});", arg));
     }
 
-    fn assert_optional_bigint(&mut self, arg: &str) {
+    fn assert_optional_bigint(&mut self, arg: &str, import_deps: &mut HashSet<String>) {
         if !self.cx.config.debug {
             return;
         }
-        self.cx.expose_is_like_none();
+        self.cx.expose_is_like_none(import_deps);
         self.prelude(&format!("if (!isLikeNone({})) {{", arg));
         self.assert_bigint(arg);
         self.prelude("}");
     }
 
-    fn assert_optional_bool(&mut self, arg: &str) {
+    fn assert_optional_bool(&mut self, arg: &str, import_deps: &mut HashSet<String>) {
         if !self.cx.config.debug {
             return;
         }
-        self.cx.expose_is_like_none();
+        self.cx.expose_is_like_none(import_deps);
         self.prelude(&format!("if (!isLikeNone({})) {{", arg));
         self.assert_bool(arg);
         self.prelude("}");
@@ -700,8 +701,9 @@ impl<'a, 'b> JsBuilder<'a, 'b> {
         mem: walrus::MemoryId,
         malloc: walrus::FunctionId,
         realloc: Option<walrus::FunctionId>,
+        import_deps: &mut HashSet<String>,
     ) -> Result<(), Error> {
-        let pass = self.cx.expose_pass_string_to_wasm(mem)?;
+        let pass = self.cx.expose_pass_string_to_wasm(mem, import_deps)?;
         let val = self.pop();
         let malloc = self.cx.export_name_of(malloc);
         let i = self.tmp();
@@ -720,6 +722,7 @@ impl<'a, 'b> JsBuilder<'a, 'b> {
         self.prelude(&format!("const len{} = WASM_VECTOR_LEN;", i));
         self.push(format!("ptr{}", i));
         self.push(format!("len{}", i));
+        import_deps.insert(format!("'${}'", pass));
         Ok(())
     }
 }
@@ -729,7 +732,7 @@ fn instruction(
     instr: &Instruction,
     log_error: &mut bool,
     constructor: &Option<String>,
-    import_deps: &mut Vec<String>,
+    import_deps: &mut HashSet<String>,
 ) -> Result<(), Error> {
     fn wasm_to_string_enum(name: &str, index: &str) -> String {
         // e.g. ["a","b","c"][someIndex]
@@ -880,8 +883,8 @@ fn instruction(
 
         Instruction::OptionInt128ToWasm => {
             let val = js.pop();
-            js.cx.expose_is_like_none();
-            js.assert_optional_bigint(&val);
+            js.cx.expose_is_like_none(import_deps);
+            js.assert_optional_bigint(&val, import_deps);
             let (low, high) = int128_to_int64x2(&val);
             js.push(format!("!isLikeNone({val})"));
             js.push(format!("isLikeNone({val}) ? BigInt(0) : {low}"));
@@ -924,7 +927,7 @@ fn instruction(
             let enum_val = js.pop();
             js.cx.expose_string_enum(name);
             let enum_val_expr = string_enum_to_wasm(name, *invalid, &enum_val);
-            js.cx.expose_is_like_none();
+            js.cx.expose_is_like_none(import_deps);
 
             // e.g. isLikeNone(someEnumVal) ? 4 : (string_enum_to_wasm(someEnumVal))
             js.push(format!(
@@ -944,7 +947,7 @@ fn instruction(
             malloc,
             realloc,
         } => {
-            js.string_to_memory(*mem, *malloc, *realloc)?;
+            js.string_to_memory(*mem, *malloc, *realloc, import_deps)?;
         }
 
         Instruction::Retptr { size } => {
@@ -969,7 +972,7 @@ fn instruction(
             // Note that we always assume the return pointer is argument 0,
             // which is currently the case for LLVM.
             let val = js.pop();
-            let expr = format!(
+            let mut expr = format!(
                 "{}().{}({} + {} * {}, {}, true);",
                 mem,
                 method,
@@ -978,6 +981,16 @@ fn instruction(
                 offset,
                 val,
             );
+            if matches!(js.cx.config.mode, OutputMode::Emscripten) {
+                expr = format!(
+                    "HEAP_DATA_VIEW.{}({} + {} * {}, {}, true);",
+                    method,
+                    js.arg(0),
+                    size,
+                    offset,
+                    val,
+                );
+            }
             js.prelude(&expr);
         }
 
@@ -997,10 +1010,18 @@ fn instruction(
             // If we're loading from the return pointer then we must have pushed
             // it earlier, and we always push the same value, so load that value
             // here
-            let expr = format!(
+            let mut expr = format!(
                 "{}().{}(retptr + {} * {}, true)",
                 mem, method, size, scaled_offset
             );
+
+            if matches!(js.cx.config.mode, OutputMode::Emscripten) {
+                expr = format!(
+                    "HEAP_DATA_VIEW.{}(retptr + {} * {}, true)",
+                    method, size, scaled_offset
+                );
+            }
+
             js.prelude(&format!("var r{} = {};", offset, expr));
             js.push(format!("r{}", offset));
         }
@@ -1053,7 +1074,7 @@ fn instruction(
 
         Instruction::I32FromOptionRust { class } => {
             let val = js.pop();
-            js.cx.expose_is_like_none();
+            js.cx.expose_is_like_none(import_deps);
             let i = js.tmp();
             js.prelude(&format!("let ptr{} = 0;", i));
             js.prelude(&format!("if (!isLikeNone({0})) {{", val));
@@ -1066,10 +1087,12 @@ fn instruction(
 
         Instruction::I32FromOptionExternref { table_and_alloc } => {
             let val = js.pop();
-            js.cx.expose_is_like_none();
+            js.cx.expose_is_like_none(import_deps);
             match table_and_alloc {
                 Some((table, alloc)) => {
-                    let alloc = js.cx.expose_add_to_externref_table(*table, *alloc)?;
+                    let alloc = js
+                        .cx
+                        .expose_add_to_externref_table(*table, *alloc, import_deps)?;
                     js.push(format!("isLikeNone({0}) ? 0 : {1}({0})", val, alloc));
                 }
                 None => {
@@ -1081,22 +1104,22 @@ fn instruction(
 
         Instruction::I32FromOptionU32Sentinel => {
             let val = js.pop();
-            js.cx.expose_is_like_none();
-            js.assert_optional_number(&val);
+            js.cx.expose_is_like_none(import_deps);
+            js.assert_optional_number(&val, import_deps);
             js.push(format!("isLikeNone({0}) ? 0xFFFFFF : {0}", val));
         }
 
         Instruction::I32FromOptionBool => {
             let val = js.pop();
-            js.cx.expose_is_like_none();
-            js.assert_optional_bool(&val);
+            js.cx.expose_is_like_none(import_deps);
+            js.assert_optional_bool(&val, import_deps);
             js.push(format!("isLikeNone({0}) ? 0xFFFFFF : {0} ? 1 : 0", val));
         }
 
         Instruction::I32FromOptionChar => {
             let val = js.pop();
             let i = js.tmp();
-            js.cx.expose_is_like_none();
+            js.cx.expose_is_like_none(import_deps);
             js.prelude(&format!(
                 "const char{i} = isLikeNone({0}) ? 0xFFFFFF : {0}.codePointAt(0);",
                 val
@@ -1111,15 +1134,15 @@ fn instruction(
 
         Instruction::I32FromOptionEnum { hole } => {
             let val = js.pop();
-            js.cx.expose_is_like_none();
-            js.assert_optional_number(&val);
+            js.cx.expose_is_like_none(import_deps);
+            js.assert_optional_number(&val, import_deps);
             js.push(format!("isLikeNone({0}) ? {1} : {0}", val, hole));
         }
 
         Instruction::F64FromOptionSentinelInt { signed } => {
             let val = js.pop();
-            js.cx.expose_is_like_none();
-            js.assert_optional_number(&val);
+            js.cx.expose_is_like_none(import_deps);
+            js.assert_optional_number(&val, import_deps);
 
             // We need to convert the given number to a 32-bit integer before
             // passing it to the ABI for 2 reasons:
@@ -1141,8 +1164,8 @@ fn instruction(
         }
         Instruction::F64FromOptionSentinelF32 => {
             let val = js.pop();
-            js.cx.expose_is_like_none();
-            js.assert_optional_number(&val);
+            js.cx.expose_is_like_none(import_deps);
+            js.assert_optional_number(&val, import_deps);
 
             // Similar to the above 32-bit integer variant, we convert the
             // number to a 32-bit *float* before passing it to the ABI. This
@@ -1156,11 +1179,11 @@ fn instruction(
 
         Instruction::FromOptionNative { ty } => {
             let val = js.pop();
-            js.cx.expose_is_like_none();
+            js.cx.expose_is_like_none(import_deps);
             if *ty == ValType::I64 {
-                js.assert_optional_bigint(&val);
+                js.assert_optional_bigint(&val, import_deps);
             } else {
-                js.assert_optional_number(&val);
+                js.assert_optional_number(&val, import_deps);
             }
             js.push(format!("!isLikeNone({0})", val));
             js.push(format!(
@@ -1177,7 +1200,9 @@ fn instruction(
 
         Instruction::VectorToMemory { kind, malloc, mem } => {
             let val = js.pop();
-            let func = js.cx.pass_to_wasm_function(kind.clone(), *mem)?;
+            let func = js
+                .cx
+                .pass_to_wasm_function(kind.clone(), *mem, import_deps)?;
             let malloc = js.cx.export_name_of(*malloc);
             let i = js.tmp();
             js.prelude(&format!(
@@ -1190,6 +1215,7 @@ fn instruction(
             js.prelude(&format!("const len{} = WASM_VECTOR_LEN;", i));
             js.push(format!("ptr{}", i));
             js.push(format!("len{}", i));
+            import_deps.insert(format!("'${}'", func));
         }
 
         Instruction::UnwrapResult { table_and_drop } => {
@@ -1260,8 +1286,8 @@ fn instruction(
             malloc,
             realloc,
         } => {
-            let func = js.cx.expose_pass_string_to_wasm(*mem)?;
-            js.cx.expose_is_like_none();
+            let func = js.cx.expose_pass_string_to_wasm(*mem, import_deps)?;
+            js.cx.expose_is_like_none(import_deps);
             let i = js.tmp();
             let malloc = js.cx.export_name_of(*malloc);
             let val = js.pop();
@@ -1280,11 +1306,14 @@ fn instruction(
             js.prelude(&format!("var len{} = WASM_VECTOR_LEN;", i));
             js.push(format!("ptr{}", i));
             js.push(format!("len{}", i));
+            import_deps.insert(format!("'${}'", func));
         }
 
         Instruction::OptionVector { kind, mem, malloc } => {
-            let func = js.cx.pass_to_wasm_function(kind.clone(), *mem)?;
-            js.cx.expose_is_like_none();
+            let func = js
+                .cx
+                .pass_to_wasm_function(kind.clone(), *mem, import_deps)?;
+            js.cx.expose_is_like_none(import_deps);
             let i = js.tmp();
             let malloc = js.cx.export_name_of(*malloc);
             let val = js.pop();
@@ -1298,12 +1327,15 @@ fn instruction(
             js.prelude(&format!("var len{} = WASM_VECTOR_LEN;", i));
             js.push(format!("ptr{}", i));
             js.push(format!("len{}", i));
+            import_deps.insert(format!("'${}'", func));
         }
 
         Instruction::MutableSliceToMemory { kind, malloc, mem } => {
             // Copy the contents of the typed array into wasm.
             let val = js.pop();
-            let func = js.cx.pass_to_wasm_function(kind.clone(), *mem)?;
+            let func = js
+                .cx
+                .pass_to_wasm_function(kind.clone(), *mem, import_deps)?;
             let malloc = js.cx.export_name_of(*malloc);
             let i = js.tmp();
             js.prelude(&format!(
@@ -1320,6 +1352,7 @@ fn instruction(
             // Then we give Wasm a reference to the original typed array, so that it can
             // update it with modifications made on the Wasm side before returning.
             js.push(val);
+            import_deps.insert(format!("'${}'", func));
         }
 
         Instruction::BoolFromI32 => {
@@ -1421,6 +1454,7 @@ fn instruction(
                 .collect::<Vec<_>>()
                 .join(", ");
             let wrapper = js.cx.adapter_name(*adapter);
+            import_deps.insert(format!("'${}'", wrapper));
             if *mutable {
                 // Mutable closures need protection against being called
                 // recursively, so ensure that we clear out one of the
@@ -1566,8 +1600,8 @@ fn instruction(
 
         Instruction::I32FromOptionNonNull => {
             let val = js.pop();
-            js.cx.expose_is_like_none();
-            js.assert_optional_number(&val);
+            js.cx.expose_is_like_none(import_deps);
+            js.assert_optional_number(&val, import_deps);
             js.push(format!("isLikeNone({0}) ? 0 : {0}", val));
         }
 
@@ -1640,7 +1674,7 @@ impl Invocation {
         args: &[String],
         prelude: &mut String,
         log_error: &mut bool,
-        import_deps: &mut Vec<String>,
+        import_deps: &mut HashSet<String>,
     ) -> Result<String, Error> {
         match self {
             Invocation::Core { id, .. } => {