xbintsc 0.2.5 → 0.2.7

package/runtime/xt_stdlib2.c

@@ -294,6 +294,7 @@ static xt_value xt_string_at(xt_value value, xt_value indexValue) {
 }
 
 static xt_value xt_string_replace_all(xt_value value, xt_value searchValue, xt_value replacementValue) {
+  if (xt_is_regexp(searchValue)) return xt_regexp_replace(value, searchValue, replacementValue);
   xt_string *s = xt_as_string(value);
   if (!s) return value;
   xt_string *search = xt_as_string(xt_to_string(searchValue));
@@ -856,6 +857,35 @@ int32_t xt_set_size(xt_value value) {
   return (int32_t)((xt_set_object *)XT_GET_PTR(value))->count;
 }
 
+/* -- for...of iteration --------------------------------------------------- */
+
+/* `for...of` lowers to a length check plus an index lookup. Arrays and strings
+   index directly; Maps yield `[key, value]` pairs and Sets yield their values. */
+xt_value xt_iter_length(xt_value value) {
+  if (xt_is_map(value)) return xt_number((double)xt_map_size(value));
+  if (xt_is_set(value)) return xt_number((double)xt_set_size(value));
+  return xt_array_length(value);
+}
+
+xt_value xt_iter_value(xt_value value, xt_value index) {
+  if (xt_is_map(value)) {
+    xt_map *map = (xt_map *)XT_GET_PTR(value);
+    int64_t i = (int64_t)xt_to_int32(index);
+    if (i < 0 || i >= (int64_t)map->count) return XT_UNDEFINED;
+    xt_value pair = xt_array_new(0, NULL);
+    xt_array_push(pair, map->keys[i]);
+    xt_array_push(pair, map->values[i]);
+    return pair;
+  }
+  if (xt_is_set(value)) {
+    xt_set_object *set = (xt_set_object *)XT_GET_PTR(value);
+    int64_t i = (int64_t)xt_to_int32(index);
+    if (i < 0 || i >= (int64_t)set->count) return XT_UNDEFINED;
+    return set->values[i];
+  }
+  return xt_get(value, index);
+}
+
 static int32_t xt_set_index(xt_set_object *set, xt_value key) {
   for (uint32_t i = 0; i < set->count; i++) if (xt_value_equals(set->values[i], key)) return (int32_t)i;
   return -1;
@@ -1027,18 +1057,221 @@ xt_value xt_error_ctor(int32_t argc, xt_value *argv) {
   return error;
 }
 
-static xt_value xt_regexp_test(xt_value target, xt_value input) {
-  xt_regexp *regexp = (xt_regexp *)XT_GET_PTR(target);
+/* `super(message)` inside a subclass of the builtin `Error`: initialize the
+ * already-allocated instance instead of creating a fresh object. */
+xt_value xt_error_init(xt_value thisValue, int32_t argc, xt_value *argv) {
+  xt_value name = xt_arg_at(argc, argv, 1);
+  xt_value message = xt_arg_at(argc, argv, 0);
+  xt_object_set(thisValue, xt_string_from_cstr("name"),
+                name == XT_UNDEFINED ? xt_string_from_cstr("Error") : name);
+  xt_object_set(thisValue, xt_string_from_cstr("message"),
+                message == XT_UNDEFINED ? xt_string_from_cstr("") : message);
+  return thisValue;
+}
+
+/* Compile `regexp` and search `input` starting at byte offset `start`.
+ * Returns 1 and fills `matchStart`/`matchEnd` (absolute offsets into `input`)
+ * when a match is found, otherwise 0. */
+
+static int xt_regex_hex_digit(char c) {
+  if (c >= '0' && c <= '9') return c - '0';
+  if (c >= 'a' && c <= 'f') return c - 'a' + 10;
+  if (c >= 'A' && c <= 'F') return c - 'A' + 10;
+  return -1;
+}
+
+/* JavaScript regexes use escapes POSIX ERE does not understand (`\r`, `\n`,
+ * `\d`, `\w`, `\s`, `(?:...)`, ...). Rewrite the common ones into their POSIX
+ * equivalents before handing the pattern to the engine. Returns a malloc'd,
+ * NUL-terminated string the caller must free. */
+static char *xt_regexp_translate_js(const char *pattern) {
+  size_t length = strlen(pattern);
+  size_t capacity = length * 16 + 16;
+  char *out = (char *)malloc(capacity);
+  if (!out) abort();
+  size_t written = 0;
+  for (size_t i = 0; i < length; i++) {
+    char c = pattern[i];
+    const char *replacement = NULL;
+    char literal = 0;
+    int consume = 0;
+    if (c == '\\') {
+      char next = (i + 1 < length) ? pattern[i + 1] : '\0';
+      switch (next) {
+        case 'r': literal = '\r'; consume = 1; break;
+        case 'n': literal = '\n'; consume = 1; break;
+        case 't': literal = '\t'; consume = 1; break;
+        case 'f': literal = '\f'; consume = 1; break;
+        case 'v': literal = '\v'; consume = 1; break;
+        case 'd': replacement = "[0-9]"; consume = 1; break;
+        case 'D': replacement = "[^0-9]"; consume = 1; break;
+        case 'w': replacement = "[A-Za-z0-9_]"; consume = 1; break;
+        case 'W': replacement = "[^A-Za-z0-9_]"; consume = 1; break;
+        case 's': replacement = "[ \t\n\r\f\v]"; consume = 1; break;
+        case 'S': replacement = "[^ \t\n\r\f\v]"; consume = 1; break;
+        case 'x': {
+          int hi = (i + 2 < length) ? xt_regex_hex_digit(pattern[i + 2]) : -1;
+          int lo = (i + 3 < length) ? xt_regex_hex_digit(pattern[i + 3]) : -1;
+          if (hi >= 0 && lo >= 0) { literal = (char)(hi * 16 + lo); consume = 3; }
+          break;
+        }
+        default: break;
+      }
+    } else if (c == '(' && i + 2 < length && pattern[i + 1] == '?' && pattern[i + 2] == ':') {
+      /* POSIX ERE has no non-capturing groups; a capturing group matches the
+       * same text, only the capture bookkeeping differs. */
+      literal = '(';
+      consume = 2;
+    }
+    if (replacement) {
+      size_t addition = strlen(replacement);
+      if (written + addition + 1 > capacity) { capacity = (written + addition) * 2 + 16; out = (char *)realloc(out, capacity); if (!out) abort(); }
+      memcpy(out + written, replacement, addition);
+      written += addition;
+    } else if (consume || literal) {
+      if (written + 2 > capacity) { capacity = capacity * 2 + 16; out = (char *)realloc(out, capacity); if (!out) abort(); }
+      out[written++] = literal;
+    } else {
+      if (written + 2 > capacity) { capacity = capacity * 2 + 16; out = (char *)realloc(out, capacity); if (!out) abort(); }
+      out[written++] = c;
+    }
+    i += (size_t)consume;
+  }
+  out[written] = '\0';
+  return out;
+}
+
+int xt_regexp_find(xt_value regexpValue, xt_value input, int32_t start, int32_t *matchStart, int32_t *matchEnd) {
+  xt_regexp *regexp = (xt_regexp *)XT_GET_PTR(regexpValue);
   xt_string *pattern = xt_as_string(regexp->source);
   xt_string *text = xt_as_string(xt_to_string(input));
+  if (!pattern || !text) return 0;
+  if (start < 0) start = 0;
+  if ((uint32_t)start > text->length) return 0;
   int flags = REG_EXTENDED;
   xt_string *f = xt_as_string(regexp->flags);
   if (f) for (uint32_t i = 0; i < f->length; i++) if (f->data[i] == 'i') flags |= REG_ICASE;
+  char *translated = xt_regexp_translate_js(pattern->data);
+  if (!translated) return 0;
   regex_t compiled;
-  if (!pattern || !text || regcomp(&compiled, pattern->data, flags) != 0) return XT_FALSE;
-  int ok = regexec(&compiled, text->data, 0, NULL, 0) == 0;
+  if (regcomp(&compiled, translated, flags) != 0) {
+    free(translated);
+    return 0;
+  }
+  free(translated);
+  regmatch_t match;
+  match.rm_so = 0;
+  match.rm_eo = 0;
+  int ok = regexec(&compiled, text->data + start, 1, &match, 0) == 0;
   regfree(&compiled);
-  return xt_bool(ok);
+  if (!ok) return 0;
+  if (matchStart) *matchStart = start + (int32_t)match.rm_so;
+  if (matchEnd) *matchEnd = start + (int32_t)match.rm_eo;
+  return 1;
+}
+
+static int xt_regexp_is_global(xt_value regexpValue) {
+  xt_regexp *regexp = (xt_regexp *)XT_GET_PTR(regexpValue);
+  xt_string *f = xt_as_string(regexp->flags);
+  if (!f) return 0;
+  for (uint32_t i = 0; i < f->length; i++) if (f->data[i] == 'g') return 1;
+  return 0;
+}
+
+static xt_value xt_regexp_test(xt_value target, xt_value input) {
+  return xt_bool(xt_regexp_find(target, input, 0, NULL, NULL));
+}
+
+/* JavaScript-style match object: `[0]` is the matched text, `index` is the
+ * match offset and `input` is the searched string. */
+xt_value xt_regexp_exec(xt_value target, xt_value input) {
+  int32_t start = 0;
+  int32_t end = 0;
+  if (!xt_regexp_find(target, input, 0, &start, &end)) return XT_NULL;
+  xt_value textValue = xt_to_string(input);
+  xt_string *text = xt_as_string(textValue);
+  xt_value out = xt_object_new();
+  xt_object_set(out, xt_string_from_cstr("0"), xt_string_new(text->data + start, (int64_t)(end - start)));
+  xt_object_set(out, xt_string_from_cstr("index"), xt_number((double)start));
+  xt_object_set(out, xt_string_from_cstr("input"), textValue);
+  xt_object_set(out, xt_string_from_cstr("length"), xt_number(1));
+  return out;
+}
+
+/* `String.prototype.replace`/`replaceAll` with a RegExp search value. */
+xt_value xt_regexp_replace(xt_value value, xt_value regexpValue, xt_value replacementValue) {
+  xt_string *text = xt_as_string(xt_to_string(value));
+  if (!text) return value;
+  xt_string *replacement = xt_as_string(xt_to_string(replacementValue));
+  if (!replacement) return value;
+  int global = xt_regexp_is_global(regexpValue);
+  size_t capacity = text->length + replacement->length + 16;
+  char *out = (char *)malloc(capacity);
+  if (!out) abort();
+  size_t length = 0;
+  int32_t cursor = 0;
+  int replaced = 0;
+  for (;;) {
+    int32_t start = 0;
+    int32_t end = 0;
+    if (!xt_regexp_find(regexpValue, value, cursor, &start, &end)) break;
+    size_t prefix = (size_t)(start - cursor);
+    size_t needed = length + prefix + replacement->length + 2;
+    if (needed > capacity) {
+      capacity = needed * 2;
+      out = (char *)realloc(out, capacity);
+      if (!out) abort();
+    }
+    memcpy(out + length, text->data + cursor, prefix);
+    length += prefix;
+    memcpy(out + length, replacement->data, replacement->length);
+    length += replacement->length;
+    replaced = 1;
+    if (end > start) {
+      cursor = end;
+    } else {
+      /* Zero-width match: copy one byte so the scan always progresses. */
+      if (cursor >= (int32_t)text->length) break;
+      out[length++] = text->data[cursor++];
+    }
+    if (!global) break;
+  }
+  if (!replaced) {
+    free(out);
+    return value;
+  }
+  size_t tail = text->length - (size_t)cursor;
+  if (length + tail + 1 > capacity) {
+    capacity = length + tail + 1;
+    out = (char *)realloc(out, capacity);
+    if (!out) abort();
+  }
+  memcpy(out + length, text->data + cursor, tail);
+  length += tail;
+  xt_value result = xt_string_new(out, (int64_t)length);
+  free(out);
+  return result;
+}
+
+/* Property access (`re.source`, `re.flags`, `re.global`, ...). */
+xt_value xt_regexp_get_property(xt_value target, xt_value key) {
+  xt_regexp *regexp = (xt_regexp *)XT_GET_PTR(target);
+  if (!XT_IS_STRING(key)) return XT_UNDEFINED;
+  xt_string *k = xt_as_string(key);
+  xt_string *f = xt_as_string(regexp->flags);
+  int flag = 0;
+  if (k->length == 6 && memcmp(k->data, "source", 6) == 0) return regexp->source;
+  if (k->length == 5 && memcmp(k->data, "flags", 5) == 0) return regexp->flags;
+  if (k->length == 9 && memcmp(k->data, "lastIndex", 9) == 0) return xt_number(0);
+  if (k->length == 6 && memcmp(k->data, "global", 6) == 0) flag = 'g';
+  else if (k->length == 10 && memcmp(k->data, "ignoreCase", 10) == 0) flag = 'i';
+  else if (k->length == 9 && memcmp(k->data, "multiline", 9) == 0) flag = 'm';
+  else if (k->length == 6 && memcmp(k->data, "sticky", 6) == 0) flag = 'y';
+  if (flag) {
+    if (f) for (uint32_t i = 0; i < f->length; i++) if (f->data[i] == flag) return XT_TRUE;
+    return XT_FALSE;
+  }
+  return XT_UNDEFINED;
 }
 
 xt_value xt_ext_container_method(xt_value target, const char *method, int32_t argc, xt_value *argv, int *handled) {
@@ -1050,14 +1283,7 @@ xt_value xt_ext_container_method(xt_value target, const char *method, int32_t ar
     xt_regexp *regexp = (xt_regexp *)obj;
     *handled = 1;
     if (strcmp(method, "test") == 0) return xt_regexp_test(target, xt_arg_at(argc, argv, 0));
-    if (strcmp(method, "exec") == 0) {
-      if (xt_truthy(xt_regexp_test(target, xt_arg_at(argc, argv, 0)))) {
-        xt_value out = xt_array_new(0, NULL);
-        xt_array_push(out, xt_arg_at(argc, argv, 0));
-        return out;
-      }
-      return XT_NULL;
-    }
+    if (strcmp(method, "exec") == 0) return xt_regexp_exec(target, xt_arg_at(argc, argv, 0));
     if (strcmp(method, "toString") == 0) {
       xt_value out = xt_string_from_cstr("/");
       out = xt_add(out, regexp->source);

package/runtime/xt_values.c

@@ -117,7 +117,8 @@ int xt_truthy(xt_value v) {
   if (v == XT_UNDEFINED || v == XT_NULL) return 0;
   if (v == XT_FALSE) return 0;
   if (v == XT_TRUE) return 1;
-  return 1; /* objects, arrays, functions and non-empty strings are truthy */
+  if (XT_IS_STRING(v)) return xt_as_string(v)->length != 0;
+  return 1; /* objects, arrays and functions are truthy */
 }
 
 double xt_to_number(xt_value v) {

package/src/ast/expressions.ts

@@ -40,7 +40,7 @@ export interface NumericLiteral extends Node {
 export interface BigIntLiteral extends Node {
   readonly kind: SyntaxKind.BigIntLiteral;
   readonly text: string;
-  readonly value: bigint;
+  readonly value: number;
 }
 
 export interface StringLiteral extends Node {
@@ -127,7 +127,12 @@ export interface ObjectLiteralExpression extends Node {
   readonly properties: ObjectLiteralElementLike[];
 }
 
-export type PropertyName = Identifier | StringLiteral | NumericLiteral | PrivateIdentifier;
+export type PropertyName = Identifier | StringLiteral | NumericLiteral | PrivateIdentifier | ComputedPropertyName;
+
+export interface ComputedPropertyName extends Node {
+  readonly kind: SyntaxKind.ComputedPropertyName;
+  readonly expression: Expression;
+}
 
 export interface FunctionExpression extends Node {
   readonly kind: SyntaxKind.FunctionExpression;

package/src/ast/kinds.ts

@@ -62,6 +62,7 @@ export const enum SyntaxKind {
   ArrayBindingPattern = 46,
   ObjectBindingPattern = 47,
   BindingElement = 48,
+  ComputedPropertyName = 49,
 
   // Statements
   ExpressionStatement = 60,

package/src/binder/binder.ts

@@ -454,6 +454,35 @@ class Binder {
       case SyntaxKind.Identifier:
         this.reference(node as Identifier, scope);
         return;
+      case SyntaxKind.PropertyAccessExpression:
+        // `obj.name` reads a property, not a variable named `name`.
+        this.bindNode((node as unknown as { expression: Expression }).expression, scope);
+        return;
+      case SyntaxKind.ElementAccessExpression: {
+        const access = node as unknown as { expression: Expression; argumentExpression: Expression };
+        this.bindNode(access.expression, scope);
+        this.bindNode(access.argumentExpression, scope);
+        return;
+      }
+      case SyntaxKind.PropertyAssignment: {
+        // `{ key: value }` / `{ key() {} }`: only the value is an expression,
+        // except a computed key (`{ [expr]: value }`) whose expression is real.
+        const property = node as unknown as { name: PropertyName; initializer: Expression };
+        if (property.name.kind === SyntaxKind.ComputedPropertyName) {
+          this.bindNode((property.name as unknown as { expression: Expression }).expression, scope);
+        }
+        this.bindNode(property.initializer, scope);
+        return;
+      }
+      case SyntaxKind.ShorthandPropertyAssignment:
+        this.reference((node as unknown as { name: Identifier }).name, scope);
+        return;
+      case SyntaxKind.LabeledStatement:
+        this.bindNode((node as unknown as { statement: Node }).statement, scope);
+        return;
+      case SyntaxKind.BreakStatement:
+      case SyntaxKind.ContinueStatement:
+        return;
       case SyntaxKind.ThisKeyword:
         this.current.usesThis = true;
         return;

package/src/codegen/generator/calls.ts

@@ -14,6 +14,7 @@ import {
   type Identifier,
   type ObjectLiteralExpression,
   type PropertyAccessExpression,
+  type SpreadElement,
 } from "../../ast/nodes.js";
 import { SymbolKind, type FunctionInfo } from "../../binder/binder.js";
 import type { ModuleExport } from "../../extensions/registry.js";
@@ -35,7 +36,7 @@ export interface CallMethods {
   emitCall(this: Generator, node: CallExpression): string;
   tryEmitBuiltinCall(this: Generator, node: CallExpression, callee: PropertyAccessExpression): string | undefined;
   runtimeCall(this: Generator, name: string, args: readonly string[]): string;
-  emitArguments(this: Generator, args: readonly Expression[]): { argc: number; ptr: string };
+  emitArguments(this: Generator, args: readonly Expression[]): { argc: string; ptr: string };
   emitDelete(this: Generator, node: DeleteExpression): string;
   emitPropertyAccess(this: Generator, node: PropertyAccessExpression): string;
   emitElementAccess(this: Generator, node: ElementAccessExpression): string;
@@ -262,17 +263,38 @@ export const callMethods: CallMethods = {
     return result;
   },
 
-  emitArguments(args: readonly Expression[]): { argc: number; ptr: string } {
-    if (args.length === 0) return { argc: 0, ptr: "null" };
-    const ptr = `%args${this.current.allocas.length}`;
-    this.current.allocas.push(`${ptr} = alloca i64, i32 ${args.length}`);
-    for (let index = 0; index < args.length; index++) {
-      const value = this.emitExpression(args[index]!);
-      const slot = this.reg();
-      this.emit(`  ${slot} = getelementptr i64, i64* ${ptr}, i32 ${index}`);
-      this.emit(`  store i64 ${value}, i64* ${slot}`);
+  emitArguments(args: readonly Expression[]): { argc: string; ptr: string } {
+    if (args.length === 0) return { argc: "0", ptr: "null" };
+    const hasSpread = args.some((element) => element.kind === SyntaxKind.SpreadElement);
+    if (!hasSpread) {
+      const ptr = `%args${this.current.allocas.length}`;
+      this.current.allocas.push(`${ptr} = alloca i64, i32 ${args.length}`);
+      for (let index = 0; index < args.length; index++) {
+        const value = this.emitExpression(args[index]!);
+        const slot = this.reg();
+        this.emit(`  ${slot} = getelementptr i64, i64* ${ptr}, i32 ${index}`);
+        this.emit(`  store i64 ${value}, i64* ${slot}`);
+      }
+      return { argc: String(args.length), ptr };
+    }
+    // At least one `...spread`: accumulate the argument list in a runtime
+    // array, which grows to whatever length the spread produces.
+    const array = this.reg();
+    this.emit(`  ${array} = call i64 @xt_array_new(i32 0, i64* null)`);
+    for (const element of args) {
+      if (element.kind === SyntaxKind.SpreadElement) {
+        const value = this.emitExpression((element as SpreadElement).expression);
+        this.emit(`  call i64 @xt_array_spread(i64 ${array}, i64 ${value})`);
+      } else {
+        const value = this.emitExpression(element);
+        this.emit(`  call i64 @xt_array_push(i64 ${array}, i64 ${value})`);
+      }
     }
-    return { argc: args.length, ptr };
+    const argc = this.reg();
+    this.emit(`  ${argc} = call i32 @xt_array_size(i64 ${array})`);
+    const ptr = this.reg();
+    this.emit(`  ${ptr} = call i64* @xt_array_items(i64 ${array})`);
+    return { argc, ptr };
   },
 
   emitDelete(node: DeleteExpression): string {
@@ -398,14 +420,15 @@ export const callMethods: CallMethods = {
       this.emit(`  ${result} = call i64 @xt_array_new(i32 ${args.argc}, i64* ${args.ptr})`);
       return result;
     }
-    let array = this.runtimeCall("xt_array_new", [`0`, `null`]);
+    const array = this.reg();
+    this.emit(`  ${array} = call i64 @xt_array_new(i32 0, i64* null)`);
     for (const element of node.elements) {
       if (element.kind === SyntaxKind.SpreadElement) {
         const spread = this.emitExpression((element as { expression: Expression }).expression);
-        array = this.runtimeCall("xt_array_spread", [array, spread]);
+        this.emit(`  call i64 @xt_array_spread(i64 ${array}, i64 ${spread})`);
       } else {
         const value = this.emitExpression(element);
-        array = this.runtimeCall("xt_array_push", [array, value]);
+        this.emit(`  call i64 @xt_array_push(i64 ${array}, i64 ${value})`);
       }
     }
     return array;
@@ -416,8 +439,15 @@ export const callMethods: CallMethods = {
     this.emit(`  ${object} = call i64 @xt_object_new()`);
     for (const property of node.properties) {
       if (property.kind === SyntaxKind.PropertyAssignment) {
-        const name = propertyNameText(property.name);
-        const key = this.stringValue(name);
+        const nameNode = property.name;
+        let key: string;
+        if (nameNode.kind === SyntaxKind.ComputedPropertyName) {
+          const keyValue = this.emitExpression((nameNode as { expression: Expression }).expression);
+          key = this.reg();
+          this.emit(`  ${key} = call i64 @xt_to_string(i64 ${keyValue})`);
+        } else {
+          key = this.stringValue(propertyNameText(nameNode));
+        }
         const value = this.emitExpression(property.initializer);
         this.emit(`  call i64 @xt_set(i64 ${object}, i64 ${key}, i64 ${value})`);
       } else if (property.kind === SyntaxKind.ShorthandPropertyAssignment) {
@@ -482,6 +512,19 @@ export const callMethods: CallMethods = {
 
   emitSuperConstructor(node: CallExpression): string {
     const thisValue = this.emitThis();
+    const classInfo = this.current.fn.classInfo;
+    const parent = classInfo?.parentExpression;
+    const unboundBuiltin =
+      parent !== undefined &&
+      parent.kind === SyntaxKind.Identifier &&
+      (parent as Identifier).text === "Error" &&
+      !this.binding.symbolOfIdentifier.get(parent as Identifier);
+    if (unboundBuiltin) {
+      const args = this.emitArguments(node.arguments);
+      const result = this.reg();
+      this.emit(`  ${result} = call i64 @xt_error_init(i64 ${thisValue}, i32 ${args.argc}, i64* ${args.ptr})`);
+      return result;
+    }
     const proto = this.reg();
     this.emit(`  ${proto} = call i64 @xt_object_get_prototype(i64 ${thisValue})`);
     const parentProto = this.reg();

package/src/codegen/generator/context.ts

@@ -117,7 +117,7 @@ export class GeneratorContext {
     return ptr;
   }
 
-  const(hex: bigint): string {
+  const(hex: string): string {
     return i64(hex);
   }
 

package/src/codegen/generator/expressions.ts

@@ -33,7 +33,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 { BINARY_RUNTIME, compoundToBinary, isAssignmentOperator, CTOR_FUNCTIONS } from "./tables.js";
+import { BINARY_RUNTIME, compoundToBinary, isAssignmentOperator, BUILTIN_FUNCTION_VALUES, CTOR_FUNCTIONS } from "./tables.js";
 import type { Generator } from "./generator.js";
 
 export interface ExpressionMethods {
@@ -64,7 +64,7 @@ export const expressionMethods: ExpressionMethods = {
         return numberLiteral(value);
       }
       case SyntaxKind.BigIntLiteral:
-        return numberLiteral(Number((node as { value: bigint }).value));
+        return numberLiteral((node as { value: number }).value);
       case SyntaxKind.StringLiteral:
         return this.stringValue((node as { value: string }).value);
       case SyntaxKind.NoSubstitutionTemplateLiteral:
@@ -197,7 +197,17 @@ export const expressionMethods: ExpressionMethods = {
         this.emit(`  ${rest} = call i64 @xt_rest_args(i32 ${argc}, i64* ${argv}, i32 0)`);
         return rest;
       }
-      default:
+      default: {
+        const builtinValue = BUILTIN_FUNCTION_VALUES[identifier.text];
+        if (builtinValue) {
+          // A global like `Boolean` used as a value (`arr.filter(Boolean)`):
+          // wrap its runtime trampoline in a closure object.
+          const cast = this.reg();
+          this.emit(`  ${cast} = bitcast i64 (i64, i64, i32, i64*)* @${builtinValue} to i8*`);
+          const closure = this.reg();
+          this.emit(`  ${closure} = call i64 @xt_closure_new(i8* ${cast}, i32 0, i64* null)`);
+          return closure;
+        }
         this.diagnostics.error(
           DiagnosticCode.CannotFindName,
           `Cannot find name '${identifier.text}'`,
@@ -205,6 +215,7 @@ export const expressionMethods: ExpressionMethods = {
           this.sourceFile.fileName,
         );
         return i64(XT_UNDEFINED);
+      }
     }
   },
 

package/src/codegen/generator/module.ts

@@ -4,6 +4,7 @@
  */
 
 import {
+  ModifierKind,
   SyntaxKind,
   type ArrowFunction,
   type Block,
@@ -15,8 +16,20 @@ import type { ClassInfo, FunctionInfo, SymbolInfo } from "../../binder/binder.js
 import { SymbolKind } from "../../binder/binder.js";
 import { i64, XT_UNDEFINED } from "../values.js";
 import { RUNTIME_DECLARATIONS, type FunctionState } from "./state.js";
+import { propertyNameText } from "./tables.js";
 import type { Generator } from "./generator.js";
 
+/** Accessibility/`readonly` parameter modifiers make a constructor parameter a property. */
+function isParameterProperty(parameter: Parameter): boolean {
+  return parameter.modifiers.some(
+    (modifier) =>
+      modifier.modifierKind === ModifierKind.Public ||
+      modifier.modifierKind === ModifierKind.Private ||
+      modifier.modifierKind === ModifierKind.Protected ||
+      modifier.modifierKind === ModifierKind.Readonly,
+  );
+}
+
 export interface ModuleMethods {
   run(this: Generator): string;
   emitFunction(this: Generator, fn: FunctionInfo): void;
@@ -120,6 +133,31 @@ export const moduleMethods: ModuleMethods = {
       this.emit(`  store i64 ${inherited}, i64* %saved.this`);
     }
 
+    // A derived class with no explicit constructor gets an implicit one that
+    // forwards every argument to the parent constructor (`super(...arguments)`).
+    if (fn.isConstructor && fn.classInfo?.parentExpression) {
+      const explicitBody = (fn.node as { body?: Block }).body;
+      const parent = fn.classInfo.parentExpression;
+      const unboundBuiltin =
+        parent.kind === SyntaxKind.Identifier &&
+        (parent as Identifier).text === "Error" &&
+        !this.binding.symbolOfIdentifier.get(parent as Identifier);
+      if (!explicitBody && !unboundBuiltin) {
+        const parentValue = this.emitExpression(parent);
+        const parentProto = this.reg();
+        this.emit(`  ${parentProto} = call i64 @xt_function_get_prototype(i64 ${parentValue})`);
+        const ctorKey = this.stringValue("__ctor");
+        const parentCtor = this.reg();
+        this.emit(`  ${parentCtor} = call i64 @xt_get(i64 ${parentProto}, i64 ${ctorKey})`);
+        const superThis = this.emitThis();
+        this.emit(`  call i64 @xt_call_with_this(i64 ${parentCtor}, i64 ${superThis}, i32 %argc, i64* %argv)`);
+      } else if (!explicitBody && unboundBuiltin) {
+        // `extends Error` with no explicit constructor: initialise message/name.
+        const superThis = this.emitThis();
+        this.emit(`  call i64 @xt_error_init(i64 ${superThis}, i32 %argc, i64* %argv)`);
+      }
+    }
+
     // Instance field initializers run before the constructor body.
     if (fn.isConstructor && fn.classInfo) {
       const thisValue = this.emitThis();
@@ -131,6 +169,20 @@ export const moduleMethods: ModuleMethods = {
       }
     }
 
+    // Constructor parameter properties (`constructor(private readonly x: T) {}`)
+    // copy the incoming argument onto `this`.
+    if (fn.isConstructor) {
+      const thisValue = this.emitThis();
+      for (let index = 0; index < fn.params.length; index++) {
+        const parameter = parameterNodes[index];
+        if (!parameter || !isParameterProperty(parameter)) continue;
+        const symbol = fn.params[index]!;
+        const key = this.stringValue(propertyNameText(parameter.name));
+        const value = this.readSlot(symbol);
+        this.emit(`  call i64 @xt_set(i64 ${thisValue}, i64 ${key}, i64 ${value})`);
+      }
+    }
+
     // Body.
     if (fn.node.kind === SyntaxKind.SourceFile) {
       this.emitStatements(this.sourceFile.statements);
@@ -220,7 +272,14 @@ export const moduleMethods: ModuleMethods = {
     for (const method of classInfo.methods) {
       const fnValue = this.emitClosureValue(method);
       const key = this.stringValue(method.name);
-      this.emit(`  call i64 @xt_set(i64 ${proto}, i64 ${key}, i64 ${fnValue})`);
+      const accessor = (method.node as { accessor?: "get" | "set" }).accessor;
+      if (accessor === "get") {
+        this.emit(`  call i64 @xt_object_define_getter(i64 ${proto}, i64 ${key}, i64 ${fnValue})`);
+      } else if (accessor === "set") {
+        this.emit(`  call i64 @xt_object_define_setter(i64 ${proto}, i64 ${key}, i64 ${fnValue})`);
+      } else {
+        this.emit(`  call i64 @xt_set(i64 ${proto}, i64 ${key}, i64 ${fnValue})`);
+      }
     }
     const ctor = this.emitClosureValue(classInfo.ctor!);
     this.emit(`  call i64 @xt_function_set_prototype(i64 ${ctor}, i64 ${proto})`);