Allow the createWasm function to use async/await where possible

The advantage if using `await` in the cases where we can is that it
avoids the generation or wrapper function for each export.

So instead of

```
var wasmExport = createWasm(); // returns empty object
...
var malloc = ((..) => (malloc = wasmExports['malloc'])()
```

We can just generate:

```
var wasmExport = createWasm(); // returns empty object
...
var malloc = wasmExports['malloc'];
```

This only currently works in MODULARIZE mode where the code is running
inside a factory function.  Otherwise it would end up using
top-level-await.

One wrinkle here is that this is not currently supported when closure is
enabled because we run closure only on the contents of the factory
function so closure ends up seeing this as a top level await when its
not.

Author: sbc100

src/preamble.js

@@ -1036,11 +1036,11 @@ function getWasmImports() {
     trueModule = null;
 #endif
 #if SHARED_MEMORY || RELOCATABLE
-    receiveInstance(result['instance'], result['module']);
+    return receiveInstance(result['instance'], result['module']);
 #else
     // TODO: Due to Closure regression https://github.com/google/closure-compiler/issues/3193, the above line no longer optimizes out down to the following line.
     // When the regression is fixed, can restore the above PTHREADS-enabled path.
-    receiveInstance(result['instance']);
+    return receiveInstance(result['instance']);
 #endif
   }
 #endif // WASM_ASYNC_COMPILATION
@@ -1076,8 +1076,7 @@ function getWasmImports() {
         // Instantiate from the module posted from the main thread.
         // We can just use sync instantiation in the worker.
         var instance = new WebAssembly.Instance(module, getWasmImports());
-        receiveInstance(instance, module);
-        resolve();
+        resolve(receiveInstance(instance, module));
       };
     });
   }
@@ -1095,16 +1094,16 @@ function getWasmImports() {
   try {
 #endif
     var result = await instantiateAsync(wasmBinary, wasmBinaryFile, info);
-    receiveInstantiationResult(result);
+    var exports = receiveInstantiationResult(result);
 #if LOAD_SOURCE_MAP
     receiveSourceMapJSON(await getSourceMapAsync());
 #endif
-    return result;
+    return exports;
 #if MODULARIZE
   } catch (e) {
     // If instantiation fails, reject the module ready promise.
     readyPromiseReject(e);
-    return;
+    return Promise.reject(e);
   }
 #endif
 #else // WASM_ASYNC_COMPILATION

test/test_browser.py

@@ -4795,28 +4795,19 @@ def test_browser_run_from_different_directory(self):
 
   # Similar to `test_browser_run_from_different_directory`, but asynchronous because of `-sMODULARIZE`
   def test_browser_run_from_different_directory_async(self):
-    for args, creations in [
-      (['-sMODULARIZE'], [
-        'Module();',    # documented way for using modularize
-        'new Module();' # not documented as working, but we support it
-       ]),
-    ]:
-      print(args)
-      # compile the code with the modularize feature and the preload-file option enabled
-      self.compile_btest('browser_test_hello_world.c', ['-o', 'test.js', '-O3'] + args)
-      ensure_dir('subdir')
-      shutil.move('test.js', Path('subdir/test.js'))
-      shutil.move('test.wasm', Path('subdir/test.wasm'))
-      for creation in creations:
-        print(creation)
-        # Make sure JS is loaded from subdirectory
-        create_file('test-subdir.html', '''
-          <script src="subdir/test.js"></script>
-          <script>
-            %s
-          </script>
-        ''' % creation)
-        self.run_browser('test-subdir.html', '/report_result?0')
+    # compile the code with the modularize feature and the preload-file option enabled
+    self.compile_btest('browser_test_hello_world.c', ['-o', 'test.js', '-O3', '-sMODULARIZE'])
+    ensure_dir('subdir')
+    shutil.move('test.js', Path('subdir/test.js'))
+    shutil.move('test.wasm', Path('subdir/test.wasm'))
+    # Make sure JS is loaded from subdirectory
+    create_file('test-subdir.html', '''
+      <script src="subdir/test.js"></script>
+      <script>
+        Module();
+      </script>
+    ''')
+    self.run_browser('test-subdir.html', '/report_result?0')
 
   # Similar to `test_browser_run_from_different_directory`, but
   # also also we eval the initial code, so currentScript is not present. That prevents us

test/test_unicode_js_library.out

@@ -1,2 +1,2 @@
-Unicode postjs: àČšñéáúÍųåêâăščếệüçλληνικάбългарскиPусскийСрпскиУкраїнська한국어中文普通话(中国大陆)普通话(香港)中文(台灣)粵語(香港)日本語हिन्दीภาษาไทย
 Unicode snowman ☃ says hello! àČšñéáúÍųåêâăščếệüçλληνικάбългарскиPусскийСрпскиУкраїнська한국어中文普通话(中国大陆)普通话(香港)中文(台灣)粵語(香港)日本語हिन्दीภาษาไทย
+Unicode postjs: àČšñéáúÍųåêâăščếệüçλληνικάбългарскиPусскийСрпскиУкраїнська한국어中文普通话(中国大陆)普通话(香港)中文(台灣)粵語(香港)日本語हिन्दीภาษาไทย

tools/emscripten.py

@@ -893,6 +893,14 @@ def create_sending(metadata, library_symbols):
   return '{\n  ' + ',\n  '.join(elems) + '\n}'
 
 
+def can_use_await():
+  # In modularize mode we can use `await` since the factor function itself
+  # is marked as `async` and the generated code all lives inside that factory
+  # function.
+  # FIXME(https://github.com/emscripten-core/emscripten/issues/23158)
+  return settings.MODULARIZE and not settings.USE_CLOSURE_COMPILER
+
+
 def make_export_wrappers(function_exports):
   assert not settings.MINIMAL_RUNTIME
 
@@ -932,7 +940,7 @@ def install_wrapper(sym):
       # With assertions enabled we create a wrapper that are calls get routed through, for
       # the lifetime of the program.
       wrapper += f"createExportWrapper('{name}', {nargs});"
-    elif settings.WASM_ASYNC_COMPILATION or settings.PTHREADS:
+    elif (settings.WASM_ASYNC_COMPILATION and not can_use_await()) or settings.PTHREADS:
       # With WASM_ASYNC_COMPILATION wrapper will replace the global var and Module var on
       # first use.
       args = [f'a{i}' for i in range(nargs)]
@@ -998,7 +1006,11 @@ def create_module(receiving, metadata, global_exports, library_symbols):
 
   if not settings.MINIMAL_RUNTIME:
     if settings.WASM_ASYNC_COMPILATION:
-      module.append("var wasmExports;\ncreateWasm();\n")
+      if can_use_await():
+        # In modullize mode the generated code is within a factory function.
+        module.append("var wasmExports = await createWasm();\n")
+      else:
+        module.append("var wasmExports;\ncreateWasm();\n")
     else:
       module.append("var wasmExports = createWasm();\n")
 

tools/link.py

@@ -2379,28 +2379,20 @@ def modularize():
   logger.debug(f'Modularizing, assigning to var {settings.EXPORT_NAME}')
   src = read_file(final_js)
 
-  # When targetting node and ES6 we use `await import ..` in the generated code
-  # so the outer function needs to be marked as async.
-  async_emit = ''
-  if settings.EXPORT_ES6 and settings.ENVIRONMENT_MAY_BE_NODE:
-    async_emit = 'async '
-
-  # TODO: Remove when https://bugs.webkit.org/show_bug.cgi?id=223533 is resolved.
-  if async_emit != '' and settings.EXPORT_NAME == 'config':
-    diagnostics.warning('emcc', 'EXPORT_NAME should not be named "config" when targeting Safari')
-
+  if settings.WASM_ASYNC_COMPILATION or (settings.EXPORT_ES6 and settings.ENVIRONMENT_MAY_BE_NODE):
+    maybe_async = 'async '
+  else:
+    maybe_async = ''
   if settings.MODULARIZE == 'instance':
     src = '''
-export default async function init(moduleArg = {}) {
+export default %(maybe_async)sfunction init(moduleArg = {}) {
   var moduleRtn;
 
 %(src)s
 
-  return await moduleRtn;
+  return moduleRtn;
 }
-''' % {
-      'src': src,
-    }
+''' % {'src': src, 'maybe_async': maybe_async}
   else:
     src = '''
 %(maybe_async)sfunction(moduleArg = {}) {
@@ -2410,10 +2402,7 @@ def modularize():
 
   return moduleRtn;
 }
-''' % {
-      'maybe_async': async_emit,
-      'src': src,
-    }
+''' % {'src': src, 'maybe_async': maybe_async}
 
   if settings.MINIMAL_RUNTIME and not settings.PTHREADS:
     # Single threaded MINIMAL_RUNTIME programs do not need access to