Implement emscripten_promise_all_settled in promise.h

src/generated_struct_info32.json

@@ -1330,6 +1330,11 @@
             "table_addr": 20,
             "table_size": 24
         },
+        "em_settled_result_t": {
+            "__size__": 8,
+            "result": 0,
+            "value": 4
+        },
         "emscripten_fetch_attr_t": {
             "__size__": 92,
             "attributes": 52,

src/generated_struct_info64.json

@@ -1330,6 +1330,11 @@
             "table_addr": 32,
             "table_size": 40
         },
+        "em_settled_result_t": {
+            "__size__": 16,
+            "result": 0,
+            "value": 8
+        },
         "emscripten_fetch_attr_t": {
             "__size__": 152,
             "attributes": 72,

src/library_promise.js

@@ -27,6 +27,16 @@ mergeInto(LibraryManager.library, {
     return promiseInfo;
   },
 
+  $idsToPromises__deps: ['$promiseMap', '$getPromise'],
+  $idsToPromises: function(idBuf, size) {
+    var promises = [];
+    for (var i = 0; i < size; i++) {
+      var id = {{{ makeGetValue('idBuf', `i*${POINTER_SIZE}`, 'i32') }}};
+      promises[i] = getPromise(id);
+    }
+    return promises;
+  },
+
   emscripten_promise_create__deps: ['$makePromise'],
   emscripten_promise_create: function() {
     return makePromise().id;
@@ -146,13 +156,9 @@ mergeInto(LibraryManager.library, {
     return newId;
   },
 
-  emscripten_promise_all__deps: ['$promiseMap', '$getPromise'],
+  emscripten_promise_all__deps: ['$promiseMap', '$idsToPromises'],
   emscripten_promise_all: function(idBuf, resultBuf, size) {
-    var promises = [];
-    for (var i = 0; i < size; i++) {
-      var id = {{{ makeGetValue('idBuf', `i*${POINTER_SIZE}`, 'i32') }}};
-      promises[i] = getPromise(id);
-    }
+    var promises = idsToPromises(idBuf, size);
 #if RUNTIME_DEBUG
     dbg('emscripten_promise_all: ' + promises);
 #endif
@@ -169,6 +175,43 @@ mergeInto(LibraryManager.library, {
     });
 #if RUNTIME_DEBUG
     dbg('create: ' + id);
+#endif
+    return id;
+  },
+
+  emscripten_promise_all_settled__deps: ['$promiseMap', '$idsToPromises'],
+  emscripten_promise_all_settled: function(idBuf, resultBuf, size) {
+    var promises = idsToPromises(idBuf, size);
+#if RUNTIME_DEBUG
+    dbg('emscripten_promise_all_settled: ' + promises);
+#endif
+    var id = promiseMap.allocate({
+      promise: Promise.allSettled(promises).then((results) => {
+        if (resultBuf) {
+          for (var i = 0; i < size; i++) {
+            var baseOffset = i * {{{ C_STRUCTS.em_settled_result_t.__size__ }}};
+            var resultOffset =
+                baseOffset + {{{ C_STRUCTS.em_settled_result_t.result }}};
+            var valueOffset =
+                baseOffset + {{{ C_STRUCTS.em_settled_result_t.value }}};
+            if (results[i].status === 'fulfilled') {
+              var fulfill = {{{ cDefs.EM_PROMISE_FULFILL }}};
+              {{{ makeSetValue('resultBuf', 'resultOffset', 'fulfill', 'i32') }}};
+              {{{ makeSetValue('resultBuf', 'valueOffset', 'results[i].value', '*') }}};
+            } else {
+              var reject = {{{ cDefs.EM_PROMISE_REJECT }}};
+              {{{ makeSetValue('resultBuf', 'resultOffset', 'reject', 'i32') }}};
+              // Closure can't type `reason` in some contexts.
+              var reason = /** @type {number} */ (results[i].reason);
+              {{{ makeSetValue('resultBuf', 'valueOffset', 'reason', '*') }}};
+            }
+          }
+        }
+        return resultBuf;
+      })
+    });
+#if RUNTIME_DEBUG
+    dbg('create: ' + id);
 #endif
     return id;
   },

src/library_sigs.js

@@ -534,6 +534,7 @@ sigs = {
   emscripten_performance_now__sig: 'd',
   emscripten_print_double__sig: 'idpi',
   emscripten_promise_all__sig: 'pppp',
+  emscripten_promise_all_settled__sig: 'pppp',
   emscripten_promise_create__sig: 'p',
   emscripten_promise_destroy__sig: 'vp',
   emscripten_promise_resolve__sig: 'vpip',

src/struct_info.json

@@ -262,7 +262,7 @@
             "O_PATH",
             "O_NONBLOCK",
             "O_CLOEXEC",
-            "F_GETOWN", 
+            "F_GETOWN",
             "F_GETOWN_EX",
             "F_SETFD",
             "O_EXCL",
@@ -1095,7 +1095,13 @@
             "EM_PROMISE_MATCH",
             "EM_PROMISE_MATCH_RELEASE",
             "EM_PROMISE_REJECT"
-        ]
+        ],
+        "structs": {
+            "em_settled_result_t": [
+                "result",
+                "value"
+            ]
+        }
     },
     {
         "file": "AL/al.h",

system/include/emscripten/promise.h

@@ -92,17 +92,29 @@ emscripten_promise_then(em_promise_t promise,
                         void* data);
 
 // Call Promise.all to create and return a new promise that is either fulfilled
-// once the `num_promises` input promises in the `promises` have been fulfilled
-// or is rejected once any of the input promises has been rejected. When the
-// returned promise is fulfilled, the values each of the input promises were
-// resolved with will be written to the `results` array and the returned promise
-// will be fulfilled with the address of that array as well.
+// once the `num_promises` input promises passed in `promises` have been
+// fulfilled or is rejected once any of the input promises has been rejected.
+// When the returned promise is fulfilled, the values each of the input promises
+// were resolved with will be written to the `results` array if it is non-null
+// and the returned promise will be fulfilled with the address of that array as
+// well.
 __attribute__((warn_unused_result)) em_promise_t emscripten_promise_all(
   em_promise_t* promises, void** results, size_t num_promises);
 
-// TODO: emscripten_promise_all_settled
-// TODO: emscripten_promise_race
-// TODO: emscripten_promise_any
+typedef struct em_settled_result_t {
+  em_promise_result_t result;
+  void* value;
+} em_settled_result_t;
+
+// Call Promise.allSettled to create and return a new promise that is fulfilled
+// once the `num_promises` input promises passed in `promises` have been
+// settled. When the returned promise is fulfilled, the `results` buffer will be
+// filled with the result comprising of either EM_PROMISE_FULFILL and the
+// fulfilled value or EM_PROMISE_REJECT and the rejection reason for each of the
+// input promises if `results` is non-null. The returned promise will be
+// fulfilled with the value of `results` as well.
+__attribute__((warn_unused_result)) em_promise_t emscripten_promise_all_settled(
+  em_promise_t* promises, em_settled_result_t* results, size_t num_promises);
 
 #ifdef __cplusplus
 }

test/core/test_promise.c

@@ -248,6 +248,102 @@ static em_promise_result_t test_all(void** result, void* data, void* value) {
   return EM_PROMISE_MATCH_RELEASE;
 }
 
+typedef struct promise_all_settled_state {
+  size_t size;
+  em_promise_t in[3];
+  em_settled_result_t out[3];
+  em_settled_result_t expected[3];
+} promise_all_settled_state;
+
+static em_promise_result_t
+check_promise_all_settled_results(void** result, void* data, void* value) {
+  promise_all_settled_state* state = (promise_all_settled_state*)data;
+  assert(value == state->out);
+  emscripten_console_log("promise_all_settled results:");
+  for (size_t i = 0; i < state->size; ++i) {
+    emscripten_console_logf(
+      "%s %ld",
+      state->out[i].result == EM_PROMISE_FULFILL ? "fulfill" : "reject",
+      (uintptr_t)state->out[i].value);
+    assert(state->out[i].result == state->expected[i].result);
+    assert(state->out[i].value == state->expected[i].value);
+  }
+  free(state);
+  return EM_PROMISE_FULFILL;
+}
+
+static em_promise_result_t check_null(void** result, void* data, void* value) {
+  assert(value == NULL);
+  return EM_PROMISE_FULFILL;
+}
+
+static em_promise_result_t
+test_all_settled(void** result, void* data, void* value) {
+  emscripten_console_log("test_all_settled");
+  assert(data == (void*)5);
+
+  // No input should be handled ok.
+  promise_all_settled_state* state = malloc(sizeof(promise_all_settled_state));
+  *state =
+    (promise_all_settled_state){.size = 0, .in = {}, .out = {}, .expected = {}};
+  em_promise_t empty =
+    emscripten_promise_all_settled(state->in, state->out, state->size);
+  em_promise_t empty_checked = emscripten_promise_then(
+    empty, check_promise_all_settled_results, fail, state);
+  emscripten_promise_destroy(empty);
+
+  // Fulfilled and rejected inputs should be reported.
+  state = malloc(sizeof(promise_all_settled_state));
+  *state = (promise_all_settled_state){.size = 3,
+                                       .in = {emscripten_promise_create(),
+                                              emscripten_promise_create(),
+                                              emscripten_promise_create()},
+                                       .out = {},
+                                       .expected = {
+                                         {EM_PROMISE_FULFILL, (void*)42},
+                                         {EM_PROMISE_REJECT, (void*)43},
+                                         {EM_PROMISE_FULFILL, (void*)44},
+                                       }};
+  em_promise_t full =
+    emscripten_promise_all_settled(state->in, state->out, state->size);
+  em_promise_t full_checked = emscripten_promise_then(
+    full, check_promise_all_settled_results, fail, state);
+  emscripten_promise_destroy(full);
+  emscripten_promise_resolve(state->in[0], EM_PROMISE_FULFILL, (void*)42);
+  emscripten_promise_resolve(state->in[1], EM_PROMISE_REJECT, (void*)43);
+  emscripten_promise_resolve(state->in[2], EM_PROMISE_FULFILL, (void*)44);
+  emscripten_promise_destroy(state->in[0]);
+  emscripten_promise_destroy(state->in[1]);
+  emscripten_promise_destroy(state->in[2]);
+
+  // Null buffer should be ok.
+  em_promise_t null_in[3] = {
+    emscripten_promise_create(),
+    emscripten_promise_create(),
+    emscripten_promise_create(),
+  };
+  em_promise_t null = emscripten_promise_all_settled(null_in, NULL, 3);
+  em_promise_t null_checked =
+    emscripten_promise_then(null, check_null, fail, NULL);
+  emscripten_promise_destroy(null);
+  emscripten_promise_resolve(null_in[0], EM_PROMISE_REJECT, (void*)42);
+  emscripten_promise_resolve(null_in[1], EM_PROMISE_FULFILL, (void*)43);
+  emscripten_promise_resolve(null_in[2], EM_PROMISE_REJECT, (void*)44);
+  emscripten_promise_destroy(null_in[0]);
+  emscripten_promise_destroy(null_in[1]);
+  emscripten_promise_destroy(null_in[2]);
+
+  em_promise_t to_finish[3] = {empty_checked, full_checked, null_checked};
+  em_promise_t finish_test_all = emscripten_promise_all(to_finish, NULL, 3);
+
+  emscripten_promise_destroy(empty_checked);
+  emscripten_promise_destroy(full_checked);
+  emscripten_promise_destroy(null_checked);
+
+  *result = finish_test_all;
+  return EM_PROMISE_MATCH_RELEASE;
+}
+
 static em_promise_result_t finish(void** result, void* data, void* value) {
   emscripten_console_logf("finish");
 
@@ -292,8 +388,10 @@ int main() {
   em_promise_t test3 =
     emscripten_promise_then(test2, test_rejection, fail, (void*)3);
   em_promise_t test4 = emscripten_promise_then(test3, test_all, fail, (void*)4);
+  em_promise_t test5 =
+    emscripten_promise_then(test4, test_all_settled, fail, (void*)5);
   em_promise_t assert_stack =
-    emscripten_promise_then(test4, check_stack, fail, NULL);
+    emscripten_promise_then(test5, check_stack, fail, NULL);
   em_promise_t end = emscripten_promise_then(assert_stack, finish, fail, NULL);
 
   emscripten_promise_resolve(start, EM_PROMISE_FULFILL, NULL);
@@ -304,6 +402,7 @@ int main() {
   emscripten_promise_destroy(test2);
   emscripten_promise_destroy(test3);
   emscripten_promise_destroy(test4);
+  emscripten_promise_destroy(test5);
   emscripten_promise_destroy(assert_stack);
   emscripten_promise_destroy(end);
 

test/core/test_promise.out

@@ -15,4 +15,10 @@ promise_all results:
 1337
 0
 promise_all error: 1337
+test_all_settled
+promise_all_settled results:
+promise_all_settled results:
+fulfill 42
+reject 43
+fulfill 44
 finish