xbintsc 0.2.4 → 0.2.6

package/src/ast/declarations.ts

@@ -14,7 +14,7 @@ import type { TypeElement } from "./types.js";
 
 export interface Parameter extends Node {
   readonly kind: SyntaxKind.Parameter;
-  readonly name: Identifier;
+  readonly name: BindingName;
   readonly modifiers: Modifier[];
   readonly dotDotDotToken: boolean;
   readonly questionToken: boolean;
@@ -22,6 +22,29 @@ export interface Parameter extends Node {
   readonly initializer?: Expression;
 }
 
+// -- binding patterns (destructuring) --------------------------------------
+
+export type BindingName = Identifier | ArrayBindingPattern | ObjectBindingPattern;
+
+export interface BindingElement extends Node {
+  readonly kind: SyntaxKind.BindingElement;
+  readonly name: BindingName;
+  /** For `{ a: b }` the `a`; absent for shorthand and array patterns. */
+  readonly propertyName?: PropertyName;
+  readonly dotDotDotToken: boolean;
+  readonly initializer?: Expression;
+}
+
+export interface ArrayBindingPattern extends Node {
+  readonly kind: SyntaxKind.ArrayBindingPattern;
+  readonly elements: (BindingElement | undefined)[];
+}
+
+export interface ObjectBindingPattern extends Node {
+  readonly kind: SyntaxKind.ObjectBindingPattern;
+  readonly elements: BindingElement[];
+}
+
 export interface TypeParameterDeclaration extends Node {
   readonly kind: SyntaxKind.TypeParameterDeclaration;
   readonly name: Identifier;
@@ -74,6 +97,8 @@ export interface MethodDeclaration extends Node {
   readonly body?: Block;
   readonly flags: NodeFlags;
   readonly optional: boolean;
+  /** Present for `get x()` / `set x(v)` accessors. */
+  readonly accessor?: "get" | "set";
 }
 
 export interface ConstructorDeclaration extends Node {

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

@@ -59,6 +59,10 @@ export const enum SyntaxKind {
   AwaitExpression = 43,
   YieldExpression = 44,
   TaggedTemplateExpression = 45,
+  ArrayBindingPattern = 46,
+  ObjectBindingPattern = 47,
+  BindingElement = 48,
+  ComputedPropertyName = 49,
 
   // Statements
   ExpressionStatement = 60,
@@ -173,4 +177,5 @@ export const enum ModifierKind {
   Static = "static",
   Readonly = "readonly",
   Async = "async",
+  Const = "const",
 }

package/src/ast/statements.ts

@@ -5,6 +5,7 @@
 import { SyntaxKind } from "./kinds.js";
 import type { Expression, Modifier, Node, Statement, TypeNode } from "./common.js";
 import type { Identifier } from "./expressions.js";
+import type { BindingName } from "./declarations.js";
 
 // ---------------------------------------------------------------------------
 // Statements
@@ -30,7 +31,7 @@ export interface DebuggerStatement extends Node {
 
 export interface VariableDeclaration extends Node {
   readonly kind: SyntaxKind.VariableDeclaration;
-  readonly name: Identifier;
+  readonly name: BindingName;
   readonly exclamation: boolean;
   readonly type?: TypeNode;
   readonly initializer?: Expression;

package/src/binder/binder.ts

@@ -13,6 +13,7 @@ import { NodeFlags, ModifierKind } from "../ast/kinds.js";
 import {
   SyntaxKind,
   type ArrowFunction,
+  type BindingName,
   type Block,
   type ClassDeclaration,
   type ClassExpression,
@@ -244,6 +245,27 @@ class Binder {
     return { kind, node, parent, fn: this.current, symbols: new Map() };
   }
 
+  /** Declare every identifier introduced by a (possibly destructured) binding. */
+  private declareBinding(
+    name: BindingName,
+    kind: SymbolKind,
+    declaration: Node,
+    scope: Scope,
+    mutable: boolean,
+  ): SymbolInfo | undefined {
+    if (name.kind === SyntaxKind.Identifier) {
+      return this.declare(name.text, kind, declaration, scope, mutable);
+    }
+    let first: SymbolInfo | undefined;
+    const pattern = name as import("../ast/declarations.js").ArrayBindingPattern | import("../ast/declarations.js").ObjectBindingPattern;
+    for (const element of pattern.elements) {
+      if (!element) continue;
+      const symbol = this.declareBinding(element.name, kind, element.name, scope, mutable);
+      if (!first) first = symbol;
+    }
+    return first;
+  }
+
   private declare(
     name: string,
     kind: SymbolKind,
@@ -334,7 +356,7 @@ class Binder {
           ? SymbolKind.Var
           : SymbolKind.Let;
     for (const declaration of list.declarations) {
-      this.declare(declaration.name.text, kind, declaration, scope, kind !== SymbolKind.Const);
+      this.declareBinding(declaration.name, kind, declaration, scope, kind !== SymbolKind.Const);
     }
   }
 
@@ -369,9 +391,9 @@ class Binder {
           const decl = node as VariableStatement;
           if (decl.declarationList.declarationKind === "var") {
             for (const d of decl.declarationList.declarations) {
-              const existing = fn.scope.symbols.get(d.name.text);
-              if (!existing) this.declare(d.name.text, SymbolKind.Var, d, fn.scope, true);
-              else this.symbolOfDeclaration.set(d, existing);
+              const existing = d.name.kind === SyntaxKind.Identifier ? fn.scope.symbols.get(d.name.text) : undefined;
+              if (!existing) this.declareBinding(d.name, SymbolKind.Var, d, fn.scope, true);
+              else if (d.name.kind === SyntaxKind.Identifier) this.symbolOfDeclaration.set(d, existing);
             }
           }
           return;
@@ -432,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;
@@ -506,11 +557,26 @@ class Binder {
   private bindVariableList(list: VariableDeclarationList, scope: Scope): void {
     for (const declaration of list.declarations) {
       const symbol = this.symbolOfDeclaration.get(declaration);
-      if (declaration.name) this.symbolOfDeclaration.set(declaration.name, symbol ?? this.symbolOfDeclaration.get(declaration) as SymbolInfo);
+      if (declaration.name.kind === SyntaxKind.Identifier) {
+        this.symbolOfDeclaration.set(declaration.name, symbol ?? this.symbolOfDeclaration.get(declaration) as SymbolInfo);
+      } else {
+        this.bindBindingPattern(declaration.name, scope);
+      }
       this.bindNode(declaration.initializer, scope);
     }
   }
 
+  /** Bind default-value expressions inside a binding pattern. */
+  private bindBindingPattern(name: BindingName, scope: Scope): void {
+    if (name.kind === SyntaxKind.Identifier) return;
+    const pattern = name as import("../ast/declarations.js").ArrayBindingPattern | import("../ast/declarations.js").ObjectBindingPattern;
+    for (const element of pattern.elements) {
+      if (!element) continue;
+      if (element.initializer) this.bindNode(element.initializer, scope);
+      this.bindBindingPattern(element.name, scope);
+    }
+  }
+
   private bindFunction(
     node: FunctionDeclaration | FunctionExpression | ArrowFunction,
     parentScope: Scope,
@@ -533,8 +599,8 @@ class Binder {
     // Parameters live in the function scope.
     const params: SymbolInfo[] = [];
     for (const parameter of node.parameters) {
-      const paramSymbol = this.declare(parameter.name.text, SymbolKind.Parameter, parameter, scope, true);
-      params.push(paramSymbol);
+      const paramSymbol = this.declareBinding(parameter.name, SymbolKind.Parameter, parameter, scope, true);
+      if (paramSymbol) params.push(paramSymbol);
       if (parameter.initializer) this.bindNode(parameter.initializer, scope);
     }
     (fn as { params: SymbolInfo[] }).params = params;
@@ -651,8 +717,8 @@ class Binder {
 
     const params: SymbolInfo[] = [];
     for (const parameter of parameters) {
-      const paramSymbol = this.declare(parameter.name.text, SymbolKind.Parameter, parameter, scope, true);
-      params.push(paramSymbol);
+      const paramSymbol = this.declareBinding(parameter.name, SymbolKind.Parameter, parameter, scope, true);
+      if (paramSymbol) params.push(paramSymbol);
       if (parameter.initializer) this.bindNode(parameter.initializer, scope);
     }
     (fn as { params: SymbolInfo[] }).params = params;

package/src/cli/main.ts

@@ -16,7 +16,7 @@ import { resolve } from "node:path";
 import { pathToFileURL } from "node:url";
 import { DiagnosticBag, formatDiagnostic, type Diagnostic } from "../diagnostics/diagnostic.js";
 import { SourceFile } from "../diagnostics/source.js";
-import { build, compileString, COMPILER_VERSION, type EmitKind } from "../driver/compiler.js";
+import { build, compileEntry, COMPILER_VERSION, type EmitKind } from "../driver/compiler.js";
 import { createDefaultRegistry, type ExtensionRegistry } from "../extensions/registry.js";
 import { nodeExtension } from "../extensions/node/index.js";
 
@@ -152,9 +152,8 @@ export function run(argv: readonly string[], io: CliIo = defaultIo): number {
       io.stderr("xbintsc: emit requires a source file\n");
       return 1;
     }
-    const source = readFileSync(resolve(entry), "utf8");
     const registry = buildRegistry(args.flags);
-    const { ir, diagnostics } = compileString(source, entry, registry);
+    const { ir, diagnostics } = compileEntry(entry, registry);
     if (diagnostics.some((d) => d.category === "error")) {
       printDiagnostics(diagnostics, entry, io);
       return 1;

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,11 +64,27 @@ 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:
         return this.stringValue((node as { value: string }).value);
+      case SyntaxKind.RegularExpressionLiteral: {
+        const regex = node as { pattern: string; flags: string };
+        const pattern = this.stringValue(regex.pattern);
+        const flags = this.stringValue(regex.flags);
+        const ptr = `%regex${this.current.allocas.length}`;
+        this.current.allocas.push(`${ptr} = alloca i64, i32 2`);
+        const slot0 = this.reg();
+        this.emit(`  ${slot0} = getelementptr i64, i64* ${ptr}, i32 0`);
+        this.emit(`  store i64 ${pattern}, i64* ${slot0}`);
+        const slot1 = this.reg();
+        this.emit(`  ${slot1} = getelementptr i64, i64* ${ptr}, i32 1`);
+        this.emit(`  store i64 ${flags}, i64* ${slot1}`);
+        const result = this.reg();
+        this.emit(`  ${result} = call i64 @xt_regexp_ctor(i32 2, i64* ${ptr})`);
+        return result;
+      }
       case SyntaxKind.TemplateLiteral:
         return this.emitTemplate(node as TemplateLiteral);
       case SyntaxKind.TrueKeyword:
@@ -87,6 +103,15 @@ export const expressionMethods: ExpressionMethods = {
         return this.emitExpression((node as { expression: Expression }).expression);
       case SyntaxKind.DeleteExpression:
         return this.emitDelete(node as DeleteExpression);
+      case SyntaxKind.TypeOfExpression: {
+        const operand = this.emitExpression((node as { expression: Expression }).expression);
+        const result = this.reg();
+        this.emit(`  ${result} = call i64 @xt_typeof(i64 ${operand})`);
+        return result;
+      }
+      case SyntaxKind.VoidExpression:
+        this.emitExpression((node as { expression: Expression }).expression);
+        return i64(XT_UNDEFINED);
       case SyntaxKind.ThisKeyword:
         return this.emitThis();
       case SyntaxKind.NewExpression:
@@ -172,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}'`,
@@ -180,6 +215,7 @@ export const expressionMethods: ExpressionMethods = {
           this.sourceFile.fileName,
         );
         return i64(XT_UNDEFINED);
+      }
     }
   },
 

package/src/codegen/generator/module.ts

@@ -4,18 +4,32 @@
  */
 
 import {
+  ModifierKind,
   SyntaxKind,
   type ArrowFunction,
   type Block,
   type Expression,
+  type Identifier,
   type Parameter,
 } from "../../ast/nodes.js";
 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;
@@ -40,8 +54,11 @@ export const moduleMethods: ModuleMethods = {
     const moduleScope = this.binding.scopes.get(this.sourceFile);
     if (moduleScope) {
       for (const symbol of moduleScope.symbols.values()) {
-        const isVariable = symbol.kind === SymbolKind.Var || symbol.kind === SymbolKind.Let || symbol.kind === SymbolKind.Const;
-        if (!isVariable || !symbol.boxed || !symbol.fn.isModule) continue;
+        const isVariable =
+          symbol.kind === SymbolKind.Var || symbol.kind === SymbolKind.Let || symbol.kind === SymbolKind.Const;
+        const isEnum = symbol.kind === SymbolKind.Enum;
+        if ((!isVariable && !isEnum) || !symbol.fn?.isModule) continue;
+        if (isVariable && !symbol.boxed) continue;
         const globalName = `@g.${symbol.id}`;
         this.moduleGlobals.set(symbol.id, globalName);
         this.globals.push(`${globalName} = internal global i64 ${i64(XT_UNDEFINED)}`);
@@ -116,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();
@@ -127,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);
@@ -199,15 +255,31 @@ export const moduleMethods: ModuleMethods = {
     const proto = this.reg();
     this.emit(`  ${proto} = call i64 @xt_object_new()`);
     if (classInfo.parentExpression) {
-      const parent = this.emitExpression(classInfo.parentExpression);
-      const parentProto = this.reg();
-      this.emit(`  ${parentProto} = call i64 @xt_function_get_prototype(i64 ${parent})`);
-      this.emit(`  call i64 @xt_object_set_prototype(i64 ${proto}, i64 ${parentProto})`);
+      // `extends Error` (and other host builtins) have no runtime class value;
+      // the subclass still works, it simply does not inherit a prototype.
+      const parent = classInfo.parentExpression;
+      const unboundBuiltin =
+        parent.kind === SyntaxKind.Identifier &&
+        (parent as Identifier).text === "Error" &&
+        !this.binding.symbolOfIdentifier.get(parent as Identifier);
+      if (!unboundBuiltin) {
+        const parentValue = this.emitExpression(parent);
+        const parentProto = this.reg();
+        this.emit(`  ${parentProto} = call i64 @xt_function_get_prototype(i64 ${parentValue})`);
+        this.emit(`  call i64 @xt_object_set_prototype(i64 ${proto}, i64 ${parentProto})`);
+      }
     }
     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})`);

package/src/codegen/generator/state.ts

@@ -68,6 +68,8 @@ export const RUNTIME_DECLARATIONS: readonly string[] = [
   "declare i64 @xt_object_new_with_proto(i64)",
   "declare i64 @xt_object_get_prototype(i64)",
   "declare i64 @xt_object_set_prototype(i64, i64)",
+  "declare i64 @xt_object_define_getter(i64, i64, i64)",
+  "declare i64 @xt_object_define_setter(i64, i64, i64)",
   "declare i64 @xt_await(i64)",
   "declare void @xt_drain_microtasks()",
   "declare void @xt_run_event_loop()",
@@ -101,6 +103,8 @@ export const RUNTIME_DECLARATIONS: readonly string[] = [
   "declare i64 @xt_set_ctor(i32, i64*)",
   "declare i64 @xt_date_ctor(i32, i64*)",
   "declare i64 @xt_regexp_ctor(i32, i64*)",
+  "declare i64 @xt_error_ctor(i32, i64*)",
+  "declare i64 @xt_error_init(i64, i32, i64*)",
   "declare i64 @xt_json_parse(i32, i64*)",
   "declare i64 @xt_json_stringify(i32, i64*)",
   "declare i64 @xt_object_from_entries(i64)",
@@ -168,10 +172,22 @@ export const RUNTIME_DECLARATIONS: readonly string[] = [
   "declare i64 @xt_delete(i64, i64)",
   "declare i64 @xt_rest_args(i32, i64*, i32)",
   "declare void @xt_set_program_args(i32, i8**)",
+  "declare i64 @xt_import_meta(i64)",
   "declare i64 @xt_array_new(i32, i64*)",
   "declare i64 @xt_array_push(i64, i64)",
   "declare i64 @xt_array_length(i64)",
   "declare i64 @xt_array_spread(i64, i64)",
+  "declare i64 @xt_iter_length(i64)",
+  "declare i64 @xt_iter_value(i64, i64)",
+  "declare i32 @xt_array_size(i64)",
+  "declare i64* @xt_array_items(i64)",
+  "declare i64 @xt_builtin_value_parseInt(i64, i64, i32, i64*)",
+  "declare i64 @xt_builtin_value_parseFloat(i64, i64, i32, i64*)",
+  "declare i64 @xt_builtin_value_isNaN(i64, i64, i32, i64*)",
+  "declare i64 @xt_builtin_value_isFinite(i64, i64, i32, i64*)",
+  "declare i64 @xt_builtin_value_number(i64, i64, i32, i64*)",
+  "declare i64 @xt_builtin_value_string(i64, i64, i32, i64*)",
+  "declare i64 @xt_builtin_value_boolean(i64, i64, i32, i64*)",
   "declare i64 @xt_get(i64, i64)",
   "declare i64 @xt_set(i64, i64, i64)",
   "declare i64 @xt_box_new(i64)",