xbintsc 0.3.3 → 0.3.5

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

@@ -5,13 +5,15 @@
 
 import {
   SyntaxKind,
+  type CallExpression,
   type DeleteExpression,
   type ElementAccessExpression,
+  type Expression,
   type Identifier,
   type PropertyAccessExpression,
 } from "../../../ast/nodes.js";
 import { i64, numberLiteral, XT_TRUE, XT_UNDEFINED } from "../../values.js";
-import { MATH_CONSTANTS, NAMESPACE_PROPERTIES } from "../tables.js";
+import { MATH_CONSTANTS, NAMESPACE_PROPERTIES, NUMBER_CONSTANTS } from "../tables.js";
 import type { Generator } from "../generator.js";
 
 export interface AccessCallMethods {
@@ -19,6 +21,14 @@ export interface AccessCallMethods {
   emitPropertyAccess(this: Generator, node: PropertyAccessExpression): string;
   emitElementAccess(this: Generator, node: ElementAccessExpression): string;
   emitOptional(this: Generator, objectValue: string, compute: () => string): string;
+  /** True when `node` is (part of) an optional chain: a `?.` appears anywhere
+   *  along its member/call spine. Parentheses end the chain. */
+  isOptionalChain(this: Generator, node: Expression): boolean;
+  emitOptionalChain(this: Generator, node: Expression): string;
+  emitChainValue(this: Generator, node: Expression, endLabel: string): string;
+  emitChainReceiver(this: Generator, node: Expression, endLabel: string): string;
+  guardOptional(this: Generator, value: string, endLabel: string): void;
+  emitPropertyGet(this: Generator, object: string, name: string): string;
 }
 
 export const accessCallMethods: AccessCallMethods = {
@@ -59,6 +69,17 @@ export const accessCallMethods: AccessCallMethods = {
     ) {
       return numberLiteral(MATH_CONSTANTS[node.name.text]!);
     }
+    if (
+      node.expression.kind === SyntaxKind.Identifier &&
+      (node.expression as Identifier).text === "Number" &&
+      NUMBER_CONSTANTS.has(node.name.text) &&
+      !this.binding.symbolOfIdentifier.get(node.expression as Identifier)
+    ) {
+      const key = this.stringValue(node.name.text);
+      const result = this.reg();
+      this.emit(`  ${result} = call i64 @xt_number_static(i64 ${key}, i32 0, i64* null)`);
+      return result;
+    }
     if (
       node.expression.kind === SyntaxKind.Identifier &&
       !this.binding.symbolOfIdentifier.get(node.expression as Identifier)
@@ -86,18 +107,7 @@ export const accessCallMethods: AccessCallMethods = {
       }
     }
     const object = this.emitExpression(node.expression);
-    const access = (): string => {
-      if (node.name.text === "length") {
-        const result = this.reg();
-        this.emit(`  ${result} = call i64 @xt_array_length(i64 ${object})`);
-        return result;
-      }
-      const key = this.stringValue(node.name.text);
-      const result = this.reg();
-      this.emit(`  ${result} = call i64 @xt_get(i64 ${object}, i64 ${key})`);
-      return result;
-    };
-    return node.optional ? this.emitOptional(object, access) : access();
+    return this.emitPropertyGet(object, node.name.text);
   },
 
   emitElementAccess(node: ElementAccessExpression): string {
@@ -111,6 +121,141 @@ export const accessCallMethods: AccessCallMethods = {
     return node.optional ? this.emitOptional(object, access) : access();
   },
 
+  /** Property read that works on any receiver value (`length` is special-cased
+   *  because it is meaningful for arrays and strings). */
+  emitPropertyGet(object: string, name: string): string {
+    if (name === "length") {
+      const result = this.reg();
+      this.emit(`  ${result} = call i64 @xt_array_length(i64 ${object})`);
+      return result;
+    }
+    const key = this.stringValue(name);
+    const result = this.reg();
+    this.emit(`  ${result} = call i64 @xt_get(i64 ${object}, i64 ${key})`);
+    return result;
+  },
+
+  /*
+   * Optional chaining is a *whole-chain* short circuit in JavaScript:
+   * `a?.b.c()` evaluates to `undefined` when `a` is nullish, without reading
+   * `.b`/`.c` or calling anything. The parser records `optional` on the
+   * individual access node, so we detect the chain here, evaluate it once and
+   * branch to a shared end label whenever any `?.` guard fails. The result slot
+   * defaults to `undefined` and is overwritten only on the non-short-circuited
+   * path.
+   */
+  isOptionalChain(node: Expression): boolean {
+    let current: Expression = node;
+    for (;;) {
+      if (current.kind === SyntaxKind.PropertyAccessExpression || current.kind === SyntaxKind.ElementAccessExpression) {
+        const access = current as PropertyAccessExpression | ElementAccessExpression;
+        if (access.optional) return true;
+        current = access.expression;
+      } else if (current.kind === SyntaxKind.CallExpression) {
+        const call = current as CallExpression;
+        if (call.optional) return true;
+        current = call.expression;
+      } else {
+        return false;
+      }
+    }
+  },
+
+  emitOptionalChain(node: Expression): string {
+    const result = this.alloca();
+    this.emit(`  store i64 ${i64(XT_UNDEFINED)}, i64* ${result}`);
+    const endLabel = this.label("optchain.end");
+    const value = this.emitChainValue(node, endLabel);
+    this.emit(`  store i64 ${value}, i64* ${result}`);
+    this.terminate(`br label %${endLabel}`);
+    this.startBlock(endLabel);
+    const merged = this.reg();
+    this.emit(`  ${merged} = load i64, i64* ${result}`);
+    return merged;
+  },
+
+  emitChainValue(node: Expression, endLabel: string): string {
+    if (node.kind === SyntaxKind.PropertyAccessExpression) {
+      const access = node as PropertyAccessExpression;
+      const object = this.emitChainReceiver(access.expression, endLabel);
+      if (access.optional) this.guardOptional(object, endLabel);
+      return this.emitPropertyGet(object, access.name.text);
+    }
+    if (node.kind === SyntaxKind.ElementAccessExpression) {
+      const access = node as ElementAccessExpression;
+      const object = this.emitChainReceiver(access.expression, endLabel);
+      if (access.optional) this.guardOptional(object, endLabel);
+      const key = this.emitExpression(access.argumentExpression);
+      return this.runtimeCall("xt_get", [object, key]);
+    }
+    if (node.kind === SyntaxKind.CallExpression) {
+      const call = node as CallExpression;
+      const callee = call.expression;
+      /* `a.b?.()` / `a[k]?.()`: evaluate the callee, then invoke it with the
+       * receiver as `this` so user methods and first-class built-in method
+       * values both bind correctly. */
+      if (call.optional) {
+        if (callee.kind === SyntaxKind.PropertyAccessExpression || callee.kind === SyntaxKind.ElementAccessExpression) {
+          const access = callee as PropertyAccessExpression | ElementAccessExpression;
+          const object = this.emitChainReceiver(access.expression, endLabel);
+          if (access.optional) this.guardOptional(object, endLabel);
+          const calleeValue =
+            access.kind === SyntaxKind.PropertyAccessExpression
+              ? this.emitPropertyGet(object, (access as PropertyAccessExpression).name.text)
+              : this.runtimeCall("xt_get", [object, this.emitExpression((access as ElementAccessExpression).argumentExpression)]);
+          this.guardOptional(calleeValue, endLabel);
+          const args = this.emitArguments(call.arguments);
+          const out = this.reg();
+          this.emit(`  ${out} = call i64 @xt_call_with_this(i64 ${calleeValue}, i64 ${object}, i32 ${args.argc}, i64* ${args.ptr})`);
+          return out;
+        }
+        const calleeValue = this.emitChainReceiver(callee, endLabel);
+        this.guardOptional(calleeValue, endLabel);
+        const args = this.emitArguments(call.arguments);
+        const out = this.reg();
+        this.emit(`  ${out} = call i64 @xt_closure_call(i64 ${calleeValue}, i32 ${args.argc}, i64* ${args.ptr})`);
+        return out;
+      }
+      /* `a?.b(...)` / `a?.[k](...)`: guard the receiver, then dispatch. */
+      if (callee.kind === SyntaxKind.PropertyAccessExpression || callee.kind === SyntaxKind.ElementAccessExpression) {
+        const access = callee as PropertyAccessExpression | ElementAccessExpression;
+        const object = this.emitChainReceiver(access.expression, endLabel);
+        if (access.optional) this.guardOptional(object, endLabel);
+        const name =
+          access.kind === SyntaxKind.PropertyAccessExpression
+            ? this.stringValue((access as PropertyAccessExpression).name.text)
+            : this.emitExpression((access as ElementAccessExpression).argumentExpression);
+        const args = this.emitArguments(call.arguments);
+        const out = this.reg();
+        this.emit(`  ${out} = call i64 @xt_call_method(i64 ${object}, i64 ${name}, i32 ${args.argc}, i64* ${args.ptr})`);
+        return out;
+      }
+      const calleeValue = this.emitChainReceiver(callee, endLabel);
+      const args = this.emitArguments(call.arguments);
+      const out = this.reg();
+      this.emit(`  ${out} = call i64 @xt_closure_call(i64 ${calleeValue}, i32 ${args.argc}, i64* ${args.ptr})`);
+      return out;
+    }
+    return this.emitExpression(node);
+  },
+
+  emitChainReceiver(node: Expression, endLabel: string): string {
+    return this.isOptionalChain(node) ? this.emitChainValue(node, endLabel) : this.emitExpression(node);
+  },
+
+  /** Branch to `endLabel` (result stays `undefined`) when `value` is nullish. */
+  guardOptional(value: string, endLabel: string): void {
+    const nullish = this.reg();
+    this.emit(`  ${nullish} = call i64 @xt_is_nullish(i64 ${value})`);
+    const truthy = this.reg();
+    this.emit(`  ${truthy} = call i32 @xt_truthy(i64 ${nullish})`);
+    const condition = this.reg();
+    this.emit(`  ${condition} = icmp ne i32 ${truthy}, 0`);
+    const cont = this.label("optchain.cont");
+    this.terminate(`br i1 ${condition}, label %${endLabel}, label %${cont}`);
+    this.startBlock(cont);
+  },
+
   /**
    * Evaluate `object` once and, when it is neither `null` nor `undefined`, run
    * `compute` to produce the value; otherwise short-circuit to `undefined`.

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

@@ -10,6 +10,7 @@ import type { Generator } from "../generator.js";
 export interface ClosureCallMethods {
   emitClosure(this: Generator, node: ArrowFunction | FunctionExpression): string;
   emitClosureValue(this: Generator, fn: FunctionInfo): string;
+  emitFunctionMetadata(this: Generator, closure: string, fn: FunctionInfo): void;
 }
 
 export const closureCallMethods: ClosureCallMethods = {
@@ -55,6 +56,29 @@ export const closureCallMethods: ClosureCallMethods = {
     this.emit(`  ${cast} = bitcast i64 (i64, i64, i32, i64*)* @${this.functionName(fn)} to i8*`);
     const closure = this.reg();
     this.emit(`  ${closure} = call i64 @xt_closure_new(i8* ${cast}, i32 ${count}, i64* ${envPtr})`);
+    this.emitFunctionMetadata(closure, fn);
     return closure;
   },
+
+  /**
+   * Attach the JavaScript `name` and `length` (arity) of a closure. Arity
+   * counts parameters before the first default / rest parameter, matching the
+   * specification.
+   */
+  emitFunctionMetadata(closure: string, fn: FunctionInfo): void {
+    const parameters =
+      (fn.node as { parameters?: readonly { initializer?: unknown; dotDotDotToken?: boolean }[] })
+        .parameters ?? [];
+    let arity = 0;
+    for (const parameter of parameters) {
+      if (parameter.initializer || parameter.dotDotDotToken) break;
+      arity++;
+    }
+    let name = fn.name;
+    if (name === "(anonymous)" || name === "(arrow)") name = "";
+    if (fn.isConstructor && fn.classInfo) name = fn.classInfo.name;
+    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})`);
+  },
 };

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

@@ -100,7 +100,9 @@ export const invocationCallMethods: InvocationCallMethods = {
       if (symbol && symbol.kind === SymbolKind.Function) {
         const declaration = symbol.declarations[0];
         const fn = declaration ? this.binding.functionOfNode.get(declaration) : undefined;
-        if (fn) {
+        /* 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) {
           const args = this.emitArguments(node.arguments);
           const result = this.reg();
           this.emit(
@@ -204,6 +206,14 @@ export const invocationCallMethods: InvocationCallMethods = {
           return result;
         }
       }
+      // Modules with no namespace dispatcher (`fs`, `child_process`, ...): lower
+      // `import fs from "node:fs"; fs.readFileSync(...)` through the module's
+      // named exports, exactly like a named import of `readFileSync`.
+      const moduleExports = this.moduleExportsOfSymbol(targetSymbol);
+      if (moduleExports) {
+        const exported = moduleExports[method];
+        if (exported) return this.emitModuleExport(node, exported);
+      }
     }
 
     void BUILTIN_METHODS;

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

@@ -47,14 +47,20 @@ export const literalCallMethods: LiteralCallMethods = {
         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})`);
+          // Property keys may be symbols; `xt_set` normalises with
+          // `xt_to_property_key`.
+          key = this.emitExpression((nameNode as { expression: Expression }).expression);
         } else {
           key = this.stringValue(propertyNameText(nameNode));
         }
         const value = this.emitExpression(property.initializer);
-        this.emit(`  call i64 @xt_set(i64 ${object}, i64 ${key}, i64 ${value})`);
+        if (property.accessor === "get") {
+          this.emit(`  call i64 @xt_object_define_getter(i64 ${object}, i64 ${key}, i64 ${value})`);
+        } else if (property.accessor === "set") {
+          this.emit(`  call i64 @xt_object_define_setter(i64 ${object}, i64 ${key}, i64 ${value})`);
+        } else {
+          this.emit(`  call i64 @xt_set(i64 ${object}, i64 ${key}, i64 ${value})`);
+        }
       } else if (property.kind === SyntaxKind.ShorthandPropertyAssignment) {
         if (property.initializer) {
           // `{ a = 1 }` is only legal as a destructuring target, not a value.

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

@@ -3,9 +3,7 @@
  */
 
 import {
-  SyntaxKind,
   type CallExpression,
-  type Identifier,
   type PropertyAccessExpression,
 } from "../../../ast/nodes.js";
 import type { Generator } from "../generator.js";
@@ -20,15 +18,14 @@ export const superCallMethods: SuperCallMethods = {
     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 errorName = parent ? this.errorFamilyName(parent) : undefined;
+    if (errorName) {
       const args = this.emitArguments(node.arguments);
+      const nameValue = this.stringValue(errorName);
       const result = this.reg();
-      this.emit(`  ${result} = call i64 @xt_error_init(i64 ${thisValue}, i32 ${args.argc}, i64* ${args.ptr})`);
+      this.emit(
+        `  ${result} = call i64 @xt_error_init(i64 ${thisValue}, i64 ${nameValue}, i32 ${args.argc}, i64* ${args.ptr})`,
+      );
       return result;
     }
     const proto = this.reg();

package/src/codegen/generator/context.ts

@@ -6,18 +6,19 @@
  * helpers every group relies on.
  */
 
-import { bind, SymbolKind, type BindResult, type ClassInfo, type SymbolInfo } from "../../binder/binder.js";
+import { bind, SymbolKind, type BindResult, type SymbolInfo } from "../../binder/binder.js";
 import type { DiagnosticBag } from "../../diagnostics/diagnostic.js";
 import { DiagnosticCode } from "../../diagnostics/diagnostic.js";
-import { SyntaxKind, type ImportDeclaration, type SourceFileNode, type Node } from "../../ast/nodes.js";
+import { SyntaxKind, type Identifier, type ImportDeclaration, type Node, type SourceFileNode } from "../../ast/nodes.js";
 import { i64, XT_UNDEFINED } from "../values.js";
 import type {
   BuiltinFunction,
   ExtensionModule,
   ModuleExport,
+  ModuleExports,
 } from "../../extensions/registry.js";
 import type { CodegenOptions, FunctionState } from "./state.js";
-import { escapeBytes, kindName, utf8Bytes } from "./tables.js";
+import { escapeBytes, isErrorFamily, kindName, utf8Bytes } from "./tables.js";
 
 export class GeneratorContext {
   readonly binding: BindResult;
@@ -29,6 +30,13 @@ export class GeneratorContext {
   readonly importExports = new Map<number, ModuleExport>();
   /** Imported symbol id -> the namespace it aliases (e.g. `path`). */
   readonly importNamespaces = new Map<number, string>();
+  /**
+   * Imported symbol id -> the named exports of the module it aliases, for
+   * modules that do not expose a runtime namespace dispatcher (`fs`,
+   * `child_process`, `crypto`, ...). Lets `import fs from "node:fs"` lower
+   * `fs.readFileSync(...)` straight to the module's runtime symbol.
+   */
+  readonly importModuleExports = new Map<number, ModuleExports>();
   readonly globals: string[] = [];
   readonly functions: string[] = [];
   readonly strings = new Map<string, { label: string; length: number }>();
@@ -61,9 +69,9 @@ export class GeneratorContext {
       if (!module) continue;
       const clause = declaration.importClause;
       if (!clause) continue;
-      if (clause.name && module.namespace) {
+      if (clause.name) {
         const symbol = this.binding.symbolOfDeclaration.get(clause.name);
-        if (symbol) this.importNamespaces.set(symbol.id, module.namespace);
+        if (symbol) this.bindModuleAlias(symbol, module);
       }
       const bindings = clause.namedBindings;
       if (bindings && bindings.kind === SyntaxKind.NamedImports) {
@@ -73,19 +81,37 @@ export class GeneratorContext {
           const symbol = this.binding.symbolOfDeclaration.get(specifier.name);
           if (symbol && exported) this.importExports.set(symbol.id, exported);
         }
-      } else if (bindings && bindings.kind === SyntaxKind.NamespaceImport && module.namespace) {
+      } else if (bindings && bindings.kind === SyntaxKind.NamespaceImport) {
         const symbol = this.binding.symbolOfDeclaration.get(bindings.name);
-        if (symbol) this.importNamespaces.set(symbol.id, module.namespace);
+        if (symbol) this.bindModuleAlias(symbol, module);
       }
     }
   }
 
+  /**
+   * Bind a default/namespace import to either the module's runtime namespace
+   * dispatcher (when it has one) or its named exports (when it does not).
+   */
+  private bindModuleAlias(symbol: SymbolInfo, module: ExtensionModule): void {
+    if (module.namespace) {
+      this.importNamespaces.set(symbol.id, module.namespace);
+    } else if (module.exports) {
+      this.importModuleExports.set(symbol.id, module.exports);
+    }
+  }
+
   /** Namespace name an imported alias refers to, if any. */
   namespaceOfSymbol(symbol: SymbolInfo | undefined): string | undefined {
     if (!symbol || symbol.kind !== SymbolKind.Import) return undefined;
     return this.importNamespaces.get(symbol.id);
   }
 
+  /** Named exports a default/namespace import aliases, if any. */
+  moduleExportsOfSymbol(symbol: SymbolInfo | undefined): ModuleExports | undefined {
+    if (!symbol || symbol.kind !== SymbolKind.Import) return undefined;
+    return this.importModuleExports.get(symbol.id);
+  }
+
   // -- emission primitives -------------------------------------------------
 
   emit(line: string): void {
@@ -210,6 +236,17 @@ export class GeneratorContext {
 
   // -- string pool ---------------------------------------------------------
 
+  /**
+   * The name of the builtin Error-family constructor an expression refers to
+   * (`extends TypeError`), or `undefined` for a user class / shadowed name.
+   */
+  errorFamilyName(expression: Node): string | undefined {
+    if (expression.kind !== SyntaxKind.Identifier) return undefined;
+    const identifier = expression as Identifier;
+    if (this.binding.symbolOfIdentifier.get(identifier)) return undefined;
+    return isErrorFamily(identifier.text) ? identifier.text : undefined;
+  }
+
   stringValue(text: string): string {
     const entry = this.internString(text);
     const result = this.reg();

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

@@ -196,9 +196,7 @@ export const assignmentExpressionMethods: AssignmentExpressionMethods = {
         const assignment = property as PropertyAssignment;
         let key: string;
         if (assignment.name.kind === SyntaxKind.ComputedPropertyName) {
-          const keyValue = this.emitExpression((assignment.name as { expression: Expression }).expression);
-          key = this.reg();
-          this.emit(`  ${key} = call i64 @xt_to_string(i64 ${keyValue})`);
+          key = this.emitExpression((assignment.name as { expression: Expression }).expression);
         } else {
           key = this.stringValue(propertyNameText(assignment.name));
         }

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

@@ -9,7 +9,6 @@ import {
   type AwaitExpression,
   type BinaryExpression,
   type CallExpression,
-  type ClassExpression,
   type ConditionalExpression,
   type DeleteExpression,
   type ElementAccessExpression,
@@ -21,13 +20,15 @@ import {
   type PostfixUnaryExpression,
   type PrefixUnaryExpression,
   type PropertyAccessExpression,
+  type TaggedTemplateExpression,
   type TemplateLiteral,
+  type YieldExpression,
   type ArrayLiteralExpression,
 } from "../../../ast/nodes.js";
 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 } from "../tables.js";
+import { BUILTIN_FUNCTION_VALUES, CTOR_FUNCTIONS, ERROR_CONSTRUCTORS } from "../tables.js";
 import type { Generator } from "../generator.js";
 
 export interface PrimaryExpressionMethods {
@@ -35,13 +36,18 @@ export interface PrimaryExpressionMethods {
   emitIdentifier(this: Generator, identifier: Identifier): string;
   emitFunctionValue(this: Generator, symbol: SymbolInfo): string;
   emitTemplate(this: Generator, node: TemplateLiteral): string;
+  emitTaggedTemplate(this: Generator, node: TaggedTemplateExpression): string;
   emitThis(this: Generator): string;
   emitNew(this: Generator, node: NewExpression): string;
   emitAwait(this: Generator, node: AwaitExpression): string;
+  emitYield(this: Generator, node: YieldExpression): string;
 }
 
 export const primaryExpressionMethods: PrimaryExpressionMethods = {
   emitExpression(node: Expression): string {
+    /* An optional chain must be lowered as a unit so `?.` short-circuits the
+       entire chain (`a?.b.c()`), not just the guarded member. */
+    if (this.isOptionalChain(node)) return this.emitOptionalChain(node);
     switch (node.kind) {
       case SyntaxKind.Identifier:
         return this.emitIdentifier(node as Identifier);
@@ -77,6 +83,8 @@ export const primaryExpressionMethods: PrimaryExpressionMethods = {
       }
       case SyntaxKind.TemplateLiteral:
         return this.emitTemplate(node as TemplateLiteral);
+      case SyntaxKind.TaggedTemplateExpression:
+        return this.emitTaggedTemplate(node as TaggedTemplateExpression);
       case SyntaxKind.TrueKeyword:
         return i64(XT_TRUE);
       case SyntaxKind.FalseKeyword:
@@ -108,6 +116,8 @@ export const primaryExpressionMethods: PrimaryExpressionMethods = {
         return this.emitNew(node as NewExpression);
       case SyntaxKind.AwaitExpression:
         return this.emitAwait(node as AwaitExpression);
+      case SyntaxKind.YieldExpression:
+        return this.emitYield(node as YieldExpression);
       case SyntaxKind.ClassExpression: {
         const info = this.binding.classOfNode.get(node);
         if (!info) {
@@ -198,6 +208,13 @@ export const primaryExpressionMethods: PrimaryExpressionMethods = {
           this.emit(`  ${closure} = call i64 @xt_closure_new(i8* ${cast}, i32 0, i64* null)`);
           return closure;
         }
+        const errorCtor = ERROR_CONSTRUCTORS[identifier.text];
+        if (errorCtor) {
+          // A first-class Error-family constructor (`instanceof TypeError`,
+          // `typeof RangeError`, `class X extends Error`, ...).
+          const nameValue = this.stringValue(identifier.text);
+          return this.runtimeCall("xt_error_constructor", [nameValue]);
+        }
         this.diagnostics.error(
           DiagnosticCode.CannotFindName,
           `Cannot find name '${identifier.text}'`,
@@ -217,6 +234,7 @@ export const primaryExpressionMethods: PrimaryExpressionMethods = {
     this.emit(`  ${cast} = bitcast i64 (i64, i64, i32, i64*)* @${this.functionName(fn)} to i8*`);
     const closure = this.reg();
     this.emit(`  ${closure} = call i64 @xt_closure_new(i8* ${cast}, i32 0, i64* null)`);
+    this.emitFunctionMetadata(closure, fn);
     return closure;
   },
 
@@ -234,6 +252,19 @@ export const primaryExpressionMethods: PrimaryExpressionMethods = {
     return result;
   },
 
+  emitYield(node: YieldExpression): string {
+    if (node.delegate) {
+      const delegate = this.emitExpression(node.expression as Expression);
+      const result = this.reg();
+      this.emit(`  ${result} = call i64 @xt_yield_star(i64 ${delegate})`);
+      return result;
+    }
+    const value = node.expression ? this.emitExpression(node.expression) : i64(XT_UNDEFINED);
+    const result = this.reg();
+    this.emit(`  ${result} = call i64 @xt_yield(i64 ${value})`);
+    return result;
+  },
+
   emitNew(node: NewExpression): string {
     const callee = node.expression;
     if (callee.kind === SyntaxKind.Identifier) {
@@ -301,4 +332,79 @@ export const primaryExpressionMethods: PrimaryExpressionMethods = {
     }
     return accumulator;
   },
+
+  /**
+   * Lower a tagged template: build the (cooked) strings array with a `.raw`
+   * sibling and call the tag with it followed by the interpolation values.
+   * `String.raw` is the one namespace tag special-cased by the runtime.
+   */
+  emitTaggedTemplate(node: TaggedTemplateExpression): string {
+    const template = node.template;
+    let cooked: string[];
+    let raw: string[];
+    let expressions: readonly Expression[];
+    if (template.kind === SyntaxKind.NoSubstitutionTemplateLiteral) {
+      cooked = [template.value];
+      raw = [template.raw ?? template.value];
+      expressions = [];
+    } else {
+      const literal = template as TemplateLiteral;
+      cooked = [literal.head, ...literal.spans.map((span) => span.literal)];
+      raw = [literal.raw ?? literal.head, ...literal.spans.map((span) => span.raw ?? span.literal)];
+      expressions = literal.spans.map((span) => span.expression);
+    }
+
+    const makeArray = (items: string[]): string => {
+      const array = this.reg();
+      this.emit(`  ${array} = call i64 @xt_array_new(i32 0, i64* null)`);
+      for (const item of items) {
+        const value = this.stringValue(item);
+        this.emit(`  call i64 @xt_array_push(i64 ${array}, i64 ${value})`);
+      }
+      return array;
+    };
+    const strings = makeArray(cooked);
+    const rawArray = makeArray(raw);
+    const rawKey = this.stringValue("raw");
+    this.emit(`  call i64 @xt_set(i64 ${strings}, i64 ${rawKey}, i64 ${rawArray})`);
+
+    const argc = String(expressions.length + 1);
+    const ptr = `%args${this.current.allocas.length}`;
+    this.current.allocas.push(`${ptr} = alloca i64, i32 ${expressions.length + 1}`);
+    const first = this.reg();
+    this.emit(`  ${first} = getelementptr i64, i64* ${ptr}, i32 0`);
+    this.emit(`  store i64 ${strings}, i64* ${first}`);
+    for (let index = 0; index < expressions.length; index++) {
+      const value = this.emitExpression(expressions[index]!);
+      const slot = this.reg();
+      this.emit(`  ${slot} = getelementptr i64, i64* ${ptr}, i32 ${index + 1}`);
+      this.emit(`  store i64 ${value}, i64* ${slot}`);
+    }
+
+    const tag = node.tag;
+    if (tag.kind === SyntaxKind.PropertyAccessExpression) {
+      const access = tag as PropertyAccessExpression;
+      const owner = access.expression;
+      if (
+        owner.kind === SyntaxKind.Identifier &&
+        (owner as Identifier).text === "String" &&
+        access.name.text === "raw" &&
+        !this.binding.symbolOfIdentifier.get(owner as Identifier)
+      ) {
+        const key = this.stringValue("raw");
+        const result = this.reg();
+        this.emit(`  ${result} = call i64 @xt_string_static(i64 ${key}, i32 ${argc}, i64* ${ptr})`);
+        return result;
+      }
+      const object = this.emitExpression(owner);
+      const name = this.stringValue(access.name.text);
+      const result = this.reg();
+      this.emit(`  ${result} = call i64 @xt_call_method(i64 ${object}, i64 ${name}, i32 ${argc}, i64* ${ptr})`);
+      return result;
+    }
+    const tagValue = this.emitExpression(tag);
+    const result = this.reg();
+    this.emit(`  ${result} = call i64 @xt_closure_call(i64 ${tagValue}, i32 ${argc}, i64* ${ptr})`);
+    return result;
+  },
 };

package/src/codegen/generator/generator.ts

@@ -18,7 +18,6 @@ import type { CodegenOptions, CodegenResult } from "./state.js";
 
 export class Generator extends GeneratorContext {}
 
-// eslint-disable-next-line @typescript-eslint/no-empty-interface
 export interface Generator extends ModuleMethods, StatementMethods, ExpressionMethods, CallMethods {}
 
 Object.assign(Generator.prototype, moduleMethods, statementMethods, expressionMethods, callMethods);