Add emscripten_promise_await based on ASYNCIFY (#19553)

Author: sbc100

src/library_promise.js

@@ -260,4 +260,25 @@ mergeInto(LibraryManager.library, {
 #endif
     return id;
   },
+
+  emscripten_promise_await__async: true,
+  emscripten_promise_await__deps: ['$getPromise', '$setPromiseResult'],
+  emscripten_promise_await: (returnValuePtr, id) => {
+#if ASYNCIFY
+#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();
+      });
+    });
+#else
+    abort('emscripten_promise_await is only available with ASYNCIFY');
+#endif
+  },
 });

src/library_sigs.js

@@ -687,6 +687,7 @@ sigs = {
   emscripten_promise_all__sig: 'pppp',
   emscripten_promise_all_settled__sig: 'pppp',
   emscripten_promise_any__sig: 'pppp',
+  emscripten_promise_await__sig: 'vpp',
   emscripten_promise_create__sig: 'p',
   emscripten_promise_destroy__sig: 'vp',
   emscripten_promise_race__sig: 'ppp',

system/include/emscripten/promise.h

@@ -135,6 +135,17 @@ __attribute__((warn_unused_result)) em_promise_t emscripten_promise_any(
 __attribute__((warn_unused_result)) em_promise_t
 emscripten_promise_race(em_promise_t* promises, size_t num_promises);
 
+// Suspend the current Wasm execution context until the given promise has been
+// settled.
+//
+// Since the stack is not unwound while Wasm execution is suspended, it is
+// safe to pass pointers to the stack to asynchronous work that is waited on
+// with this function.
+//
+// This function can only be used in programs that were built with `-sASYNCIFY`.
+__attribute__((warn_unused_result)) em_settled_result_t
+emscripten_promise_await(em_promise_t promise);
+
 #ifdef __cplusplus
 }
 #endif

test/core/test_promise_await.c

@@ -0,0 +1,61 @@
+#include <assert.h>
+#include <emscripten/promise.h>
+#include <emscripten/em_js.h>
+#include <emscripten/emscripten.h>
+#include <stdbool.h>
+#include <stdio.h>
+
+void fulfill_from_timout(void* arg) {
+  emscripten_promise_resolve((em_promise_t)arg, EM_PROMISE_FULFILL, (void*)43);
+}
+
+void test_already_fulfilled() {
+  // Test waiting on an already fulfilled promise.
+  em_promise_t p = emscripten_promise_create();
+  emscripten_promise_resolve(p, EM_PROMISE_FULFILL, (void*)42);
+
+  printf("waiting on promise: %p\n", p);
+  em_settled_result_t res = emscripten_promise_await(p);
+  printf(".. done wait: %d %ld\n", res.result, (intptr_t)res.value);
+
+  assert(res.result == EM_PROMISE_FULFILL);
+  assert(res.value == (void*)42);
+  emscripten_promise_destroy(p);
+}
+
+void test_not_yet_fulfilled() {
+  em_promise_t p = emscripten_promise_create();
+  emscripten_async_call(fulfill_from_timout, p, 0);
+
+  printf("waiting on promise: %p\n", p);
+  em_settled_result_t res = emscripten_promise_await(p);
+  printf(".. done wait: %d %ld\n", res.result, (intptr_t)res.value);
+
+  assert(res.result == EM_PROMISE_FULFILL);
+  assert(res.value == (void*)43);
+  emscripten_promise_destroy(p);
+}
+
+void test_rejected() {
+  em_promise_t p = emscripten_promise_create();
+  emscripten_promise_resolve(p, EM_PROMISE_REJECT, (void*)44);
+
+  printf("waiting on promise: %p\n", p);
+  em_settled_result_t res = emscripten_promise_await(p);
+  printf(".. done wait: %d %ld\n", res.result, (intptr_t)res.value);
+
+  assert(res.result == EM_PROMISE_REJECT);
+  assert(res.value == (void*)44);
+  emscripten_promise_destroy(p);
+}
+
+int main() {
+  printf("main\n");
+
+  test_already_fulfilled();
+  test_not_yet_fulfilled();
+  test_rejected();
+
+  printf("main done\n");
+  return 0;
+}

test/core/test_promise_await.out

@@ -0,0 +1,8 @@
+main
+waiting on promise: 0x1
+.. done wait: 0 42
+waiting on promise: 0x1
+.. done wait: 0 43
+waiting on promise: 0x1
+.. done wait: 3 44
+main done

test/test_core.py

@@ -9724,6 +9724,16 @@ def test_promise(self):
     self.set_setting('MIN_CHROME_VERSION', '85')
     self.do_core_test('test_promise.c')
 
+  @no_wasm64('TODO: asyncify for wasm64')
+  @with_asyncify_and_jspi
+  def test_promise_await(self):
+    self.do_core_test('test_promise_await.c')
+
+  def test_promise_await_error(self):
+    # Check that the API is not available when ASYNCIFY is not set
+    self.do_runf(test_file('core/test_promise_await.c'), 'Aborted(emscripten_promise_await is only available with ASYNCIFY)',
+                 assert_returncode=NON_ZERO)
+
   def test_emscripten_async_load_script(self):
     create_file('script1.js', 'Module._set(456);''')
     create_file('file1.txt', 'first')