[jspi] Require async js functions when used with __async decorator.

The `_emval_await` library function is marked `_emval_await__async: true`,
but the js function is not async. With memory64 enabled we auto convert to
bigint and look for the async keyword (which is missing) to apply the await
before creating the BigInt. With my changes __async will require an
async js function, which signals the function is used with JSPI and the
appropriate awaits are then inserted.

Author: brendandahl

src/jsifier.mjs

@@ -9,6 +9,7 @@
 
 import assert from 'node:assert';
 import * as fs from 'node:fs/promises';
+import { isAsyncFunction } from 'node:util/types';
 import {
   ATMODULES,
   ATEXITS,
@@ -332,7 +333,7 @@ return ${makeReturn64(await_ + body)};
       return `\
 ${async_}function(${args}) {
 ${argConversions}
-var ret = (() => { ${body} })();
+var ret = (${async_}() => { ${body} })();
 return ${makeReturn64(await_ + 'ret')};
 }`;
     }
@@ -535,8 +536,8 @@ function(${args}) {
         deps.push('setTempRet0');
       }
 
-      const isAsyncFunction = LibraryManager.library[symbol + '__async'];
-      if (ASYNCIFY && isAsyncFunction) {
+      const hasAsyncDecorator = LibraryManager.library[symbol + '__async'];
+      if (ASYNCIFY && hasAsyncDecorator) {
         asyncFuncs.push(symbol);
       }
 
@@ -671,6 +672,10 @@ function(${args}) {
       }
 
       if (isFunction) {
+        if (ASYNCIFY == 2 && hasAsyncDecorator && !isAsyncFunction(snippet)) {
+          error(`'${symbol}' is marked with the __async decorator but is not an async JS function.`);
+        }
+
         snippet = processLibraryFunction(snippet, symbol, mangled, deps, isStub);
         addImplicitDeps(snippet, deps);
         if (CHECK_DEPS && !isUserSymbol) {
@@ -765,7 +770,7 @@ function(${args}) {
         }
         contentText += `\n${mangled}.sig = '${sig}';`;
       }
-      if (ASYNCIFY && isAsyncFunction) {
+      if (ASYNCIFY && hasAsyncDecorator) {
         assert(isFunction);
         contentText += `\n${mangled}.isAsync = true;`;
       }

src/lib/libasync.js

@@ -482,11 +482,11 @@ addToLibrary({
 
   emscripten_sleep__deps: ['$safeSetTimeout'],
   emscripten_sleep__async: true,
-  emscripten_sleep: (ms) => Asyncify.handleSleep((wakeUp) => safeSetTimeout(wakeUp, ms)),
+  emscripten_sleep: async (ms) => Asyncify.handleSleep((wakeUp) => safeSetTimeout(wakeUp, ms)),
 
   emscripten_wget_data__deps: ['$asyncLoad', 'malloc'],
   emscripten_wget_data__async: true,
-  emscripten_wget_data: (url, pbuffer, pnum, perror) => Asyncify.handleAsync(async () => {
+  emscripten_wget_data: async (url, pbuffer, pnum, perror) => Asyncify.handleAsync(async () => {
     /* no need for run dependency, this is async but will not do any prepare etc. step */
     try {
       const byteArray = await asyncLoad(UTF8ToString(url));
@@ -503,7 +503,7 @@ addToLibrary({
 
   emscripten_scan_registers__deps: ['$safeSetTimeout'],
   emscripten_scan_registers__async: true,
-  emscripten_scan_registers: (func) => {
+  emscripten_scan_registers: async (func) => {
     return Asyncify.handleSleep((wakeUp) => {
       // We must first unwind, so things are spilled to the stack. Then while
       // we are pausing we do the actual scan. After that we can resume. Note
@@ -591,7 +591,7 @@ addToLibrary({
 
   emscripten_fiber_swap__deps: ["$Asyncify", "$Fibers", '$stackSave'],
   emscripten_fiber_swap__async: true,
-  emscripten_fiber_swap: (oldFiber, newFiber) => {
+  emscripten_fiber_swap: async (oldFiber, newFiber) => {
     if (ABORT) return;
 #if ASYNCIFY_DEBUG
     dbg('ASYNCIFY/FIBER: swap', oldFiber, '->', newFiber, 'state:', Asyncify.state);

src/lib/libcore.js

@@ -2617,7 +2617,7 @@ function wrapSyscallFunction(x, library, isWasi) {
   post = handler + post;
 
   if (pre || post) {
-    t = modifyJSFunction(t, (args, body) => `function (${args}) {\n${pre}${body}${post}}\n`);
+    t = modifyJSFunction(t, (args, body, async_) => `${async_} function (${args}) {\n${pre}${body}${post}}\n`);
   }
 
   library[x] = eval('(' + t + ')');

src/lib/libemval.js

@@ -401,12 +401,19 @@ ${functionBody}
 #if ASYNCIFY
   _emval_await__deps: ['$Emval', '$Asyncify'],
   _emval_await__async: true,
+#if ASYNCIFY == 1
   _emval_await: (promise) => {
     return Asyncify.handleAsync(async () => {
       var value = await Emval.toValue(promise);
       return Emval.toHandle(value);
     });
   },
+#else
+  _emval_await: async (promise) => {
+    var value = await Emval.toValue(promise);
+    return Emval.toHandle(value);
+  },
+#endif
 #endif
 
   _emval_iter_begin__deps: ['$Emval'],

src/lib/libidbstore.js

@@ -94,7 +94,7 @@ var LibraryIDBStore = {
 #if ASYNCIFY
   emscripten_idb_load__async: true,
   emscripten_idb_load__deps: ['malloc'],
-  emscripten_idb_load: (db, id, pbuffer, pnum, perror) => Asyncify.handleSleep((wakeUp) => {
+  emscripten_idb_load: async (db, id, pbuffer, pnum, perror) => Asyncify.handleSleep((wakeUp) => {
     IDBStore.getFile(UTF8ToString(db), UTF8ToString(id), (error, byteArray) => {
       if (error) {
         {{{ makeSetValue('perror', 0, '1', 'i32') }}};
@@ -110,7 +110,7 @@ var LibraryIDBStore = {
     });
   }),
   emscripten_idb_store__async: true,
-  emscripten_idb_store: (db, id, ptr, num, perror) => Asyncify.handleSleep((wakeUp) => {
+  emscripten_idb_store: async (db, id, ptr, num, perror) => Asyncify.handleSleep((wakeUp) => {
     IDBStore.setFile(UTF8ToString(db), UTF8ToString(id), new Uint8Array(HEAPU8.subarray(ptr, ptr+num)), (error) => {
       // Closure warns about storing booleans in TypedArrays.
       /** @suppress{checkTypes} */
@@ -119,15 +119,15 @@ var LibraryIDBStore = {
     });
   }),
   emscripten_idb_delete__async: true,
-  emscripten_idb_delete: (db, id, perror) => Asyncify.handleSleep((wakeUp) => {
+  emscripten_idb_delete: async (db, id, perror) => Asyncify.handleSleep((wakeUp) => {
     IDBStore.deleteFile(UTF8ToString(db), UTF8ToString(id), (error) => {
       /** @suppress{checkTypes} */
       {{{ makeSetValue('perror', 0, '!!error', 'i32') }}};
       wakeUp();
     });
   }),
   emscripten_idb_exists__async: true,
-  emscripten_idb_exists: (db, id, pexists, perror) => Asyncify.handleSleep((wakeUp) => {
+  emscripten_idb_exists: async (db, id, pexists, perror) => Asyncify.handleSleep((wakeUp) => {
     IDBStore.existsFile(UTF8ToString(db), UTF8ToString(id), (error, exists) => {
       /** @suppress{checkTypes} */
       {{{ makeSetValue('pexists', 0, '!!exists', 'i32') }}};
@@ -137,7 +137,7 @@ var LibraryIDBStore = {
     });
   }),
   emscripten_idb_clear__async: true,
-  emscripten_idb_clear: (db, perror) => Asyncify.handleSleep((wakeUp) => {
+  emscripten_idb_clear: async (db, perror) => Asyncify.handleSleep((wakeUp) => {
     IDBStore.clearStore(UTF8ToString(db), (error) => {
       /** @suppress{checkTypes} */
       {{{ makeSetValue('perror', 0, '!!error', 'i32') }}};

src/lib/libpromise.js

@@ -261,7 +261,7 @@ addToLibrary({
 #if ASYNCIFY
   emscripten_promise_await__deps: ['$getPromise', '$setPromiseResult'],
 #endif
-  emscripten_promise_await: (returnValuePtr, id) => {
+  emscripten_promise_await: async (returnValuePtr, id) => {
 #if ASYNCIFY
 #if RUNTIME_DEBUG
     dbg(`emscripten_promise_await: ${id}`);

src/lib/libwasi.js

@@ -541,7 +541,7 @@ var WasiLibrary = {
   },
 
   fd_sync__async: true,
-  fd_sync: (fd) => {
+  fd_sync: {{{ asyncIf(ASYNCIFY) }}} (fd) => {
 #if SYSCALLS_REQUIRE_FILESYSTEM
     var stream = SYSCALLS.getStreamFromFD(fd);
     var rtn = stream.stream_ops?.fsync?.(stream);

test/codesize/test_codesize_hello_dylink_all.json

@@ -1,7 +1,7 @@
 {
-  "a.out.js": 244848,
+  "a.out.js": 244853,
   "a.out.nodebug.wasm": 574227,
-  "total": 819075,
+  "total": 819080,
   "sent": [
     "IMG_Init",
     "IMG_Load",

test/test_jslib.py

@@ -7,7 +7,7 @@
 from subprocess import PIPE
 
 from common import RunnerCore, create_file, read_file, test_file
-from decorators import also_with_wasm64, also_without_bigint, parameterized
+from decorators import also_with_wasm64, also_without_bigint, parameterized, requires_jspi
 
 from tools.shared import EMCC
 from tools.utils import delete_file
@@ -719,3 +719,22 @@ def test_jslib_version_check(self):
       #endif
     ''')
     self.assert_fail([EMCC, '--js-library=libfoo.js'], 'error: libfoo.js:3: #error "library does not support emscripten > 3.0.0"')
+
+  @requires_jspi
+  def test_jslib_jspi_missing_async(self):
+    create_file('lib.js', r'''
+      addToLibrary({
+        foo__async: true,
+        foo: function(f) {},
+      });
+    ''')
+    create_file('main.c', r'''
+      #include <emscripten.h>
+      extern void foo();
+      EMSCRIPTEN_KEEPALIVE void test() {
+        foo();
+      }
+    ''')
+    err = self.expect_fail([EMCC, 'main.c', '-o', 'out.js', '-sJSPI', '--js-library=lib.js', '-Wno-experimental'])
+    self.assertContained('error: \'foo\' is marked with the __async decorator but is not an async JS function.', err)
+

test/test_other.py

@@ -3292,10 +3292,11 @@ def test_embind_asyncify(self):
     ''')
     self.do_runf('main.cpp', 'done', cflags=['-lembind', '-sASYNCIFY', '--post-js', 'post.js'])
 
+  @also_with_wasm64
   @parameterized({
-    '': [['-sDYNAMIC_EXECUTION=1']],
-    'no_dynamic': [['-sDYNAMIC_EXECUTION=0']],
-    'dyncall': [['-sALLOW_MEMORY_GROWTH', '-sMAXIMUM_MEMORY=4GB']],
+    '': (['-sDYNAMIC_EXECUTION=1'],),
+    'no_dynamic': (['-sDYNAMIC_EXECUTION=0'],),
+    'dyncall': (['-sALLOW_MEMORY_GROWTH', '-sMAXIMUM_MEMORY=4GB'],),
   })
   @requires_jspi
   def test_embind_jspi(self, args):