Use Asyncify shorthands. NFC (#24266)

Noticed a few places where Asyncify.handleSleep was used with promises,
for which handleAsync is a more natural fit; also switched a few places
to arrow functions.

It makes code slightly cleaner, and, if used with JSPI where Promises
are first-class, avoids jumping through handleSleep wrapping as well.

Author: RReverser

src/lib/libasync.js

@@ -426,12 +426,10 @@ addToLibrary({
     //
     // This is particularly useful for native JS `async` functions where the
     // returned value will "just work" and be passed back to C++.
-    handleAsync(startAsync) {
-      return Asyncify.handleSleep((wakeUp) => {
-        // TODO: add error handling as a second param when handleSleep implements it.
-        startAsync().then(wakeUp);
-      });
-    },
+    handleAsync: (startAsync) => Asyncify.handleSleep((wakeUp) => {
+      // TODO: add error handling as a second param when handleSleep implements it.
+      startAsync().then(wakeUp);
+    }),
 
 #elif ASYNCIFY == 2
     //
@@ -452,9 +450,7 @@ addToLibrary({
         {{{ runtimeKeepalivePop(); }}}
       }
     },
-    handleSleep(startAsync) {
-      return Asyncify.handleAsync(() => new Promise(startAsync));
-    },
+    handleSleep: (startAsync) => Asyncify.handleAsync(() => new Promise(startAsync)),
     makeAsyncFunction(original) {
 #if ASYNCIFY_DEBUG
       dbg('asyncify: makeAsyncFunction for', original);
@@ -466,33 +462,24 @@ addToLibrary({
 
   emscripten_sleep__deps: ['$safeSetTimeout'],
   emscripten_sleep__async: true,
-  emscripten_sleep: (ms) => {
-    // emscripten_sleep() does not return a value, but we still need a |return|
-    // here for stack switching support (ASYNCIFY=2). In that mode this function
-    // returns a Promise instead of nothing, and that Promise is what tells the
-    // wasm VM to pause the stack.
-    return Asyncify.handleSleep((wakeUp) => safeSetTimeout(wakeUp, ms));
-  },
+  emscripten_sleep: (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) => {
-    return Asyncify.handleSleep((wakeUp) => {
-      /* no need for run dependency, this is async but will not do any prepare etc. step */
-      asyncLoad(UTF8ToString(url)).then((byteArray) => {
-        // can only allocate the buffer after the wakeUp, not during an asyncing
-        var buffer = _malloc(byteArray.length); // must be freed by caller!
-        HEAPU8.set(byteArray, buffer);
-        {{{ makeSetValue('pbuffer', 0, 'buffer', '*') }}};
-        {{{ makeSetValue('pnum',  0, 'byteArray.length', 'i32') }}};
-        {{{ makeSetValue('perror',  0, '0', 'i32') }}};
-        wakeUp();
-      }, () => {
-        {{{ makeSetValue('perror',  0, '1', 'i32') }}};
-        wakeUp();
-      });
-    });
-  },
+  emscripten_wget_data: (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));
+      // can only allocate the buffer after the wakeUp, not during an asyncing
+      var buffer = _malloc(byteArray.length); // must be freed by caller!
+      HEAPU8.set(byteArray, buffer);
+      {{{ makeSetValue('pbuffer', 0, 'buffer', '*') }}};
+      {{{ makeSetValue('pnum', 0, 'byteArray.length', 'i32') }}};
+      {{{ makeSetValue('perror', 0, '0', 'i32') }}};
+    } catch (err) {
+      {{{ makeSetValue('perror', 0, '1', 'i32') }}};
+    }
+  }),
 
   emscripten_scan_registers__deps: ['$safeSetTimeout'],
   emscripten_scan_registers__async: true,

src/lib/libdylink.js

@@ -1245,17 +1245,19 @@ var LibraryDylink = {
 #if ASYNCIFY
   _dlopen_js__async: true,
 #endif
-  _dlopen_js: {{{ asyncIf(ASYNCIFY == 2) }}} (handle) => {
+  _dlopen_js: {{{ asyncIf(ASYNCIFY == 2) }}} (handle) =>
 #if ASYNCIFY
-    return Asyncify.handleSleep((wakeUp) => {
+    Asyncify.handleSleep((wakeUp) =>
       dlopenInternal(handle, { loadAsync: true })
-        .then(wakeUp)
-        .catch(() => wakeUp(0));
-    });
+      .then(wakeUp)
+      // Note: this currently relies on being able to catch errors even from `wakeUp` callback itself.
+      // That's why we can't refactor it to `handleAsync` at the moment.
+      .catch(() => wakeUp(0))
+    )
 #else
-    return dlopenInternal(handle, { loadAsync: false });
+    dlopenInternal(handle, { loadAsync: false })
 #endif
-  },
+    ,
 
   // Async version of dlopen.
   _emscripten_dlopen_js__deps: ['$dlopenInternal', '$callUserCallback', '$dlSetError'],

src/lib/libpromise.js

@@ -266,15 +266,10 @@ addToLibrary({
 #if RUNTIME_DEBUG
     dbg(`emscripten_promise_await: ${id}`);
 #endif
-    return Asyncify.handleSleep((wakeUp) => {
-      getPromise(id).then((value) => {
-        setPromiseResult(returnValuePtr, true, value);
-        wakeUp();
-      }, (value) => {
-        setPromiseResult(returnValuePtr, false, value);
-        wakeUp();
-      });
-    });
+    return Asyncify.handleAsync(() => getPromise(id).then(
+      value => setPromiseResult(returnValuePtr, true, value),
+      error => setPromiseResult(returnValuePtr, false, error)
+    ));
 #else
     abort('emscripten_promise_await is only available with ASYNCIFY');
 #endif

src/lib/libwasi.js

@@ -544,11 +544,7 @@ var WasiLibrary = {
         return;
       }
       mount.type.syncfs(mount, false, (err) => {
-        if (err) {
-          wakeUp({{{ cDefs.EIO }}});
-          return;
-        }
-        wakeUp(0);
+        wakeUp(err ? {{{ cDefs.EIO }}} : 0);
       });
     });
 #else