xbintsc 0.3.3 → 0.3.5

package/runtime/xt_generator.c

@@ -0,0 +1,304 @@
+/*
+ * xbintsc runtime — stackful generators.
+ *
+ * A generator function object carries `is_generator`. Calling it does not run
+ * the body; it creates an `xt_generator` that owns a private stack. `.next()`
+ * switches onto that stack, where the body runs until it calls `xt_yield`,
+ * which switches back. Because the body keeps a real call stack, `try`,
+ * `finally` and nested loops work across suspension points without a state
+ * machine transform.
+ *
+ * POSIX uses `ucontext` (`swapcontext`); Windows uses fibers. The generator's
+ * exception stack is swapped alongside it so a `throw` inside the body still
+ * targets the body's own `try` frames.
+ */
+
+#define _XOPEN_SOURCE 700
+
+#include "rt_internal.h"
+
+#include <stdlib.h>
+#include <string.h>
+
+#if defined(__APPLE__)
+#pragma clang diagnostic ignored "-Wdeprecated-declarations"
+#endif
+
+#ifdef _WIN32
+#include <windows.h>
+#else
+#include <ucontext.h>
+#endif
+
+typedef struct xt_generator {
+  xt_header header;
+  xt_value function;
+  xt_value this_value;
+  xt_value *args;
+  int32_t argc;
+  xt_value sent;   /* value passed by the most recent resume */
+  xt_value result; /* yielded / returned value, or a thrown exception */
+  /* Value pulled by `xt_iter_has` and consumed by `xt_iter_value`. */
+  xt_value iter_value;
+  int resume_kind; /* 0 = next, 1 = throw, 2 = return */
+  int started;
+  int done;
+  int threw;
+  int booted;
+  void *saved_try_top;
+#ifdef _WIN32
+  void *fiber;
+  void *caller_fiber;
+#else
+  ucontext_t ctx;
+  ucontext_t caller;
+  char *stack;
+#endif
+} xt_generator;
+
+/* The generator whose coroutine is running, if any. */
+static xt_generator *g_active_generator = NULL;
+/* Filled in just before a coroutine is first entered (POSIX has no portable
+ * way to pass a pointer to `makecontext`). */
+static xt_generator *g_boot_generator = NULL;
+#ifdef _WIN32
+static void *g_main_fiber = NULL;
+#endif
+
+int xt_is_generator(xt_value value) {
+  if (!XT_IS_OBJECT(value)) return 0;
+  return ((xt_header *)XT_GET_PTR(value))->kind == XT_OBJECT_KIND_GENERATOR;
+}
+
+static xt_generator *xt_as_generator(xt_value value) {
+  if (!xt_is_generator(value)) return NULL;
+  return (xt_generator *)XT_GET_PTR(value);
+}
+
+static xt_value xt_generator_result_object(xt_value value, int done) {
+  xt_value result = xt_object_new();
+  xt_object_set(result, xt_string_from_cstr("value"), value);
+  xt_object_set(result, xt_string_from_cstr("done"), xt_bool(done));
+  return result;
+}
+
+static void xt_generator_suspend(xt_generator *gen) {
+  gen->saved_try_top = xt_try_mark();
+#ifdef _WIN32
+  SwitchToFiber(gen->caller_fiber);
+#else
+  swapcontext(&gen->ctx, &gen->caller);
+#endif
+}
+
+/* Runs on the generator's private stack. */
+static void xt_generator_run(xt_generator *gen) {
+  void *boundary = xt_try_enter();
+  if (xt_try_setjmp(boundary) == 0) {
+    xt_function *function = (xt_function *)XT_GET_PTR(gen->function);
+    gen->result = function->code(gen->this_value, gen->function, gen->argc, gen->args);
+    gen->threw = 0;
+  } else {
+    gen->result = xt_try_exception(boundary);
+    gen->threw = 1;
+  }
+  gen->done = 1;
+  xt_generator_suspend(gen);
+}
+
+#ifndef _WIN32
+static void xt_generator_entry(void) {
+  xt_generator *gen = g_boot_generator;
+  g_boot_generator = NULL;
+  xt_generator_run(gen);
+}
+#else
+static void CALLBACK xt_generator_entry(void *param) {
+  xt_generator_run((xt_generator *)param);
+}
+#endif
+
+static void xt_generator_boot(xt_generator *gen) {
+#ifdef _WIN32
+  if (!g_main_fiber) g_main_fiber = ConvertThreadToFiber(NULL);
+  gen->fiber = CreateFiber(1 << 20, xt_generator_entry, gen);
+  if (!gen->fiber) abort();
+#else
+  size_t size = 1 << 20;
+  gen->stack = (char *)malloc(size);
+  if (!gen->stack) abort();
+  if (getcontext(&gen->ctx) != 0) abort();
+  gen->ctx.uc_stack.ss_sp = gen->stack;
+  gen->ctx.uc_stack.ss_size = size;
+  gen->ctx.uc_link = NULL;
+  g_boot_generator = gen;
+  makecontext(&gen->ctx, xt_generator_entry, 0);
+#endif
+  gen->booted = 1;
+}
+
+/* Release the private stack once the coroutine has finished. The generator
+ * object itself stays valid; later `.next()` calls just report `done`. */
+static void xt_generator_dispose(xt_generator *gen) {
+#ifdef _WIN32
+  if (gen->fiber) {
+    DeleteFiber(gen->fiber);
+    gen->fiber = NULL;
+  }
+  gen->caller_fiber = NULL;
+#else
+  if (gen->stack) {
+    free(gen->stack);
+    gen->stack = NULL;
+  }
+#endif
+}
+
+static void xt_generator_resume(xt_generator *gen) {
+  if (!gen->booted) xt_generator_boot(gen);
+  xt_generator *previous = g_active_generator;
+  g_active_generator = gen;
+  void *caller_try = xt_try_mark();
+  xt_try_restore(gen->saved_try_top);
+#ifdef _WIN32
+  gen->caller_fiber = GetCurrentFiber();
+  SwitchToFiber(gen->fiber);
+#else
+  swapcontext(&gen->caller, &gen->ctx);
+#endif
+  gen->saved_try_top = xt_try_mark();
+  xt_try_restore(caller_try);
+  if (gen->done) xt_generator_dispose(gen);
+  g_active_generator = previous;
+}
+
+xt_value xt_generator_new(xt_value function, xt_value thisValue, int32_t argc, xt_value *argv) {
+  xt_generator *gen = (xt_generator *)xt_alloc(sizeof(xt_generator), XT_OBJECT_KIND_GENERATOR);
+  gen->function = function;
+  gen->this_value = thisValue;
+  gen->argc = argc;
+  gen->result = XT_UNDEFINED;
+  gen->sent = XT_UNDEFINED;
+  gen->iter_value = XT_UNDEFINED;
+  if (argc > 0 && argv) {
+    gen->args = (xt_value *)malloc(sizeof(xt_value) * (size_t)argc);
+    if (!gen->args) abort();
+    memcpy(gen->args, argv, sizeof(xt_value) * (size_t)argc);
+  }
+  return XT_FROM_PTR(XT_TAG_OBJECT, gen);
+}
+
+xt_value xt_generator_next(xt_value generator, xt_value sent) {
+  xt_generator *gen = xt_as_generator(generator);
+  if (!gen) {
+    xt_throw(xt_string_from_cstr("TypeError: not a generator"));
+    return XT_UNDEFINED;
+  }
+  if (gen->done) return xt_generator_result_object(XT_UNDEFINED, 1);
+  gen->sent = sent;
+  gen->resume_kind = 0;
+  xt_generator_resume(gen);
+  if (gen->done) {
+    if (gen->threw) xt_throw(gen->result);
+    return xt_generator_result_object(gen->result, 1);
+  }
+  return xt_generator_result_object(gen->result, 0);
+}
+
+xt_value xt_generator_throw(xt_value generator, xt_value error) {
+  xt_generator *gen = xt_as_generator(generator);
+  if (!gen) {
+    xt_throw(xt_string_from_cstr("TypeError: not a generator"));
+    return XT_UNDEFINED;
+  }
+  if (gen->done) {
+    xt_throw(error);
+    return XT_UNDEFINED;
+  }
+  gen->sent = error;
+  gen->resume_kind = 1;
+  xt_generator_resume(gen);
+  if (gen->done) {
+    if (gen->threw) xt_throw(gen->result);
+    return xt_generator_result_object(gen->result, 1);
+  }
+  return xt_generator_result_object(gen->result, 0);
+}
+
+xt_value xt_generator_return(xt_value generator, xt_value value) {
+  xt_generator *gen = xt_as_generator(generator);
+  if (!gen) {
+    xt_throw(xt_string_from_cstr("TypeError: not a generator"));
+    return XT_UNDEFINED;
+  }
+  /* Abandon the coroutine without resuming: finally blocks are not run. */
+  gen->done = 1;
+  gen->threw = 0;
+  gen->result = value;
+  xt_generator_dispose(gen);
+  return xt_generator_result_object(value, 1);
+}
+
+/* Suspend the running generator with `value`; returns the value the caller
+ * passes to the next resume (`next(v)` / `throw(e)` / `return(v)`). */
+xt_value xt_yield(xt_value value) {
+  xt_generator *gen = g_active_generator;
+  if (!gen || gen->done) return XT_UNDEFINED;
+  gen->result = value;
+  xt_generator_suspend(gen);
+  if (gen->resume_kind == 1) {
+    xt_throw(gen->sent);
+    return XT_UNDEFINED;
+  }
+  if (gen->resume_kind == 2) {
+    gen->done = 1;
+    gen->threw = 0;
+    gen->result = gen->sent;
+    xt_generator_suspend(gen);
+    return XT_UNDEFINED;
+  }
+  return gen->sent;
+}
+
+/* `yield* delegate`: relay every value the delegate produces. */
+xt_value xt_yield_star(xt_value delegate) {
+  xt_value nextName = xt_string_from_cstr("next");
+  int usesNext = XT_IS_FUNCTION(xt_get(delegate, nextName));
+  /* A plain iterable (`[Symbol.iterator]` but no `next`) resolves through the
+   * iteration protocol; arrays/strings/Map/Set keep their index protocol. */
+  if (!usesNext) delegate = xt_iter_open(delegate);
+  xt_value sent = XT_UNDEFINED;
+  int32_t index = 0;
+  for (;;) {
+    xt_value value;
+    int done;
+    if (usesNext) {
+      xt_value step = xt_call_method(delegate, nextName, 1, &sent);
+      done = xt_truthy(xt_get(step, xt_string_from_cstr("done")));
+      value = xt_get(step, xt_string_from_cstr("value"));
+    } else {
+      xt_value position = xt_number((double)index);
+      if (!xt_truthy(xt_iter_has(delegate, position))) return XT_UNDEFINED;
+      value = xt_iter_value(delegate, position);
+      index++;
+      done = 0;
+    }
+    if (done) return value;
+    sent = xt_yield(value);
+  }
+}
+
+/* `for...of` step for generators: pull and cache the next value. */
+int xt_generator_has_next(xt_value generator) {
+  xt_generator *gen = xt_as_generator(generator);
+  if (!gen || gen->done) return 0;
+  xt_value step = xt_generator_next(generator, XT_UNDEFINED);
+  if (xt_truthy(xt_get(step, xt_string_from_cstr("done")))) return 0;
+  gen->iter_value = xt_get(step, xt_string_from_cstr("value"));
+  return 1;
+}
+
+xt_value xt_generator_iter_value(xt_value generator) {
+  xt_generator *gen = xt_as_generator(generator);
+  return gen ? gen->iter_value : XT_UNDEFINED;
+}

package/runtime/xt_io.c

@@ -7,15 +7,17 @@
  *
  * The generated IR calls `_setjmp` with two arguments — the jmp_buf and the
  * caller's frame address (`@llvm.frameaddress(0)`) — paired with `longjmp`
- * here. This is exactly what clang lowers a C `_setjmp(buf)` call to on MSVC.
- * On Windows the UCRT `_setjmp` takes the frame as a second argument and
- * stores it in `_JUMP_BUFFER.Frame`; `longjmp` passes that frame to
- * `RtlUnwind` to run the unwind. Calling `_setjmp` with only one argument left
- * `Frame` as garbage, so `longjmp` unwound to a bogus target
- * (`STATUS_BAD_FUNCTION_TABLE`, 0xC00000FF). `_setjmp` is used rather than the
- * exported `setjmp` symbol, which is a legacy two-argument routine with an
- * incompatible ABI; on Linux/macOS `_setjmp` simply ignores the extra
- * argument and pairs with `longjmp` (the XSI `_longjmp` does not exist on
+ * here. This is exactly what clang lowers a C `_setjmp(buf)` call to on MSVC:
+ * on Windows the UCRT `_setjmp` stores that frame in `_JUMP_BUFFER.Frame` and
+ * `longjmp` passes it to `RtlUnwind` to run the unwind, so omitting it makes
+ * `longjmp` unwind to a bogus target (`STATUS_BAD_FUNCTION_TABLE`,
+ * 0xC00000FF). Because the generated call is IR it must pass the frame
+ * explicitly; the C runtime (see `xt_try_setjmp`) instead follows whatever
+ * the active `<setjmp.h>` declares -- one argument on MSVC (clang injects the
+ * frame) and two on MinGW-w64. `_setjmp` is used
+ * rather than the exported `setjmp` symbol, whose Windows ABI is an
+ * incompatible two-argument routine; on Linux/macOS `_setjmp` takes only the
+ * buffer and pairs with `longjmp` (the XSI `_longjmp` does not exist on
  * Windows).
  */
 
@@ -43,12 +45,6 @@
  * with `xt_try_leave`. `xt_throw` longjmps into the innermost frame when one
  * is active, and only prints + exits when the exception is uncaught.
  */
-typedef struct xt_try_frame {
-  jmp_buf buf;
-  struct xt_try_frame *prev;
-  xt_value exception;
-} xt_try_frame;
-
 static xt_try_frame *g_try_top = NULL;
 
 /* Program arguments, captured once by `xt_set_program_args` from `main`. */
@@ -138,9 +134,18 @@ xt_value xt_try_exception(void *framePtr) {
 
 void xt_try_leave(void *framePtr) {
   xt_try_frame *frame = (xt_try_frame *)framePtr;
-  if (frame && g_try_top == frame) g_try_top = frame->prev;
+  if (frame && g_try_top == frame) {
+    g_try_top = frame->prev;
+    free(frame);
+  }
 }
 
+/* Save/restore the innermost try frame. Generators use this to swap their own
+ * exception stack in while they run on their private coroutine stack. */
+void *xt_try_mark(void) { return (void *)g_try_top; }
+
+void xt_try_restore(void *mark) { g_try_top = (xt_try_frame *)mark; }
+
 void xt_throw(xt_value v) {
   if (g_try_top) {
     g_try_top->exception = v;
@@ -172,8 +177,77 @@ void xt_println(xt_value v) {
 /*
  * console.log applies a Node-like inspection format: strings unquoted at the
  * top level, arrays as `[ a, b ]` and objects as `{ key: value }`.
+ *
+ * Recursion tracks the ancestor chain so self-referential containers print
+ * Node's `[Circular *N]` marker instead of recursing forever. `N` is the
+ * 1-based position of the repeated container in the current path.
  */
-static void xt_inspect(xt_value v, FILE *out) {
+#define XT_INSPECT_MAX_DEPTH 512
+static const void *xt_inspect_stack[XT_INSPECT_MAX_DEPTH];
+static int xt_inspect_depth = 0;
+
+static int xt_inspect_seen(const void *ptr) {
+  for (int i = 0; i < xt_inspect_depth; i++) {
+    if (xt_inspect_stack[i] == ptr) return i + 1;
+  }
+  return 0;
+}
+
+static void xt_inspect_push(const void *ptr) {
+  if (xt_inspect_depth < XT_INSPECT_MAX_DEPTH) xt_inspect_stack[xt_inspect_depth++] = ptr;
+}
+
+static void xt_inspect_pop(void) {
+  if (xt_inspect_depth > 0) xt_inspect_depth--;
+}
+
+static int xt_inspect_identifier_key(xt_string *key) {
+  if (key->length == 0) return 0;
+  char c = key->data[0];
+  if (!((c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || c == '_' || c == '$')) return 0;
+  for (uint32_t i = 1; i < key->length; i++) {
+    c = key->data[i];
+    if (!((c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || (c >= '0' && c <= '9') || c == '_' || c == '$')) return 0;
+  }
+  return 1;
+}
+
+/* Render a string the way `util.inspect` does inside a container: quoted,
+ * preferring whichever quote character needs fewer escapes. */
+static void xt_inspect_string(xt_string *s, FILE *out) {
+  int hasSingle = 0;
+  int hasDouble = 0;
+  for (uint32_t i = 0; i < s->length; i++) {
+    if (s->data[i] == '\'') hasSingle = 1;
+    else if (s->data[i] == '"') hasDouble = 1;
+  }
+  char quote = (hasSingle && !hasDouble) ? '"' : '\'';
+  fputc(quote, out);
+  for (uint32_t i = 0; i < s->length; i++) {
+    unsigned char c = (unsigned char)s->data[i];
+    switch (c) {
+      case '\\': fputs("\\\\", out); break;
+      case '\n': fputs("\\n", out); break;
+      case '\r': fputs("\\r", out); break;
+      case '\t': fputs("\\t", out); break;
+      case '\f': fputs("\\f", out); break;
+      case '\b': fputs("\\b", out); break;
+      case '\v': fputs("\\v", out); break;
+      default:
+        if (c == (unsigned char)quote) { fputc('\\', out); fputc(c, out); }
+        else if (c < 0x20) fprintf(out, "\\x%02x", c);
+        else fputc(c, out);
+    }
+  }
+  fputc(quote, out);
+}
+
+static void xt_inspect(xt_value v, FILE *out, int nested) {
+  if (xt_is_symbol(v)) {
+    xt_string *text = xt_as_string(xt_symbol_to_string(v));
+    fwrite(text->data, 1, text->length, out);
+    return;
+  }
   if (XT_IS_BIGINT(v)) {
     xt_value text = xt_bigint_to_decimal(v);
     xt_string *s = xt_as_string(text);
@@ -181,39 +255,105 @@ static void xt_inspect(xt_value v, FILE *out) {
     fputc('n', out);
     return;
   }
+  if (nested && XT_IS_STRING(v)) {
+    xt_inspect_string(xt_as_string(v), out);
+    return;
+  }
   if (XT_IS_ARRAY(v)) {
     xt_array *array = (xt_array *)XT_GET_PTR(v);
+    int seen = xt_inspect_seen(array);
+    if (seen > 0) {
+      fprintf(out, "[Circular *%d]", seen);
+      return;
+    }
+    if (xt_inspect_depth >= XT_INSPECT_MAX_DEPTH) {
+      fputs("[Array]", out);
+      return;
+    }
+    xt_inspect_push(array);
     fputc('[', out);
     for (uint32_t i = 0; i < array->length; i++) {
       if (i > 0) fputs(", ", out);
       else fputc(' ', out);
-      xt_inspect(array->items[i], out);
+      xt_inspect(array->items[i], out, 1);
+    }
+    if (XT_IS_OBJECT(array->extra)) {
+      xt_object *extra = (xt_object *)XT_GET_PTR(array->extra);
+      for (uint32_t i = 0; i < extra->count; i++) {
+        if (array->length > 0 || i > 0) fputs(", ", out);
+        else fputc(' ', out);
+        xt_value key = extra->properties[i].key;
+        if (xt_is_symbol(key)) {
+          xt_string *text = xt_as_string(xt_symbol_to_string(key));
+          fwrite(text->data, 1, text->length, out);
+        } else {
+          xt_string *keyString = xt_as_string(key);
+          fwrite(keyString->data, 1, keyString->length, out);
+        }
+        fputs(": ", out);
+        xt_inspect(extra->properties[i].value, out, 1);
+      }
     }
-    if (array->length > 0) fputc(' ', out);
+    if (array->length > 0 || (XT_IS_OBJECT(array->extra) && ((xt_object *)XT_GET_PTR(array->extra))->count > 0)) fputc(' ', out);
     fputc(']', out);
+    xt_inspect_pop();
     return;
   }
   if (XT_IS_OBJECT(v)) {
     xt_object *obj = (xt_object *)XT_GET_PTR(v);
+    int seen = xt_inspect_seen(obj);
+    if (seen > 0) {
+      fprintf(out, "[Circular *%d]", seen);
+      return;
+    }
+    if (xt_inspect_depth >= XT_INSPECT_MAX_DEPTH) {
+      fputs("[Object]", out);
+      return;
+    }
+    xt_inspect_push(obj);
     fputc('{', out);
-    for (uint32_t i = 0; i < obj->count; i++) {
-      if (i > 0) fputs(", ", out);
-      else fputc(' ', out);
-      fwrite(obj->properties[i].key->data, 1, obj->properties[i].key->length, out);
-      fputs(": ", out);
-      xt_inspect(obj->properties[i].value, out);
+    /* `util.inspect` lists string keys first, then symbol keys, in insertion
+     * order; symbol keys are printed without brackets. */
+    int written = 0;
+    for (int pass = 0; pass < 2; pass++) {
+      for (uint32_t i = 0; i < obj->count; i++) {
+        xt_value key = obj->properties[i].key;
+        int isSymbol = xt_is_symbol(key);
+        if ((pass == 0) == isSymbol) continue;
+        if (written > 0) fputs(", ", out);
+        else fputc(' ', out);
+        written++;
+        if (isSymbol) {
+          xt_string *text = xt_as_string(xt_symbol_to_string(key));
+          fwrite(text->data, 1, text->length, out);
+        } else {
+          xt_string *keyString = xt_as_string(key);
+          if (xt_inspect_identifier_key(keyString)) fwrite(keyString->data, 1, keyString->length, out);
+          else xt_inspect_string(keyString, out);
+        }
+        fputs(": ", out);
+        xt_inspect(obj->properties[i].value, out, 1);
+      }
     }
-    if (obj->count > 0) fputc(' ', out);
+    if (written > 0) fputc(' ', out);
     fputc('}', out);
+    xt_inspect_pop();
     return;
   }
   xt_print_value(v, out);
 }
 
+/* Inspect one top-level value; reset the ancestor chain so nested console
+ * calls (or a `longjmp` out of a throw) never leave stale state behind. */
+static void xt_inspect_top(xt_value v, FILE *out) {
+  xt_inspect_depth = 0;
+  xt_inspect(v, out, 0);
+}
+
 void xt_console_log(int32_t argc, xt_value *argv) {
   for (int32_t i = 0; i < argc; i++) {
     if (i > 0) fputc(' ', stdout);
-    xt_inspect(argv[i], stdout);
+    xt_inspect_top(argv[i], stdout);
   }
   fputc('\n', stdout);
 }
@@ -221,7 +361,7 @@ void xt_console_log(int32_t argc, xt_value *argv) {
 static void xt_console_write(int32_t argc, xt_value *argv, FILE *out) {
   for (int32_t i = 0; i < argc; i++) {
     if (i > 0) fputc(' ', out);
-    xt_inspect(argv[i], out);
+    xt_inspect_top(argv[i], out);
   }
   fputc('\n', out);
 }
@@ -239,7 +379,7 @@ xt_value xt_console_trace(int32_t argc, xt_value *argv) {
   fputs("Trace", stderr);
   for (int32_t i = 0; i < argc; i++) {
     fputc(' ', stderr);
-    xt_inspect(argv[i], stderr);
+    xt_inspect_top(argv[i], stderr);
   }
   fputc('\n', stderr);
   return XT_UNDEFINED;
@@ -251,7 +391,7 @@ xt_value xt_console_assert(int32_t argc, xt_value *argv) {
     if (argc > 1) fputs(":", stderr);
     for (int32_t i = 1; i < argc; i++) {
       fputc(' ', stderr);
-      xt_inspect(argv[i], stderr);
+      xt_inspect_top(argv[i], stderr);
     }
     fputc('\n', stderr);
   }

package/runtime/xt_promise.c

@@ -210,6 +210,7 @@ xt_value xt_promise_static(xt_value name, int32_t argc, xt_value *argv) {
     if (XT_IS_ARRAY(iterable)) {
       xt_array *array = xt_as_array(iterable);
       int anyRejected = 0;
+      xt_value reasons = xt_array_new(0, NULL);
       for (uint32_t i = 0; i < array->length; i++) {
         xt_value item = array->items[i];
         xt_promise *inner = xt_is_promise(item) ? xt_as_promise(item) : NULL;
@@ -224,6 +225,7 @@ xt_value xt_promise_static(xt_value name, int32_t argc, xt_value *argv) {
         if (rejected) {
           if (strcmp(fn, "any") == 0) {
             anyRejected++;
+            xt_array_push(reasons, inner->value);
             continue;
           }
           xt_promise_settle(result, XT_PROMISE_REJECTED, inner->value);
@@ -237,7 +239,10 @@ xt_value xt_promise_static(xt_value name, int32_t argc, xt_value *argv) {
         xt_array_push(values, settled);
       }
       if (strcmp(fn, "any") == 0 && anyRejected > 0) {
-        xt_promise_settle(result, XT_PROMISE_REJECTED, xt_string_from_cstr("AggregateError: all promises rejected"));
+        xt_value ctorArgv[2];
+        ctorArgv[0] = reasons;
+        ctorArgv[1] = xt_string_from_cstr("All promises were rejected");
+        xt_promise_settle(result, XT_PROMISE_REJECTED, xt_aggregate_error_ctor(2, ctorArgv));
         return xt_promise_value(result);
       }
     }