xbintsc 0.5.6 → 0.5.21

package/runtime/xt_containers/access.inc

@@ -32,7 +32,77 @@ static void xt_throw_read_of_nullish(xt_value target, xt_value key) {
   char message[256];
   snprintf(message, sizeof(message),
            "TypeError: Cannot read properties of %s (reading '%s')", base, keybuf);
-  xt_throw(xt_string_from_cstr(message));
+  xt_throw(xt_error_from_message(message));
+}
+
+/* -- Array.prototype[Symbol.iterator] -------------------------------------- */
+/*
+ * `for...of` and spread use the internal index protocol, but libraries also
+ * call the iterator method explicitly (`arr[Symbol.iterator]()`, `Array.from`,
+ * manual `.next()`). Build a small iterator object per call: `next` closes over
+ * the array and a one-element box holding the current index, and the iterator
+ * is itself iterable so it can be passed back to `for...of` / spread.
+ */
+static xt_value xt_array_iterator_next(xt_value thisValue, xt_value env, int32_t argc,
+                                       xt_value *argv) {
+  (void)thisValue;
+  (void)argc;
+  (void)argv;
+  xt_value array = xt_closure_env(env, 0);
+  xt_value indexBox = xt_closure_env(env, 1);
+  int32_t index = xt_to_int32(xt_get(indexBox, xt_number(0)));
+  xt_array *items = xt_as_array(array);
+  xt_value result = xt_object_new();
+  if (!items || index < 0 || (uint32_t)index >= items->length) {
+    xt_object_set(result, xt_string_from_cstr("value"), XT_UNDEFINED);
+    xt_object_set(result, xt_string_from_cstr("done"), XT_TRUE);
+    return result;
+  }
+  xt_object_set(result, xt_string_from_cstr("value"), items->items[index]);
+  xt_object_set(result, xt_string_from_cstr("done"), XT_FALSE);
+  xt_set(indexBox, xt_number(0), xt_number(index + 1));
+  return result;
+}
+
+static xt_value xt_iterator_return_this(xt_value thisValue, xt_value env, int32_t argc,
+                                        xt_value *argv) {
+  (void)env;
+  (void)argc;
+  (void)argv;
+  return thisValue;
+}
+
+static xt_value xt_array_iterator(xt_value thisValue, xt_value env, int32_t argc,
+                                  xt_value *argv) {
+  (void)env;
+  (void)argc;
+  (void)argv;
+  if (!XT_IS_ARRAY(thisValue)) {
+    xt_value message =
+        xt_string_from_cstr("Array.prototype[Symbol.iterator] called on a non-array");
+    xt_throw(xt_type_error_ctor(1, &message));
+  }
+  xt_value indexBox = xt_array_new(0, NULL);
+  xt_array_push(indexBox, xt_number(0));
+  xt_value captured[2] = {thisValue, indexBox};
+  xt_value iterator = xt_object_new();
+  xt_object_set(iterator, xt_string_from_cstr("next"),
+                xt_closure_new((void *)xt_array_iterator_next, 2, captured));
+  xt_object_set(iterator, xt_symbol_well_known("iterator"),
+                xt_closure_new((void *)xt_iterator_return_this, 0, NULL));
+  return iterator;
+}
+
+/* The method value is stable (`arr[Symbol.iterator] === arr[Symbol.iterator]`),
+ * so cache it and root the cache for the collector. */
+static xt_value xt_array_iterator_method_value = XT_UNDEFINED;
+
+static xt_value xt_array_iterator_method(void) {
+  if (!XT_IS_FUNCTION(xt_array_iterator_method_value)) {
+    xt_array_iterator_method_value = xt_closure_new((void *)xt_array_iterator, 0, NULL);
+    xt_gc_add_root(&xt_array_iterator_method_value);
+  }
+  return xt_array_iterator_method_value;
 }
 
 xt_value xt_get(xt_value target, xt_value key) {
@@ -71,6 +141,9 @@ xt_value xt_get(xt_value target, xt_value key) {
         xt_value value = xt_object_get(extra, key);
         if (value != XT_UNDEFINED) return value;
       }
+      /* Array.prototype[Symbol.iterator] is the fallback, after any own
+       * symbol property the program assigned. */
+      if (key == xt_symbol_well_known("iterator")) return xt_array_iterator_method();
       xt_value method = xt_method_value(target, key);
       if (method != XT_UNDEFINED) return method;
       xt_value proto = ((xt_array *)XT_GET_PTR(target))->prototype;
@@ -105,6 +178,17 @@ xt_value xt_get(xt_value target, xt_value key) {
     /* Map/Set expose `.size`; promises, dates and regexps have their own
      * getters implemented in the standard library. */
     xt_object *obj = (xt_object *)XT_GET_PTR(target);
+    if (obj->header.kind == XT_OBJECT_KIND_GENERATOR && xt_is_symbol(key)) {
+      /* Generators are iterable objects: `Symbol.iterator` returns the
+       * generator itself, and an async generator also exposes
+       * `Symbol.asyncIterator`. */
+      if (key == xt_symbol_well_known("asyncIterator") && xt_is_async_generator(target)) {
+        return xt_async_iterator_method();
+      }
+      if (key == xt_symbol_well_known("iterator") && !xt_is_async_generator(target)) {
+        return xt_async_iterator_method();
+      }
+    }
     if (obj->header.kind == XT_OBJECT_KIND_SYMBOL) {
       if (XT_IS_STRING(key)) {
         xt_string *k = xt_as_string(key);
@@ -138,6 +222,25 @@ xt_value xt_get(xt_value target, xt_value key) {
       }
     }
     {
+      /* Typed arrays keep their elements in a shared ArrayBuffer: serve
+       * `.buffer` / element reads from it instead of the property bag. */
+      int typed = xt_typed_array_kind_of(target);
+      if (typed >= 0) {
+        if (XT_IS_STRING(key)) {
+          xt_string *k = xt_as_string(key);
+          if (k->length == 6 && memcmp(xt_string_bytes(k), "buffer", 6) == 0) {
+            return xt_typed_array_buffer_of(target);
+          }
+          if (k->length == 10 && memcmp(xt_string_bytes(k), "byteOffset", 10) == 0) {
+            return xt_number((double)xt_typed_array_byte_offset_of(target));
+          }
+          uint32_t index = 0;
+          if (xt_key_is_array_index(k, &index)) return xt_typed_array_read(target, index);
+        } else if (XT_IS_NUMBER(key)) {
+          int32_t index = xt_to_int32(key);
+          if (index >= 0) return xt_typed_array_read(target, (uint32_t)index);
+        }
+      }
       xt_value value = xt_object_get(target, key);
       if (value != XT_UNDEFINED) return value;
       xt_value method = xt_method_value(target, key);
@@ -174,6 +277,47 @@ xt_value xt_get(xt_value target, xt_value key) {
   return XT_UNDEFINED;
 }
 
+/* Inline-cached property read. The generated code gives every source-level
+ * property access two zeroed i64 words; the first stores the receiver's shape
+ * and the second the property index. A shape hit is a pointer compare plus one
+ * key check, which avoids the linear property scan. Only ordinary objects and
+ * errors use the cache; arrays, functions, strings and containers fall back to
+ * the generic path. */
+xt_value xt_get_ic(xt_value target, xt_value key, int64_t *cache) {
+  if (!cache || !XT_IS_OBJECT(target)) return xt_get(target, key);
+  xt_object *obj = (xt_object *)XT_GET_PTR(target);
+  if (obj->header.kind != XT_OBJECT_KIND_OBJECT && obj->header.kind != XT_OBJECT_KIND_ERROR) {
+    return xt_get(target, key);
+  }
+  if (!XT_IS_STRING(key) && !xt_is_symbol(key)) return xt_get(target, key);
+  xt_shape *shape = obj->shape;
+  uintptr_t cachedShape = (uintptr_t)cache[0];
+  int64_t cachedIndex = cache[1];
+  if (shape && cachedShape == (uintptr_t)shape && cachedIndex >= 0 &&
+      cachedIndex < (int64_t)obj->count) {
+    xt_property *prop = &obj->properties[cachedIndex];
+    if (prop->key == key || xt_property_key_equals(prop->key, key)) {
+      if (prop->getter != XT_UNDEFINED && XT_IS_FUNCTION(prop->getter)) {
+        return xt_call_with_this(prop->getter, target, 0, NULL);
+      }
+      if (prop->getter != XT_UNDEFINED) return XT_UNDEFINED;
+      return prop->value;
+    }
+  }
+  xt_value propertyKey = xt_to_property_key(key);
+  xt_property *prop = xt_object_find_property(obj, propertyKey);
+  if (prop) {
+    cache[0] = (int64_t)(uintptr_t)shape;
+    cache[1] = (int64_t)(prop - obj->properties);
+    if (prop->getter != XT_UNDEFINED && XT_IS_FUNCTION(prop->getter)) {
+      return xt_call_with_this(prop->getter, target, 0, NULL);
+    }
+    if (prop->getter != XT_UNDEFINED) return XT_UNDEFINED;
+    return prop->value;
+  }
+  return xt_get(target, key);
+}
+
 xt_value xt_set(xt_value target, xt_value key, xt_value value) {
   if (XT_IS_ARRAY(target)) {
     /* Assigning `arr.length` truncates or extends the array. */
@@ -209,7 +353,7 @@ xt_value xt_set(xt_value target, xt_value key, xt_value value) {
         if ((k->length == 6 && memcmp(xt_string_bytes(k), "length", 6) == 0) ||
             (k->length == 10 && memcmp(xt_string_bytes(k), "byteLength", 10) == 0) ||
             (k->length == 10 && memcmp(xt_string_bytes(k), "byteOffset", 10) == 0)) {
-          xt_throw(xt_string_from_cstr("TypeError: Cannot assign to read only property"));
+          xt_throw(xt_error_from_message("TypeError: Cannot assign to read only property"));
           return value;
         }
       }
@@ -227,7 +371,8 @@ xt_value xt_set(xt_value target, xt_value key, xt_value value) {
       if (isIndex) {
         double length = xt_to_number(xt_object_get_cstr(target, "length"));
         if (index >= (uint32_t)length) return value; /* out-of-bounds writes are ignored */
-        return xt_object_set(target, key, xt_number(xt_typed_array_coerce(typed, xt_to_number(value))));
+        xt_typed_array_write(target, index, value);
+        return value;
       }
     }
     return xt_object_set(target, key, value);

package/runtime/xt_containers/objects.inc

@@ -47,6 +47,9 @@ static const char *xt_object_tag_of(xt_value value) {
       case XT_OBJECT_KIND_ERROR: return "Error";
       case XT_OBJECT_KIND_MAP: return "Map";
       case XT_OBJECT_KIND_SET: return "Set";
+      case XT_OBJECT_KIND_WEAK_MAP: return "WeakMap";
+      case XT_OBJECT_KIND_WEAK_SET: return "WeakSet";
+      case XT_OBJECT_KIND_WEAK_REF: return "WeakRef";
       case XT_OBJECT_KIND_DATE: return "Date";
       case XT_OBJECT_KIND_REGEXP: return "RegExp";
       case XT_OBJECT_KIND_PROMISE: return "Promise";
@@ -68,13 +71,13 @@ static xt_value xt_object_proto_method(xt_value thisValue, xt_value env, int32_t
   if (!name) return XT_UNDEFINED;
   if (strcmp(name, "hasOwnProperty") == 0) {
     if (thisValue == XT_UNDEFINED || thisValue == XT_NULL) {
-      xt_throw(xt_string_from_cstr("TypeError: Cannot convert undefined or null to object"));
+      xt_throw(xt_error_from_message("TypeError: Cannot convert undefined or null to object"));
     }
     return xt_object_has_own(thisValue, xt_arg_at(argc, argv, 0));
   }
   if (strcmp(name, "propertyIsEnumerable") == 0) {
     if (thisValue == XT_UNDEFINED || thisValue == XT_NULL) {
-      xt_throw(xt_string_from_cstr("TypeError: Cannot convert undefined or null to object"));
+      xt_throw(xt_error_from_message("TypeError: Cannot convert undefined or null to object"));
     }
     /* Enumerability is not tracked; every own property is enumerable. */
     return xt_object_has_own(thisValue, xt_arg_at(argc, argv, 0));
@@ -163,6 +166,7 @@ xt_value xt_object_new_with_proto(xt_value proto) {
   obj->count = 0;
   obj->capacity = 0;
   obj->properties = NULL;
+  obj->shape = xt_shape_empty();
   obj->prototype = proto;
   obj->frozen = 0;
   obj->is_array_base = 0;
@@ -229,6 +233,7 @@ static xt_property *xt_object_insert_property(xt_object *obj, xt_value key) {
       }
     }
   }
+  uint32_t oldCount = obj->count;
   xt_object_reserve(obj, obj->count + 1);
   for (uint32_t i = obj->count; i > position; i--) obj->properties[i] = obj->properties[i - 1];
   xt_property *prop = &obj->properties[position];
@@ -237,6 +242,10 @@ static xt_property *xt_object_insert_property(xt_object *obj, xt_value key) {
   prop->getter = XT_UNDEFINED;
   prop->setter = XT_UNDEFINED;
   obj->count++;
+  /* Appending follows a transition; inserting an integer key into the middle
+   * reorders the list, so rebuild the canonical shape from the new layout. */
+  if (position == oldCount && obj->shape) obj->shape = xt_shape_transition(obj->shape, key);
+  else xt_object_shape_changed(obj);
   return prop;
 }
 
@@ -382,6 +391,9 @@ xt_value xt_object_get_prototype(xt_value value) {
       case XT_OBJECT_KIND_SYMBOL:
       case XT_OBJECT_KIND_MAP:
       case XT_OBJECT_KIND_SET:
+      case XT_OBJECT_KIND_WEAK_MAP:
+      case XT_OBJECT_KIND_WEAK_SET:
+      case XT_OBJECT_KIND_WEAK_REF:
       case XT_OBJECT_KIND_DATE:
       case XT_OBJECT_KIND_REGEXP:
       case XT_OBJECT_KIND_PROMISE:
@@ -482,6 +494,18 @@ xt_value xt_object_own_property_symbols(xt_value value) {
 
 xt_value xt_object_keys(xt_value value) {
   xt_value result = xt_array_new(0, NULL);
+  /* A typed array's enumerable own keys are its indices; `length` and the
+   * buffer metadata are observable but not enumerable. */
+  int typed = xt_typed_array_kind_of(value);
+  if (typed >= 0) {
+    uint32_t length = (uint32_t)xt_to_number(xt_object_get_cstr(value, "length"));
+    for (uint32_t i = 0; i < length; i++) {
+      char buffer[32];
+      snprintf(buffer, sizeof(buffer), "%u", i);
+      xt_array_push(result, xt_string_from_cstr(buffer));
+    }
+    return result;
+  }
   if (XT_IS_OBJECT(value)) {
     xt_object *obj = (xt_object *)XT_GET_PTR(value);
     for (uint32_t i = 0; i < obj->count; i++) {

package/runtime/xt_containers/shapes.inc

@@ -0,0 +1,71 @@
+/* ------------------------------------------------------------------------- */
+/* Hidden classes                                                            */
+/* ------------------------------------------------------------------------- */
+
+/* Shapes are interned by their (parent, property key) transition. They are
+ * immortal metadata, but their keys are ordinary strings/symbols, so a root
+ * provider keeps those keys alive. Pointer identity is enough to share a
+ * transition between the same interned literal; dynamically built keys simply
+ * get their own shape, which is still a correct layout identity for the IC. */
+#define XT_SHAPE_BUCKETS 256
+/* Interned shapes are immortal metadata. A program that creates property names
+ * dynamically would otherwise leak one shape per name forever, so stop
+ * interning after a bounded number; those objects simply fall back to the
+ * uncached lookup (a NULL shape). */
+#define XT_SHAPE_LIMIT 16384
+static xt_shape *g_shapes[XT_SHAPE_BUCKETS];
+static xt_shape *g_shape_all = NULL;
+static xt_shape *g_shape_root = NULL;
+static uint32_t g_shape_count = 0;
+
+static size_t xt_shape_bucket(xt_shape *parent, xt_value key) {
+  uintptr_t mixed = ((uintptr_t)parent >> 4) ^ ((uintptr_t)XT_GET_PTR(key) >> 4);
+  return (size_t)mixed & (XT_SHAPE_BUCKETS - 1);
+}
+
+static void xt_shape_gc_roots(void) {
+  for (xt_shape *shape = g_shape_all; shape; shape = shape->all_next) xt_gc_mark_value(shape->key);
+}
+
+static xt_shape *xt_shape_empty(void) {
+  if (g_shape_root) return g_shape_root;
+  xt_shape *shape = (xt_shape *)calloc(1, sizeof(xt_shape));
+  if (!shape) abort();
+  shape->key = XT_UNDEFINED;
+  g_shape_root = shape;
+  g_shape_all = shape;
+  xt_gc_register_root_provider(xt_shape_gc_roots);
+  return shape;
+}
+
+xt_shape *xt_shape_transition(xt_shape *parent, xt_value key) {
+  if (!parent) parent = xt_shape_empty();
+  size_t bucket = xt_shape_bucket(parent, key);
+  for (xt_shape *shape = g_shapes[bucket]; shape; shape = shape->next) {
+    if (shape->parent == parent && shape->key == key) return shape;
+  }
+  if (g_shape_count >= XT_SHAPE_LIMIT) return NULL;
+  xt_shape *shape = (xt_shape *)calloc(1, sizeof(xt_shape));
+  if (!shape) abort();
+  shape->key = key;
+  shape->count = parent->count + 1;
+  shape->parent = parent;
+  shape->next = g_shapes[bucket];
+  g_shapes[bucket] = shape;
+  shape->all_next = g_shape_all;
+  g_shape_all = shape;
+  g_shape_count++;
+  return shape;
+}
+
+void xt_object_shape_changed(xt_object *obj) {
+  xt_shape *shape = xt_shape_empty();
+  for (uint32_t i = 0; i < obj->count; i++) {
+    shape = xt_shape_transition(shape, obj->properties[i].key);
+    if (!shape) {
+      obj->shape = NULL;
+      return;
+    }
+  }
+  obj->shape = shape;
+}

package/runtime/xt_containers.c

@@ -16,6 +16,7 @@
 #include <stdlib.h>
 #include <string.h>
 
+#include "xt_containers/shapes.inc"
 #include "xt_containers/objects.inc"
 #include "xt_containers/arrays.inc"
 #include "xt_containers/access.inc"

package/runtime/xt_coroutine.c

@@ -48,6 +48,11 @@ struct xt_coroutine {
   int booted;
   int started;
   void *saved_try_top;
+  /* Coroutine that was current when this one was entered. Used to answer
+   * "which JavaScript execution context is running?" so a nested async
+   * function inside an async generator (or vice versa) does not mistake the
+   * outer coroutine for its own. */
+  xt_coroutine *previous;
 #ifdef _WIN32
   void *fiber;
   void *caller_fiber;
@@ -65,6 +70,14 @@ struct xt_coroutine {
 /* Filled in just before a coroutine is first entered (POSIX has no portable
  * way to pass a pointer to `makecontext`). */
 static xt_coroutine *g_boot_coroutine = NULL;
+/* The coroutine whose body is executing right now (NULL on the main stack). */
+static xt_coroutine *g_current_coroutine = NULL;
+
+xt_coroutine *xt_coroutine_current(void) { return g_current_coroutine; }
+
+int xt_coroutine_is_current(xt_coroutine *co) {
+  return co != NULL && g_current_coroutine == co;
+}
 #ifdef _WIN32
 static void *g_main_fiber = NULL;
 #else
@@ -150,6 +163,8 @@ void xt_coroutine_enter(xt_coroutine *co) {
   }
   void *caller_try = xt_try_mark();
   xt_try_restore(co->saved_try_top);
+  co->previous = g_current_coroutine;
+  g_current_coroutine = co;
 #ifdef _WIN32
   _setjmp(co->caller_regs);
   co->has_caller_regs = 1;
@@ -158,6 +173,7 @@ void xt_coroutine_enter(xt_coroutine *co) {
 #else
   swapcontext(&co->caller, &co->ctx);
 #endif
+  g_current_coroutine = co->previous;
   co->saved_try_top = xt_try_mark();
   xt_try_restore(caller_try);
   if (co->stack_pushed) {
@@ -168,6 +184,7 @@ void xt_coroutine_enter(xt_coroutine *co) {
 
 void xt_coroutine_leave(xt_coroutine *co) {
   co->saved_try_top = xt_try_mark();
+  g_current_coroutine = co->previous;
 #ifdef _WIN32
   SwitchToFiber(co->caller_fiber);
 #else