xbintsc 0.3.87 → 0.5.6

package/runtime/xt_async.c

@@ -0,0 +1,197 @@
+/*
+ * xbintsc runtime — real `async` / `await`.
+ *
+ * An `async` function runs its body on a stackful coroutine (the same
+ * machinery generators use, see `xt_coroutine.c`) and immediately returns a
+ * promise. The body runs synchronously until it reaches an `await` whose
+ * operand is still pending; at that point the coroutine suspends and control
+ * returns to the caller, so the program body or the event loop can keep going.
+ * When the awaited promise settles, the promise runtime queues a microtask that
+ * resumes the coroutine exactly where it stopped — because the coroutine keeps
+ * a real C stack, `try`/`finally`, loops and locals all survive the suspension
+ * without a state-machine transform.
+ *
+ * `await` on an already-settled value keeps the historical fast path: it
+ * returns (or throws) synchronously instead of forcing a microtask turn. This
+ * makes the common "await a synchronous builtin" case cheap and preserves the
+ * existing ordering guarantees.
+ */
+
+#include "rt_internal.h"
+
+#include <stdlib.h>
+#include <string.h>
+
+typedef struct xt_async {
+  xt_header header;
+  xt_value function;
+  xt_value this_value;
+  xt_value *args;
+  int32_t argc;
+  /* Promise returned to the caller and settled when the body finishes. */
+  xt_value promise;
+  /* Completion value, or the exception that escaped the body. */
+  xt_value value;
+  /* Values handed over by the waiter and consumed by `xt_await`. */
+  xt_value resume_value;
+  int await_threw;
+  int done;
+  int threw;
+  xt_coroutine *coroutine;
+} xt_async;
+
+/* The async coroutine currently running on its private stack, if any. It is
+ * only reachable through this pointer while it runs, so it is a GC root. */
+static xt_async *g_active_async = NULL;
+
+static void xt_async_gc_register(void);
+
+/* Runs on the coroutine's private stack and never returns normally: it
+ * suspends back to the resumer once the body has completed. */
+static void xt_async_run(void *arg) {
+  xt_async *async = (xt_async *)arg;
+  void *boundary = xt_try_enter();
+  if (xt_try_setjmp(boundary) == 0) {
+    xt_function *function = (xt_function *)XT_GET_PTR(async->function);
+    async->value = function->code(async->this_value, async->function, async->argc, async->args);
+    async->threw = 0;
+  } else {
+    /* `throw` inside the body (not caught by a `try`) rejects the promise. */
+    async->value = xt_try_exception(boundary);
+    async->threw = 1;
+  }
+  async->done = 1;
+  xt_coroutine_leave(async->coroutine);
+}
+
+/* Switch onto the coroutine. It either suspends at an `await` or completes. */
+static void xt_async_resume(xt_async *async) {
+  xt_async *previous = g_active_async;
+  g_active_async = async;
+  xt_coroutine_enter(async->coroutine);
+  g_active_async = previous;
+  if (!async->done) return;
+  xt_coroutine_release(async->coroutine);
+  async->coroutine = NULL;
+  if (async->threw) xt_promise_reject_value(async->promise, async->value);
+  else xt_promise_fulfill(async->promise, async->value);
+}
+
+xt_value xt_async_call(xt_value function, xt_value thisValue, int32_t argc, xt_value *argv) {
+  xt_async *async = (xt_async *)xt_alloc(sizeof(xt_async), XT_OBJECT_KIND_ASYNC);
+  async->function = function;
+  async->this_value = thisValue;
+  async->argc = argc;
+  async->args = NULL;
+  if (argc > 0 && argv) {
+    async->args = (xt_value *)malloc(sizeof(xt_value) * (size_t)argc);
+    if (!async->args) abort();
+    memcpy(async->args, argv, sizeof(xt_value) * (size_t)argc);
+  }
+  async->promise = xt_promise_create();
+  async->value = XT_UNDEFINED;
+  async->resume_value = XT_UNDEFINED;
+  async->await_threw = 0;
+  async->done = 0;
+  async->threw = 0;
+  async->coroutine = xt_coroutine_create(xt_async_run, async);
+  xt_async_gc_register();
+  /* Start synchronously, matching JavaScript: the body runs up to its first
+   * pending `await` before the call returns. */
+  xt_async_resume(async);
+  return async->promise;
+}
+
+void xt_async_wake(void *asyncPointer, xt_value value, int rejected) {
+  xt_async *async = (xt_async *)asyncPointer;
+  if (!async || async->done || !async->coroutine) return;
+  async->resume_value = value;
+  async->await_threw = rejected;
+  xt_async_resume(async);
+}
+
+/* `await value`: unwrap promises, suspending the running async coroutine when
+ * the promise is still pending. */
+xt_value xt_await(xt_value value) {
+  int state = xt_promise_state_of(value);
+  if (state < 0) return value;
+  if (state == XT_PROMISE_REJECTED) {
+    xt_throw(xt_promise_value_of(value));
+    return XT_UNDEFINED;
+  }
+  if (state == XT_PROMISE_FULFILLED) return xt_promise_value_of(value);
+
+  xt_async *async = g_active_async;
+  if (async && async->coroutine) {
+    async->await_threw = 0;
+    async->resume_value = XT_UNDEFINED;
+    xt_promise_add_async_waiter(value, async);
+    xt_coroutine_leave(async->coroutine);
+    /* The waiter resumed us. A rejection is rethrown inside the coroutine so
+     * its own `try`/`catch` and `finally` see it. */
+    if (async->await_threw) {
+      async->await_threw = 0;
+      xt_throw(async->resume_value);
+      return XT_UNDEFINED;
+    }
+    return async->resume_value;
+  }
+
+  /* No coroutine to suspend (top-level `await`, or `await` reached outside an
+   * async function): block on the reactor until the promise settles, exactly
+   * like a synchronous embedder waiting for the event loop. The loop returns
+   * immediately when no work remains, so a promise nothing can settle does not
+   * hang the process here. */
+  for (int guard = 0; guard < 100000; guard++) {
+    xt_drain_microtasks();
+    state = xt_promise_state_of(value);
+    if (state != XT_PROMISE_PENDING) break;
+    if (!xt_loop_has_work()) break;
+    if (xt_loop_poll(-1) < 0) break;
+  }
+  state = xt_promise_state_of(value);
+  if (state == XT_PROMISE_REJECTED) {
+    xt_throw(xt_promise_value_of(value));
+    return XT_UNDEFINED;
+  }
+  return state == XT_PROMISE_FULFILLED ? xt_promise_value_of(value) : XT_UNDEFINED;
+}
+
+/* While a coroutine runs, the async object is only reachable through this
+ * static pointer. */
+static void xt_async_gc_scan_roots(void) {
+  if (!g_active_async) return;
+  xt_gc_mark_header((xt_header *)g_active_async);
+}
+
+static void xt_async_gc_register(void) {
+  static int registered = 0;
+  if (registered) return;
+  registered = 1;
+  xt_gc_register_root_provider(xt_async_gc_scan_roots);
+}
+
+void xt_async_gc_trace(xt_header *header) {
+  xt_async *async = (xt_async *)header;
+  xt_gc_mark_value(async->function);
+  xt_gc_mark_value(async->this_value);
+  xt_gc_mark_value(async->promise);
+  xt_gc_mark_value(async->value);
+  xt_gc_mark_value(async->resume_value);
+  if (async->args && async->argc > 0) {
+    xt_gc_scan_region(async->args, sizeof(xt_value) * (size_t)async->argc);
+  }
+  xt_coroutine_gc_trace(async->coroutine);
+}
+
+void xt_async_gc_release(xt_header *header) {
+  xt_async *async = (xt_async *)header;
+  free(async->args);
+  xt_coroutine_release(async->coroutine);
+  async->coroutine = NULL;
+}
+
+xt_value xt_function_set_async(xt_value value) {
+  if (XT_IS_FUNCTION(value)) ((xt_function *)XT_GET_PTR(value))->is_async = 1;
+  return value;
+}

package/runtime/xt_builtins.c

@@ -18,23 +18,22 @@
 
 xt_value xt_object_values(xt_value value) {
   xt_value result = xt_array_new(0, NULL);
-  if (!XT_IS_OBJECT(value)) return result;
-  xt_object *obj = (xt_object *)XT_GET_PTR(value);
-  for (uint32_t i = 0; i < obj->count; i++) {
-    if (XT_IS_STRING(obj->properties[i].key)) xt_array_push(result, obj->properties[i].value);
-  }
+  xt_value keys = xt_object_keys(value);
+  xt_array *array = xt_as_array(keys);
+  if (!array) return result;
+  for (uint32_t i = 0; i < array->length; i++) xt_array_push(result, xt_get(value, array->items[i]));
   return result;
 }
 
 xt_value xt_object_entries(xt_value value) {
   xt_value result = xt_array_new(0, NULL);
-  if (!XT_IS_OBJECT(value)) return result;
-  xt_object *obj = (xt_object *)XT_GET_PTR(value);
-  for (uint32_t i = 0; i < obj->count; i++) {
-    if (!XT_IS_STRING(obj->properties[i].key)) continue;
+  xt_value keys = xt_object_keys(value);
+  xt_array *array = xt_as_array(keys);
+  if (!array) return result;
+  for (uint32_t i = 0; i < array->length; i++) {
     xt_value pair = xt_array_new(0, NULL);
-    xt_array_push(pair, obj->properties[i].key);
-    xt_array_push(pair, obj->properties[i].value);
+    xt_array_push(pair, array->items[i]);
+    xt_array_push(pair, xt_get(value, array->items[i]));
     xt_array_push(result, pair);
   }
   return result;
@@ -45,8 +44,11 @@ xt_value xt_object_assign(int32_t argc, xt_value *argv) {
   xt_value target = argv[0];
   if (!XT_IS_OBJECT(target)) return target;
   for (int32_t i = 1; i < argc; i++) {
-    if (!XT_IS_OBJECT(argv[i])) continue;
-    xt_object *source = (xt_object *)XT_GET_PTR(argv[i]);
+    if (!XT_IS_OBJECT(argv[i]) && !XT_IS_ARRAY(argv[i]) && !XT_IS_STRING(argv[i])) continue;
+    /* Arrays and strings contribute their index properties, exactly like
+     * `{ ..."ab" }` / `Object.assign({}, [1, 2])` in ECMAScript. */
+    xt_value properties = xt_object_rest(argv[i], 0, NULL);
+    xt_object *source = (xt_object *)XT_GET_PTR(properties);
     for (uint32_t j = 0; j < source->count; j++) {
       xt_object_set(target, source->properties[j].key, source->properties[j].value);
     }
@@ -102,11 +104,11 @@ xt_value xt_object_rest(xt_value source, int32_t argc, xt_value *argv) {
 
   if (XT_IS_STRING(source)) {
     xt_string *string = (xt_string *)XT_GET_PTR(source);
-    const char *bytes = xt_string_bytes(string);
-    for (uint32_t i = 0; i < string->length; i++) {
+    uint32_t units = xt_string_utf16_length(string);
+    for (uint32_t i = 0; i < units; i++) {
       char buffer[16];
       snprintf(buffer, sizeof(buffer), "%u", i);
-      xt_object_rest_copy(result, xt_string_from_cstr(buffer), xt_string_new(bytes + i, 1), argc, argv);
+      xt_object_rest_copy(result, xt_string_from_cstr(buffer), xt_string_unit_value(string, (int32_t)i), argc, argv);
     }
     return result;
   }
@@ -395,7 +397,7 @@ xt_value xt_in(xt_value key, xt_value value) {
     xt_string *k = xt_as_string(xt_to_string(key));
     if (k->length == 6 && memcmp(xt_string_bytes(k), "length", 6) == 0) return XT_TRUE;
     int32_t index = xt_to_int32(key);
-    return xt_bool(index >= 0 && (uint32_t)index < s->length);
+    return xt_bool(index >= 0 && (uint32_t)index < xt_string_utf16_length(s));
   }
   return XT_FALSE;
 }
@@ -446,6 +448,9 @@ xt_value xt_closure_new(void *fn, int32_t env_count, xt_value *env) {
   function->properties = NULL;
   function->environment = NULL;
   function->prototype = XT_UNDEFINED;
+  function->is_generator = 0;
+  function->is_async = 0;
+  function->builtin_name = NULL;
   if (env_count > 0) {
     function->environment = (xt_value *)malloc(sizeof(xt_value) * (size_t)env_count);
     for (int32_t i = 0; i < env_count; i++) function->environment[i] = env[i];
@@ -466,6 +471,9 @@ xt_value xt_call_with_this(xt_value value, xt_value thisValue, int32_t argc, xt_
   /* Calling a generator function returns a suspended generator instead of
    * running the body. */
   if (function->is_generator) return xt_generator_new(value, thisValue, argc, argv);
+  /* An `async` function runs its body on a coroutine and returns a promise,
+   * which may already be settled or may resolve after an event-loop turn. */
+  if (function->is_async) return xt_async_call(value, thisValue, argc, argv);
   /* The closure value itself is threaded through as `env` so the callee can
    * read its captures with xt_closure_env(env, i). */
   return function->code(thisValue, value, argc, argv);
@@ -478,11 +486,6 @@ xt_value xt_function_set_prototype(xt_value value, xt_value proto) {
   return value;
 }
 
-xt_value xt_function_set_generator(xt_value value) {
-  if (XT_IS_FUNCTION(value)) ((xt_function *)XT_GET_PTR(value))->is_generator = 1;
-  return value;
-}
-
 xt_value xt_function_get_prototype(xt_value value) {
   if (XT_IS_FUNCTION(value)) return ((xt_function *)XT_GET_PTR(value))->prototype;
   return XT_UNDEFINED;
@@ -497,22 +500,22 @@ xt_value xt_new(xt_value ctor, int32_t argc, xt_value *argv) {
   xt_value proto = function->prototype;
   xt_value instance = xt_object_new_with_proto(XT_IS_OBJECT(proto) ? proto : XT_UNDEFINED);
   xt_value result = function->code(instance, ctor, argc, argv);
-  if (XT_IS_OBJECT(result) || XT_IS_ARRAY(result)) return result;
+  if (XT_IS_OBJECT(result) || XT_IS_ARRAY(result) || XT_IS_FUNCTION(result)) return result;
   return instance;
 }
 
 xt_value xt_instance_of(xt_value value, xt_value ctor) {
   if (!XT_IS_FUNCTION(ctor)) return XT_FALSE;
   xt_value proto = ((xt_function *)XT_GET_PTR(ctor))->prototype;
-  if (!XT_IS_OBJECT(proto)) return XT_FALSE;
-  if (!XT_IS_OBJECT(value)) return XT_FALSE;
-  xt_object *cur = (xt_object *)XT_GET_PTR(value);
-  xt_object *target = (xt_object *)XT_GET_PTR(proto);
-  cur = (xt_object *)XT_GET_PTR(XT_IS_OBJECT(cur->prototype) ? cur->prototype : XT_UNDEFINED);
-  while (cur) {
-    if (cur == target) return XT_TRUE;
-    if (!XT_IS_OBJECT(cur->prototype)) break;
-    cur = (xt_object *)XT_GET_PTR(cur->prototype);
+  if (XT_IS_OBJECT(proto) || XT_IS_ARRAY(proto) || XT_IS_FUNCTION(proto)) {
+    /* Walk the value's [[Prototype]] chain. `xt_object_get_prototype` knows the
+     * layout of every kind (arrays carry a prototype field; Map/Set/Date/... use
+     * their built-in prototype), so this is safe for containers too. */
+    xt_value cursor = xt_object_get_prototype(value);
+    while (cursor != XT_UNDEFINED && cursor != XT_NULL) {
+      if (cursor == proto) return XT_TRUE;
+      cursor = xt_object_get_prototype(cursor);
+    }
   }
   return XT_FALSE;
 }
@@ -520,10 +523,11 @@ xt_value xt_instance_of(xt_value value, xt_value ctor) {
 /*
  * `value instanceof Array` (and the rest of the built-in constructors).
  *
- * Built-in constructors are not first-class values: the codegen recognises the
- * name and asks this helper instead. Ids match `BUILTIN_INSTANCEOF` in
- * `src/codegen/generator/tables.ts`; 16..24 map onto the runtime's `XT_TA_*`
- * order (Uint8Array first).
+ * The codegen recognises the direct spelling and asks this helper instead of
+ * materialising the constructor value; an alias (`const A = Array`) goes
+ * through the ordinary prototype chain in `xt_instance_of`. Ids match
+ * `BUILTIN_INSTANCEOF` in `src/codegen/generator/tables.ts`; 16..24 map onto
+ * the runtime's `XT_TA_*` order (Uint8Array first).
  */
 enum {
   XT_INSTANCE_ARRAY = 0,