xbintsc 0.3.87 → 0.5.6

package/runtime/xt_typed_array/construction.inc

@@ -43,6 +43,10 @@ static xt_value xt_ta_proto(int kind) {
   xt_ta_define(proto, "keys", (void *)xt_ta_method_keys);
   xt_ta_define(proto, "values", (void *)xt_ta_method_values);
   xt_ta_define(proto, "entries", (void *)xt_ta_method_entries);
+  xt_value constructor = xt_builtin_constructor(xt_string_from_cstr(xt_ta_names[kind]));
+  if (constructor != XT_UNDEFINED) {
+    xt_object_set(proto, xt_string_from_cstr("constructor"), constructor);
+  }
   return proto;
 }
 
@@ -64,7 +68,7 @@ static int xt_ta_length_of(xt_value value, uint32_t *out) {
     return 1;
   }
   if (XT_IS_STRING(value)) {
-    *out = xt_as_string(value)->length;
+    *out = xt_string_code_point_count(xt_as_string(value));
     return 1;
   }
   if (xt_typed_array_kind_of(value) >= 0) {
@@ -86,8 +90,10 @@ static xt_value xt_ta_from_value(int kind, xt_value value, xt_value mapFn, xt_va
   uint32_t length = 0;
   if (!xt_ta_length_of(value, &length)) length = 0;
   xt_value array = xt_ta_new(kind, length);
+  xt_string *sourceString = XT_IS_STRING(value) ? xt_as_string(value) : NULL;
   for (uint32_t i = 0; i < length; i++) {
-    xt_value item = xt_get(value, xt_number((double)i));
+    xt_value item = sourceString ? xt_string_code_point_value(sourceString, (int32_t)i)
+                                 : xt_get(value, xt_number((double)i));
     if (haveMap) {
       xt_value args[3] = {item, xt_number((double)i), array};
       item = xt_call_with_this(mapFn, thisArg, 3, args);
@@ -140,3 +146,38 @@ XT_TA_CTOR(i32, XT_TA_I32)
 XT_TA_CTOR(f32, XT_TA_F32)
 XT_TA_CTOR(f64, XT_TA_F64)
 
+/* Dispatch by constructor name, used when a typed-array constructor is a
+ * first-class value (`const T = Uint8Array; new T(4)`). */
+static int xt_ta_kind_from_name(const char *name) {
+  if (!name) return -1;
+  if (strcmp(name, "Uint8Array") == 0) return XT_TA_U8;
+  if (strcmp(name, "Int8Array") == 0) return XT_TA_I8;
+  if (strcmp(name, "Uint8ClampedArray") == 0) return XT_TA_U8C;
+  if (strcmp(name, "Uint16Array") == 0) return XT_TA_U16;
+  if (strcmp(name, "Int16Array") == 0) return XT_TA_I16;
+  if (strcmp(name, "Uint32Array") == 0) return XT_TA_U32;
+  if (strcmp(name, "Int32Array") == 0) return XT_TA_I32;
+  if (strcmp(name, "Float32Array") == 0) return XT_TA_F32;
+  if (strcmp(name, "Float64Array") == 0) return XT_TA_F64;
+  return -1;
+}
+
+xt_value xt_typed_array_ctor_by_name(xt_value nameValue, int32_t argc, xt_value *argv) {
+  int kind = xt_ta_kind_from_name(XT_IS_STRING(nameValue) ? xt_string_data(nameValue) : NULL);
+  if (kind < 0) return XT_UNDEFINED;
+  return xt_ta_ctor_impl(kind, argc, argv);
+}
+
+xt_value xt_typed_array_static_by_name(xt_value nameValue, xt_value method, int32_t argc,
+                                       xt_value *argv) {
+  int kind = xt_ta_kind_from_name(XT_IS_STRING(nameValue) ? xt_string_data(nameValue) : NULL);
+  if (kind < 0) return XT_UNDEFINED;
+  return xt_ta_static_impl(kind, method, argc, argv);
+}
+
+xt_value xt_typed_array_prototype(xt_value nameValue) {
+  int kind = xt_ta_kind_from_name(XT_IS_STRING(nameValue) ? xt_string_data(nameValue) : NULL);
+  if (kind < 0) return XT_UNDEFINED;
+  return xt_ta_proto(kind);
+}
+

package/runtime/xt_typed_array.c

@@ -34,6 +34,10 @@ enum {
 };
 
 static const int xt_ta_bytes[XT_TA_KIND_COUNT] = {1, 1, 1, 2, 2, 4, 4, 4, 8};
+static const char *const xt_ta_names[XT_TA_KIND_COUNT] = {
+    "Uint8Array", "Int8Array", "Uint8ClampedArray", "Uint16Array", "Int16Array",
+    "Uint32Array", "Int32Array", "Float32Array", "Float64Array",
+};
 
 static xt_value xt_ta_protos[XT_TA_KIND_COUNT];
 

package/runtime/xt_values/constructors.inc

@@ -10,6 +10,8 @@ xt_value xt_number(double d) { return xt_from_double(d); }
 xt_string *xt_string_alloc(size_t length) {
   xt_string *s = (xt_string *)xt_alloc(sizeof(xt_string), XT_OBJECT_KIND_STRING);
   s->length = (uint32_t)length;
+  s->utf16_length = 0;
+  s->code_point_count = 0;
   /* Keep the terminator in the allocation: many consumers hand `flat` to libc. */
   s->capacity = (uint32_t)length + 1;
   s->flat = (char *)malloc(s->capacity);
@@ -26,6 +28,7 @@ xt_string *xt_string_alloc(size_t length) {
 xt_value xt_string_new(const char *data, size_t len) {
   xt_string *s = xt_string_alloc(len);
   if (len > 0) memcpy(s->flat, data, len);
+  xt_string_finish(s);
   return XT_FROM_PTR(XT_TAG_STRING, s);
 }
 
@@ -44,3 +47,8 @@ int32_t xt_string_length_value(xt_value value) {
   xt_string *s = xt_as_string(value);
   return s ? (int32_t)s->length : -1;
 }
+
+int32_t xt_string_utf16_length_value(xt_value value) {
+  xt_string *s = xt_as_string(value);
+  return s ? (int32_t)xt_string_utf16_length(s) : -1;
+}

package/runtime/xt_values/strings.inc

@@ -62,9 +62,13 @@ const char *xt_string_bytes(xt_string *s) {
 
   out[offset] = '\0';
   s->flat = out;
+  s->length = (uint32_t)offset;
   s->capacity = (uint32_t)(total + 1);
   s->left = NULL;
   s->right = NULL;
+  /* A concat boundary can split a surrogate pair; flattening is where the two
+   * halves meet, so normalise and record the UTF-16/code-point view now. */
+  xt_string_finish(s);
   return s->flat;
 }
 
@@ -74,12 +78,22 @@ static xt_value xt_string_concat(xt_string *a, xt_string *b) {
   size_t total = (size_t)a->length + (size_t)b->length;
   if (total <= XT_STRING_CONS_THRESHOLD) {
     xt_string *out = xt_string_alloc(total);
-    memcpy(out->flat, xt_string_bytes(a), a->length);
-    memcpy(out->flat + a->length, xt_string_bytes(b), b->length);
+    const char *aBytes = xt_string_bytes(a);
+    uint32_t aLength = a->length;
+    const char *bBytes = xt_string_bytes(b);
+    uint32_t bLength = b->length;
+    memcpy(out->flat, aBytes, aLength);
+    memcpy(out->flat + aLength, bBytes, bLength);
+    xt_string_finish(out);
     return XT_FROM_PTR(XT_TAG_STRING, out);
   }
   xt_string *out = (xt_string *)xt_alloc(sizeof(xt_string), XT_OBJECT_KIND_STRING);
   out->length = (uint32_t)total;
+  /* UTF-16 length is additive even when the boundary joins a surrogate pair;
+   * the code-point count is not, so leave it to be recomputed after
+   * flattening. */
+  out->utf16_length = xt_string_utf16_length(a) + xt_string_utf16_length(b);
+  out->code_point_count = 0;
   out->capacity = 0;
   out->flat = NULL;
   out->left = a;
@@ -91,6 +105,8 @@ int xt_string_equals(xt_string *a, xt_string *b) {
   /* Interned literals (property names above all) are shared, so identity is the
    * common case and skips the length, flattening and byte comparison entirely. */
   if (a == b) return 1;
+  const char *aBytes = xt_string_bytes(a);
+  const char *bBytes = xt_string_bytes(b);
   if (a->length != b->length) return 0;
-  return memcmp(xt_string_bytes(a), xt_string_bytes(b), a->length) == 0;
+  return memcmp(aBytes, bBytes, a->length) == 0;
 }

package/runtime/xt_values/utf16.inc

@@ -0,0 +1,340 @@
+/* ------------------------------------------------------------------------- */
+/* UTF-8 storage, UTF-16 view                                                */
+/* ------------------------------------------------------------------------- */
+/*
+ * Strings are stored as UTF-8, but JavaScript observes them as sequences of
+ * UTF-16 code units. The helpers here bridge the two views:
+ *
+ *   - a decoded code point above 0xFFFF occupies two UTF-16 units;
+ *   - a surrogate half that is not part of a pair (produced by indexing or
+ *     slicing through a pair) is stored as its own three-byte WTF-8 sequence;
+ *   - `xt_utf8_normalize_surrogates` recombines adjacent WTF-8 halves so that
+ *     concatenation and flattening keep the canonical four-byte form.
+ *
+ * Invalid UTF-8 bytes decode as U+FFFD with width 1, so a C extension that
+ * hands over arbitrary bytes can never make the walkers run off the end.
+ */
+
+uint32_t xt_utf8_decode(const char *data, size_t length, size_t *width) {
+  const unsigned char *bytes = (const unsigned char *)data;
+  if (length == 0) {
+    if (width) *width = 0;
+    return 0xFFFD;
+  }
+  unsigned char first = bytes[0];
+  if (first < 0x80) {
+    if (width) *width = 1;
+    return first;
+  }
+  if ((first & 0xE0) == 0xC0 && length >= 2 && (bytes[1] & 0xC0) == 0x80) {
+    if (width) *width = 2;
+    return ((uint32_t)(first & 0x1F) << 6) | (uint32_t)(bytes[1] & 0x3F);
+  }
+  if ((first & 0xF0) == 0xE0 && length >= 3 && (bytes[1] & 0xC0) == 0x80 &&
+      (bytes[2] & 0xC0) == 0x80) {
+    if (width) *width = 3;
+    return ((uint32_t)(first & 0x0F) << 12) | ((uint32_t)(bytes[1] & 0x3F) << 6) |
+           (uint32_t)(bytes[2] & 0x3F);
+  }
+  if ((first & 0xF8) == 0xF0 && length >= 4 && (bytes[1] & 0xC0) == 0x80 &&
+      (bytes[2] & 0xC0) == 0x80 && (bytes[3] & 0xC0) == 0x80) {
+    uint32_t code = ((uint32_t)(first & 0x07) << 18) | ((uint32_t)(bytes[1] & 0x3F) << 12) |
+                    ((uint32_t)(bytes[2] & 0x3F) << 6) | (uint32_t)(bytes[3] & 0x3F);
+    if (code >= 0x10000 && code <= 0x10FFFF) {
+      if (width) *width = 4;
+      return code;
+    }
+  }
+  /* Invalid or overlong sequence: consume one byte, report the replacement. */
+  if (width) *width = 1;
+  return 0xFFFD;
+}
+
+size_t xt_utf8_encode(uint32_t code, char *out) {
+  if (code < 0x80) {
+    out[0] = (char)code;
+    return 1;
+  }
+  if (code < 0x800) {
+    out[0] = (char)(0xC0 | (code >> 6));
+    out[1] = (char)(0x80 | (code & 0x3F));
+    return 2;
+  }
+  if (code < 0x10000) {
+    out[0] = (char)(0xE0 | (code >> 12));
+    out[1] = (char)(0x80 | ((code >> 6) & 0x3F));
+    out[2] = (char)(0x80 | (code & 0x3F));
+    return 3;
+  }
+  out[0] = (char)(0xF0 | ((code >> 18) & 0x07));
+  out[1] = (char)(0x80 | ((code >> 12) & 0x3F));
+  out[2] = (char)(0x80 | ((code >> 6) & 0x3F));
+  out[3] = (char)(0x80 | (code & 0x3F));
+  return 4;
+}
+
+void xt_utf8_measure(const char *data, size_t length, uint32_t *units, uint32_t *points) {
+  size_t offset = 0;
+  uint32_t unitCount = 0;
+  uint32_t pointCount = 0;
+  while (offset < length) {
+    size_t width = 0;
+    uint32_t code = xt_utf8_decode(data + offset, length - offset, &width);
+    if (width == 0) break;
+    unitCount += code >= 0x10000 ? 2 : 1;
+    pointCount++;
+    offset += width;
+  }
+  if (units) *units = unitCount;
+  if (points) *points = pointCount;
+}
+
+uint32_t xt_utf8_utf16_length(const char *data, size_t length) {
+  uint32_t units = 0;
+  xt_utf8_measure(data, length, &units, NULL);
+  return units;
+}
+
+/* Both halves of a surrogate pair are encoded as three-byte WTF-8 sequences:
+ * `ED A0..AF xx` for D800-DBFF and `ED B0..BF xx` for DC00-DFFF. */
+static int xt_wtf8_surrogate(const unsigned char *bytes, size_t length, uint32_t *code, int *high) {
+  if (length < 3 || bytes[0] != 0xED || bytes[1] < 0xA0 || bytes[1] > 0xBF ||
+      bytes[2] < 0x80 || bytes[2] > 0xBF)
+    return 0;
+  *code = ((uint32_t)(bytes[0] & 0x0F) << 12) | ((uint32_t)(bytes[1] & 0x3F) << 6) |
+          (uint32_t)(bytes[2] & 0x3F);
+  *high = bytes[1] <= 0xAF;
+  return 1;
+}
+
+size_t xt_utf8_normalize_surrogates(char *data, size_t length) {
+  const unsigned char *source = (const unsigned char *)data;
+  unsigned char *write = (unsigned char *)data;
+  size_t offset = 0;
+  while (offset < length) {
+    uint32_t highCode = 0;
+    int high = 0;
+    if (xt_wtf8_surrogate(source + offset, length - offset, &highCode, &high) && high) {
+      uint32_t lowCode = 0;
+      int low = 0;
+      if (offset + 3 < length &&
+          xt_wtf8_surrogate(source + offset + 3, length - offset - 3, &lowCode, &low) && !low) {
+        uint32_t code = 0x10000 + ((highCode - 0xD800) << 10) + (lowCode - 0xDC00);
+        write += xt_utf8_encode(code, (char *)write);
+        offset += 6;
+        continue;
+      }
+    }
+    *write++ = source[offset++];
+  }
+  return (size_t)(write - (unsigned char *)data);
+}
+
+void xt_string_finish(xt_string *s) {
+  if (!s || !s->flat) return;
+  size_t length = xt_utf8_normalize_surrogates(s->flat, s->length);
+  s->length = (uint32_t)length;
+  s->flat[length] = '\0';
+  xt_utf8_measure(s->flat, length, &s->utf16_length, &s->code_point_count);
+}
+
+uint32_t xt_string_utf16_length(xt_string *s) {
+  if (!s || s->length == 0) return 0;
+  if (s->utf16_length) return s->utf16_length;
+  if (!s->flat) xt_string_bytes(s);
+  else xt_utf8_measure(s->flat, s->length, &s->utf16_length, &s->code_point_count);
+  return s->utf16_length;
+}
+
+uint32_t xt_string_code_point_count(xt_string *s) {
+  if (!s || s->length == 0) return 0;
+  if (s->code_point_count) return s->code_point_count;
+  if (!s->flat) xt_string_bytes(s);
+  else xt_utf8_measure(s->flat, s->length, &s->utf16_length, &s->code_point_count);
+  return s->code_point_count;
+}
+
+/* A string whose byte and UTF-16 lengths agree contains only ASCII, so the two
+ * index spaces coincide and every walker below can skip decoding. */
+static int xt_string_is_ascii(xt_string *s) {
+  return s->length == xt_string_utf16_length(s);
+}
+
+int32_t xt_string_code_unit(xt_string *s, int32_t index) {
+  if (!s || index < 0 || (uint32_t)index >= s->length) return -1;
+  if (xt_string_is_ascii(s)) return (int32_t)(unsigned char)xt_string_bytes(s)[index];
+  const char *bytes = xt_string_bytes(s);
+  size_t offset = 0;
+  int32_t unit = 0;
+  while (offset < s->length) {
+    size_t width = 0;
+    uint32_t code = xt_utf8_decode(bytes + offset, s->length - offset, &width);
+    if (code >= 0x10000) {
+      uint32_t value = code - 0x10000;
+      if (unit == index) return (int32_t)(0xD800 + (value >> 10));
+      if (unit + 1 == index) return (int32_t)(0xDC00 + (value & 0x3FF));
+      unit += 2;
+    } else {
+      if (unit == index) return (int32_t)code;
+      unit += 1;
+    }
+    offset += width;
+  }
+  return -1;
+}
+
+int32_t xt_string_code_point_at(xt_string *s, int32_t index) {
+  if (!s || index < 0) return -1;
+  if (xt_string_is_ascii(s)) return index < (int32_t)s->length ? (int32_t)(unsigned char)xt_string_bytes(s)[index] : -1;
+  const char *bytes = xt_string_bytes(s);
+  size_t offset = 0;
+  int32_t unit = 0;
+  while (offset < s->length) {
+    size_t width = 0;
+    uint32_t code = xt_utf8_decode(bytes + offset, s->length - offset, &width);
+    int widthUnits = code >= 0x10000 ? 2 : 1;
+    if (unit == index) return (int32_t)code;
+    if (widthUnits == 2 && unit + 1 == index)
+      return (int32_t)(0xDC00 + ((code - 0x10000) & 0x3FF));
+    unit += widthUnits;
+    offset += width;
+  }
+  return -1;
+}
+
+xt_value xt_string_from_code_point(uint32_t code) {
+  char buffer[4];
+  size_t length = xt_utf8_encode(code, buffer);
+  return xt_string_new(buffer, length);
+}
+
+xt_value xt_string_from_units(const uint16_t *units, size_t count) {
+  size_t capacity = count * 4 + 1;
+  char *out = (char *)malloc(capacity);
+  if (!out) abort();
+  size_t length = 0;
+  for (size_t i = 0; i < count; i++) {
+    uint32_t code = units[i];
+    if (code >= 0xD800 && code <= 0xDBFF && i + 1 < count && units[i + 1] >= 0xDC00 &&
+        units[i + 1] <= 0xDFFF) {
+      code = 0x10000 + ((code - 0xD800) << 10) + ((uint32_t)units[i + 1] - 0xDC00);
+      i++;
+    }
+    length += xt_utf8_encode(code, out + length);
+  }
+  xt_value result = xt_string_new(out, length);
+  free(out);
+  return result;
+}
+
+xt_value xt_string_unit_value(xt_string *s, int32_t index) {
+  int32_t unit = xt_string_code_unit(s, index);
+  if (unit < 0) return xt_string_from_cstr("");
+  return xt_string_from_code_point((uint32_t)unit);
+}
+
+xt_value xt_string_code_point_value(xt_string *s, int32_t index) {
+  if (!s || index < 0) return XT_UNDEFINED;
+  if (xt_string_is_ascii(s))
+    return index < (int32_t)s->length
+               ? xt_string_from_code_point((uint32_t)(unsigned char)xt_string_bytes(s)[index])
+               : XT_UNDEFINED;
+  const char *bytes = xt_string_bytes(s);
+  size_t offset = 0;
+  int32_t point = 0;
+  while (offset < s->length) {
+    size_t width = 0;
+    uint32_t code = xt_utf8_decode(bytes + offset, s->length - offset, &width);
+    if (point == index) return xt_string_from_code_point(code);
+    point++;
+    offset += width;
+  }
+  return XT_UNDEFINED;
+}
+
+xt_value xt_string_slice_units(xt_string *s, int32_t start, int32_t end) {
+  if (!s) return xt_string_from_cstr("");
+  int32_t units = (int32_t)xt_string_utf16_length(s);
+  if (start < 0) start = 0;
+  if (start > units) start = units;
+  if (end < 0) end = 0;
+  if (end > units) end = units;
+  if (start >= end) return xt_string_from_cstr("");
+  if (xt_string_is_ascii(s)) {
+    const char *ascii = xt_string_bytes(s);
+    return xt_string_new(ascii + start, (size_t)(end - start));
+  }
+
+  const char *bytes = xt_string_bytes(s);
+  /* Splitting a surrogate pair expands four bytes into two three-byte WTF-8
+   * halves, so leave two bytes of headroom. */
+  char *out = (char *)malloc((size_t)s->length + 8);
+  if (!out) abort();
+  size_t length = 0;
+  size_t offset = 0;
+  int32_t unit = 0;
+  while (offset < s->length) {
+    size_t width = 0;
+    uint32_t code = xt_utf8_decode(bytes + offset, s->length - offset, &width);
+    if (code >= 0x10000) {
+      uint32_t value = code - 0x10000;
+      if (start <= unit && end >= unit + 2) {
+        length += xt_utf8_encode(code, out + length);
+      } else if (start <= unit && end == unit + 1) {
+        length += xt_utf8_encode(0xD800 + (value >> 10), out + length);
+      } else if (start == unit + 1 && end >= unit + 2) {
+        length += xt_utf8_encode(0xDC00 + (value & 0x3FF), out + length);
+      }
+      unit += 2;
+    } else {
+      if (unit >= start && unit < end) length += xt_utf8_encode(code, out + length);
+      unit += 1;
+    }
+    offset += width;
+  }
+  xt_value result = xt_string_new(out, length);
+  free(out);
+  return result;
+}
+
+int32_t xt_string_byte_offset(xt_string *s, int32_t unit_index) {
+  if (!s || unit_index <= 0) return 0;
+  if (xt_string_is_ascii(s)) return unit_index < (int32_t)s->length ? unit_index : (int32_t)s->length;
+  const char *bytes = xt_string_bytes(s);
+  size_t offset = 0;
+  int32_t unit = 0;
+  while (offset < s->length) {
+    if (unit >= unit_index) return (int32_t)offset;
+    size_t width = 0;
+    uint32_t code = xt_utf8_decode(bytes + offset, s->length - offset, &width);
+    int widthUnits = code >= 0x10000 ? 2 : 1;
+    if (widthUnits == 2 && unit + 1 == unit_index) return (int32_t)offset;
+    unit += widthUnits;
+    offset += width;
+  }
+  return (int32_t)s->length;
+}
+
+int32_t xt_string_unit_offset(xt_string *s, int32_t byte_offset) {
+  if (!s || byte_offset <= 0) return 0;
+  if ((uint32_t)byte_offset >= s->length) return (int32_t)xt_string_utf16_length(s);
+  if (xt_string_is_ascii(s)) return byte_offset;
+  const char *bytes = xt_string_bytes(s);
+  size_t offset = 0;
+  int32_t unit = 0;
+  while (offset < (size_t)byte_offset && offset < s->length) {
+    size_t width = 0;
+    uint32_t code = xt_utf8_decode(bytes + offset, s->length - offset, &width);
+    unit += code >= 0x10000 ? 2 : 1;
+    offset += width;
+  }
+  return unit;
+}
+
+int xt_string_is_boundary(xt_string *s, int32_t unit_index) {
+  int32_t units = (int32_t)xt_string_utf16_length(s);
+  if (unit_index <= 0 || unit_index >= units) return 1;
+  if (xt_string_is_ascii(s)) return 1;
+  int32_t byte = xt_string_byte_offset(s, unit_index);
+  return xt_string_unit_offset(s, byte) == unit_index;
+}

package/runtime/xt_values.c

@@ -19,6 +19,7 @@
 
 #include "xt_values/constructors.inc"
 #include "xt_values/strings.inc"
+#include "xt_values/utf16.inc"
 #include "xt_values/number-format.inc"
 #include "xt_values/conversions.inc"
 #include "xt_values/arithmetic.inc"

package/src/codegen/generator/calls/access.ts

@@ -13,7 +13,7 @@ import {
   type PropertyAccessExpression,
 } from "../../../ast/nodes.js";
 import { i64, numberLiteral, XT_TRUE, XT_UNDEFINED } from "../../values.js";
-import { MATH_CONSTANTS, NAMESPACE_PROPERTIES, NUMBER_CONSTANTS, TYPED_ARRAYS } from "../tables.js";
+import { MATH_CONSTANTS, NAMESPACE_PROPERTIES, NUMBER_CONSTANTS, SYMBOL_WELL_KNOWN, TYPED_ARRAYS } from "../tables.js";
 import type { Generator } from "../generator.js";
 
 export interface AccessCallMethods {
@@ -85,7 +85,12 @@ export const accessCallMethods: AccessCallMethods = {
       !this.binding.symbolOfIdentifier.get(node.expression as Identifier)
     ) {
       const getter = NAMESPACE_PROPERTIES[(node.expression as Identifier).text];
-      if (getter) {
+      /* `Symbol.iterator` & friends are well-known symbol values, but
+       * `Symbol.prototype` / `.name` / `.length` are ordinary properties of
+       * the first-class constructor value. */
+      const symbolGetter =
+        (node.expression as Identifier).text === "Symbol" && SYMBOL_WELL_KNOWN.has(node.name.text);
+      if (getter && (getter !== "xt_symbol_get" || symbolGetter)) {
         const key = this.stringValue(node.name.text);
         const result = this.reg();
         this.emit(`  ${result} = call i64 @${getter}(i64 ${key})`);

package/src/codegen/generator/calls/closures.ts

@@ -80,5 +80,8 @@ export const closureCallMethods: ClosureCallMethods = {
     const nameValue = this.stringValue(name);
     this.emit(`  call i64 @xt_function_set_metadata(i64 ${closure}, i64 ${nameValue}, i32 ${arity})`);
     if (fn.isGenerator) this.emit(`  call i64 @xt_function_set_generator(i64 ${closure})`);
+    /* `async` functions run on a coroutine: the runtime must know at call time
+     * so it can return a promise and suspend at `await`. */
+    if (fn.isAsync) this.emit(`  call i64 @xt_function_set_async(i64 ${closure})`);
   },
 };

package/src/codegen/generator/calls/invocation.ts

@@ -109,9 +109,10 @@ export const invocationCallMethods: InvocationCallMethods = {
       if (symbol && symbol.kind === SymbolKind.Function) {
         const declaration = symbol.declarations[0];
         const fn = declaration ? this.binding.functionOfNode.get(declaration) : undefined;
-        /* Generator functions are not called directly: the call must create a
-         * suspended generator, so fall through to the closure-call path. */
-        if (fn && !fn.isGenerator) {
+        /* Generator and `async` functions are not called directly: the call
+         * must create a suspended generator / start a coroutine, so fall
+         * through to the closure-call path. */
+        if (fn && !fn.isGenerator && !fn.isAsync) {
           const args = this.emitArguments(node.arguments);
           const result = this.reg();
           this.emit(

package/src/codegen/generator/expressions/primary.ts

@@ -28,7 +28,7 @@ import {
 import { SymbolKind, type SymbolInfo } from "../../../binder/binder.js";
 import { DiagnosticCode } from "../../../diagnostics/diagnostic.js";
 import { i64, numberLiteral, XT_FALSE, XT_NULL, XT_TRUE, XT_UNDEFINED } from "../../values.js";
-import { BUILTIN_FUNCTION_VALUES, CTOR_FUNCTIONS, ERROR_CONSTRUCTORS } from "../tables.js";
+import { BUILTIN_FUNCTION_VALUES, CTOR_FUNCTIONS, ERROR_CONSTRUCTORS, FIRST_CLASS_CONSTRUCTORS } from "../tables.js";
 import type { Generator } from "../generator.js";
 
 export interface PrimaryExpressionMethods {
@@ -218,6 +218,11 @@ export const primaryExpressionMethods: PrimaryExpressionMethods = {
         return rest;
       }
       default: {
+        if (FIRST_CLASS_CONSTRUCTORS.has(identifier.text)) {
+          // `const A = Array`, `arr.filter(Boolean)`, `new (Map)()`: the
+          // constructor is an ordinary function value backed by the runtime.
+          return this.runtimeCall("xt_builtin_constructor", [this.stringValue(identifier.text)]);
+        }
         const builtinValue = BUILTIN_FUNCTION_VALUES[identifier.text];
         if (builtinValue) {
           // A global like `Boolean` used as a value (`arr.filter(Boolean)`):

package/src/codegen/generator/module.ts

@@ -41,7 +41,6 @@ export interface ModuleMethods {
   emitFunctionReturn(this: Generator, value: string): void;
   emitMain(this: Generator): void;
   functionName(this: Generator, fn: FunctionInfo): string;
-  wrapAsync(this: Generator, value: string): string;
   classGlobal(this: Generator, classInfo: ClassInfo): string;
   emitClassReference(this: Generator, classInfo: ClassInfo): string;
   emitClassSetup(this: Generator, classInfo: ClassInfo): void;
@@ -124,7 +123,11 @@ export const moduleMethods: ModuleMethods = {
       finallyStack: [],
       escapePointers: [],
       usesTry: false,
-      trackFrames: !fn.isGenerator,
+      /* Generator and async bodies run on a private coroutine stack that can be
+       * suspended in the middle of a call. Their shadow frame would then sit on
+       * the shadow stack while the caller unwinds its own, so leave them out of
+       * `Error.stack` frames (nesting calls inside them are still recorded). */
+      trackFrames: !fn.isGenerator && !fn.isAsync,
       ...(debugSubprogram ? { debugSubprogram } : {}),
     };
     this.current = state;
@@ -254,15 +257,17 @@ export const moduleMethods: ModuleMethods = {
       this.emitStatements(this.sourceFile.statements);
     } else if (fn.node.kind === SyntaxKind.ArrowFunction && (fn.node as ArrowFunction).body.kind !== SyntaxKind.Block) {
       const value = this.emitExpression((fn.node as ArrowFunction).body as Expression);
-      this.emitFunctionReturn(fn.isAsync ? this.wrapAsync(value) : value);
+      this.emitFunctionReturn(value);
     } else {
       const body = (fn.node as { body: Block }).body;
       if (body) this.emitStatements(body.statements);
     }
 
     if (!this.current.terminated) {
-      const fallback = fn.isAsync ? this.wrapAsync(i64(XT_UNDEFINED)) : i64(XT_UNDEFINED);
-      this.emitFunctionReturn(fallback);
+      /* An `async` body returns its value plainly: the runtime's async
+       * coroutine settles the returned promise (and adopts a returned
+       * promise), so wrapping here would add a redundant promise. */
+      this.emitFunctionReturn(i64(XT_UNDEFINED));
     }
 
     const escapes = state.usesTry
@@ -327,13 +332,6 @@ export const moduleMethods: ModuleMethods = {
     this.terminate(`ret i64 ${value}`);
   },
 
-  /** Wrap a returned value in a resolved promise (for `async` functions). */
-  wrapAsync(value: string): string {
-    const result = this.reg();
-    this.emit(`  ${result} = call i64 @xt_promise_resolve(i64 ${value})`);
-    return result;
-  },
-
   classGlobal(classInfo: ClassInfo): string {
     const existing = this.classGlobals.get(classInfo.id);
     if (existing) return existing;

package/src/codegen/generator/state.ts

@@ -104,6 +104,7 @@ export const RUNTIME_DECLARATIONS: readonly string[] = [
   "declare i64 @xt_closure_new(i8*, i32, i64*)",
   "declare i64 @xt_function_set_metadata(i64, i64, i32)",
   "declare i64 @xt_function_set_generator(i64)",
+  "declare i64 @xt_function_set_async(i64)",
   "declare i64 @xt_closure_call(i64, i32, i64*)",
   "declare i64 @xt_closure_env(i64, i32)",
   "declare i64 @xt_call_with_this(i64, i64, i32, i64*)",
@@ -111,6 +112,9 @@ export const RUNTIME_DECLARATIONS: readonly string[] = [
   "declare i64 @xt_new(i64, i32, i64*)",
   "declare i64 @xt_instance_of(i64, i64)",
   "declare i64 @xt_instance_of_builtin(i64, i32)",
+  "declare i64 @xt_builtin_constructor(i64)",
+  "declare i64 @xt_array_ctor(i32, i64*)",
+  "declare i64 @xt_object_ctor(i32, i64*)",
   "declare i64 @xt_function_set_prototype(i64, i64)",
   "declare i64 @xt_function_get_prototype(i64)",
   "declare i64 @xt_object_new_with_proto(i64)",

package/src/codegen/generator/statements/control-flow.ts

@@ -250,8 +250,7 @@ export const controlFlowStatementMethods: ControlFlowStatementMethods = {
   },
 
   emitReturn(statement: ReturnStatement): void {
-    let value = statement.expression ? this.emitExpression(statement.expression) : i64(XT_UNDEFINED);
-    if (this.current.fn.isAsync) value = this.wrapAsync(value);
+    const value = statement.expression ? this.emitExpression(statement.expression) : i64(XT_UNDEFINED);
     this.runFinallysBeforeExit(0);
     if (this.current.terminated) return;
     this.popTryFramesTo(0);