xbintsc 0.1.6 → 0.1.8

package/dist/src/codegen/llvm.js

@@ -15,1542 +15,9 @@
  *
  * Later pipeline stages (optimization passes, object emission) live in the
  * driver; this module only produces IR text.
+ *
+ * The implementation is split by function under `./generator/`; this module is
+ * the stable entry point.
  */
-import { SyntaxKind, } from "../ast/nodes.js";
-import { AssignmentOperator, BinaryOperator, PrefixUnaryOperator, PostfixUnaryOperator, } from "../ast/nodes.js";
-import { bind, SymbolKind, } from "../binder/binder.js";
-import { DiagnosticCode } from "../diagnostics/diagnostic.js";
-import { i64, numberLiteral, XT_UNDEFINED, XT_NULL, XT_FALSE, XT_TRUE } from "./values.js";
-const RUNTIME_DECLARATIONS = [
-    "declare i64 @xt_undefined()",
-    "declare i64 @xt_null()",
-    "declare i64 @xt_bool(i32)",
-    "declare i64 @xt_number(double)",
-    "declare i64 @xt_string_new(i8*, i64)",
-    "declare i64 @xt_string_from_cstr(i8*)",
-    "declare i64 @xt_arg(i32, i64*, i32)",
-    "declare i64 @xt_closure_new(i8*, i32, i64*)",
-    "declare i64 @xt_closure_call(i64, i32, i64*)",
-    "declare i64 @xt_closure_env(i64, i32)",
-    "declare i32 @xt_truthy(i64)",
-    "declare double @xt_to_number(i64)",
-    "declare i64 @xt_to_string(i64)",
-    "declare i64 @xt_typeof(i64)",
-    "declare i64 @xt_add(i64, i64)",
-    "declare i64 @xt_sub(i64, i64)",
-    "declare i64 @xt_mul(i64, i64)",
-    "declare i64 @xt_div(i64, i64)",
-    "declare i64 @xt_mod(i64, i64)",
-    "declare i64 @xt_pow(i64, i64)",
-    "declare i64 @xt_neg(i64)",
-    "declare i64 @xt_pos(i64)",
-    "declare i64 @xt_bit_and(i64, i64)",
-    "declare i64 @xt_bit_or(i64, i64)",
-    "declare i64 @xt_bit_xor(i64, i64)",
-    "declare i64 @xt_bit_not(i64)",
-    "declare i64 @xt_shl(i64, i64)",
-    "declare i64 @xt_shr(i64, i64)",
-    "declare i64 @xt_ushr(i64, i64)",
-    "declare i64 @xt_lt(i64, i64)",
-    "declare i64 @xt_le(i64, i64)",
-    "declare i64 @xt_gt(i64, i64)",
-    "declare i64 @xt_ge(i64, i64)",
-    "declare i64 @xt_eq(i64, i64)",
-    "declare i64 @xt_ne(i64, i64)",
-    "declare i64 @xt_seq(i64, i64)",
-    "declare i64 @xt_sne(i64, i64)",
-    "declare i64 @xt_not(i64)",
-    "declare i64 @xt_object_new()",
-    "declare i64 @xt_object_get_cstr(i64, i8*)",
-    "declare i64 @xt_object_set(i64, i64, i64)",
-    "declare i64 @xt_object_has(i64, i64)",
-    "declare i64 @xt_object_keys(i64)",
-    "declare i64 @xt_object_values(i64)",
-    "declare i64 @xt_object_entries(i64)",
-    "declare i64 @xt_object_assign(i32, i64*)",
-    "declare i64 @xt_object_spread(i64, i64)",
-    "declare i64 @xt_call_method(i64, i64, i32, i64*)",
-    "declare i64 @xt_math_call(i64, i32, i64*)",
-    "declare i64 @xt_parse_int(i32, i64*)",
-    "declare i64 @xt_parse_float(i32, i64*)",
-    "declare i64 @xt_is_nan(i32, i64*)",
-    "declare i64 @xt_is_finite(i32, i64*)",
-    "declare i64 @xt_number_ctor(i32, i64*)",
-    "declare i64 @xt_string_ctor(i32, i64*)",
-    "declare i64 @xt_boolean_ctor(i32, i64*)",
-    "declare i64 @xt_in(i64, i64)",
-    "declare i64 @xt_delete(i64, i64)",
-    "declare i64 @xt_rest_args(i32, i64*, i32)",
-    "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_get(i64, i64)",
-    "declare i64 @xt_set(i64, i64, i64)",
-    "declare i64 @xt_box_new(i64)",
-    "declare i64 @xt_box_get(i64)",
-    "declare i64 @xt_box_set(i64, i64)",
-    "declare i64 @xt_is_nullish(i64)",
-    "declare void @xt_throw(i64)",
-    "declare i32 @_setjmp(i8*) returns_twice",
-    "declare i8* @xt_try_enter()",
-    "declare i64 @xt_try_exception(i8*)",
-    "declare void @xt_try_leave(i8*)",
-    "declare void @xt_console_log(i32, i64*)",
-    "declare void @xt_console_info(i32, i64*)",
-    "declare void @xt_console_warn(i32, i64*)",
-    "declare void @xt_console_error(i32, i64*)",
-];
-export function generate(sourceFile, diagnostics, options = {}) {
-    const generator = new Generator(sourceFile, diagnostics, options);
-    return { ir: generator.run(), binding: generator.binding };
-}
-class Generator {
-    sourceFile;
-    diagnostics;
-    binding;
-    globals = [];
-    functions = [];
-    strings = new Map();
-    extraDeclarations = new Set();
-    builtins;
-    stringCounter = 0;
-    current;
-    constructor(sourceFile, diagnostics, options = {}) {
-        this.sourceFile = sourceFile;
-        this.diagnostics = diagnostics;
-        this.binding = bind(sourceFile);
-        this.builtins = options.builtins ?? {};
-    }
-    run() {
-        for (const fn of this.binding.functions)
-            this.emitFunction(fn);
-        this.emitMain();
-        const header = ["; ModuleID = 'xbintsc'", "source_filename = \"" + this.sourceFile.fileName + "\"", ""];
-        return [...header, ...RUNTIME_DECLARATIONS, ...this.extraDeclarations, "", ...this.globals, "", ...this.functions, ""].join("\n");
-    }
-    // -- module level --------------------------------------------------------
-    emitFunction(fn) {
-        const name = this.functionName(fn);
-        const state = {
-            fn,
-            buffer: [],
-            allocas: [],
-            slots: new Map(),
-            reg: 0,
-            label: 0,
-            terminated: false,
-            loops: [],
-            tryFrames: [],
-            escapePointers: [],
-            usesTry: false,
-        };
-        this.current = state;
-        const header = `define i64 @${name}(i64 %env, i32 %argc, i64* %argv) {`;
-        this.emit(`%saved.env = alloca i64`);
-        this.emit(`store i64 %env, i64* %saved.env`);
-        this.emit(`%saved.argc = alloca i32`);
-        this.emit(`store i32 %argc, i32* %saved.argc`);
-        this.emit(`%saved.argv = alloca i64*`);
-        this.emit(`store i64* %argv, i64** %saved.argv`);
-        // Parameters.
-        const parameterNodes = fn.node.parameters ?? [];
-        for (let index = 0; index < fn.params.length; index++) {
-            const symbol = fn.params[index];
-            const parameter = parameterNodes[index];
-            if (parameter?.dotDotDotToken) {
-                const rest = this.reg();
-                this.emit(`  ${rest} = call i64 @xt_rest_args(i32 %argc, i64* %argv, i32 ${index})`);
-                this.declareSlot(symbol, rest);
-                continue;
-            }
-            const value = this.reg();
-            this.emit(`  ${value} = call i64 @xt_arg(i32 %argc, i64* %argv, i32 ${index})`);
-            this.declareSlot(symbol, value);
-            if (parameter?.initializer)
-                this.emitDefaultParameter(symbol, value, parameter.initializer);
-        }
-        // Captures threaded through the environment.
-        for (const symbol of fn.captures) {
-            const index = fn.captureIndex.get(symbol.id);
-            const value = this.reg();
-            this.emit(`  ${value} = call i64 @xt_closure_env(i64 %env, i32 ${index})`);
-            this.defineCaptureSlot(symbol, value);
-        }
-        // Body.
-        if (fn.node.kind === SyntaxKind.SourceFile) {
-            this.emitStatements(this.sourceFile.statements);
-        }
-        else if (fn.node.kind === SyntaxKind.ArrowFunction && fn.node.body.kind !== SyntaxKind.Block) {
-            const value = this.emitExpression(fn.node.body);
-            this.terminate(`ret i64 ${value}`);
-        }
-        else {
-            const body = fn.node.body;
-            this.emitStatements(body.statements);
-        }
-        if (!this.current.terminated)
-            this.terminate(`ret i64 ${i64(XT_UNDEFINED)}`);
-        const escapes = state.usesTry
-            ? state.escapePointers.map((ptr) => `  call void asm sideeffect "", "r"(i64* ${ptr})`)
-            : [];
-        const lines = [...state.allocas.map((a) => `  ${a}`), ...escapes, ...state.buffer];
-        this.functions.push([header, ...lines, "}", ""].join("\n"));
-    }
-    emitMain() {
-        const moduleName = this.functionName(this.binding.moduleFunction);
-        this.functions.push([
-            "define i32 @main(i32 %argc, i8** %argv) {",
-            `  %result = call i64 @${moduleName}(i64 ${i64(XT_UNDEFINED)}, i32 0, i64* null)`,
-            "  ret i32 0",
-            "}",
-            "",
-        ].join("\n"));
-    }
-    functionName(fn) {
-        return fn.isModule ? "xt_module" : `xt_fn_${fn.id}`;
-    }
-    // -- emission primitives -------------------------------------------------
-    emit(line) {
-        this.current.buffer.push(line);
-    }
-    terminate(line) {
-        this.current.buffer.push(`  ${line}`);
-        this.current.terminated = true;
-    }
-    reg() {
-        return `%r${this.current.reg++}`;
-    }
-    label(prefix) {
-        return `${prefix}.${this.current.label++}`;
-    }
-    startBlock(label) {
-        this.current.buffer.push(`${label}:`);
-        this.current.terminated = false;
-    }
-    alloca() {
-        const ptr = `%slot${this.current.allocas.length}`;
-        this.current.allocas.push(`${ptr} = alloca i64`);
-        this.current.escapePointers.push(ptr);
-        return ptr;
-    }
-    const(hex) {
-        return i64(hex);
-    }
-    // -- variables -----------------------------------------------------------
-    declareSlot(symbol, initial) {
-        const ptr = this.alloca();
-        if (symbol.boxed) {
-            const box = this.reg();
-            this.emit(`  ${box} = call i64 @xt_box_new(i64 ${initial})`);
-            this.emit(`  store i64 ${box}, i64* ${ptr}`);
-        }
-        else {
-            this.emit(`  store i64 ${initial}, i64* ${ptr}`);
-        }
-        this.current.slots.set(symbol.id, { ptr, boxed: symbol.boxed });
-    }
-    defineCaptureSlot(symbol, box) {
-        const ptr = this.alloca();
-        this.emit(`  store i64 ${box}, i64* ${ptr}`);
-        // A captured symbol is always boxed; the environment holds the box.
-        this.current.slots.set(symbol.id, { ptr, boxed: true });
-    }
-    readSlot(symbol) {
-        const slot = this.current.slots.get(symbol.id);
-        if (!slot) {
-            // Referenced from an inner function without a capture slot: this should
-            // be impossible once the binder has run, but stay defensive.
-            this.diagnostics.error(DiagnosticCode.CodegenError, `Internal: no slot for '${symbol.name}' in ${this.current.fn.name}`);
-            return i64(XT_UNDEFINED);
-        }
-        const value = this.reg();
-        this.emit(`  ${value} = load i64, i64* ${slot.ptr}`);
-        if (!slot.boxed)
-            return value;
-        const unboxed = this.reg();
-        this.emit(`  ${unboxed} = call i64 @xt_box_get(i64 ${value})`);
-        return unboxed;
-    }
-    writeSlot(symbol, value) {
-        const slot = this.current.slots.get(symbol.id);
-        if (!slot) {
-            this.diagnostics.error(DiagnosticCode.CodegenError, `Internal: no slot for '${symbol.name}'`);
-            return;
-        }
-        if (!slot.boxed) {
-            this.emit(`  store i64 ${value}, i64* ${slot.ptr}`);
-            return;
-        }
-        const box = this.reg();
-        this.emit(`  ${box} = load i64, i64* ${slot.ptr}`);
-        this.emit(`  call i64 @xt_box_set(i64 ${box}, i64 ${value})`);
-    }
-    emitDefaultParameter(symbol, value, initializer) {
-        const isUndefined = this.reg();
-        this.emit(`  ${isUndefined} = call i64 @xt_seq(i64 ${value}, i64 ${i64(XT_UNDEFINED)})`);
-        const truthy = this.reg();
-        this.emit(`  ${truthy} = call i32 @xt_truthy(i64 ${isUndefined})`);
-        const condition = this.reg();
-        this.emit(`  ${condition} = icmp ne i32 ${truthy}, 0`);
-        const applyLabel = this.label("param.default");
-        const endLabel = this.label("param.end");
-        this.terminate(`br i1 ${condition}, label %${applyLabel}, label %${endLabel}`);
-        this.startBlock(applyLabel);
-        const fallback = this.emitExpression(initializer);
-        this.writeSlot(symbol, fallback);
-        this.terminate(`br label %${endLabel}`);
-        this.startBlock(endLabel);
-    }
-    // -- statements ----------------------------------------------------------
-    emitStatements(statements) {
-        for (const statement of statements) {
-            if (this.current.terminated)
-                break;
-            this.emitStatement(statement);
-        }
-    }
-    emitStatement(statement) {
-        switch (statement.kind) {
-            case SyntaxKind.ExpressionStatement:
-                this.emitExpression(statement.expression);
-                return;
-            case SyntaxKind.VariableStatement:
-                this.emitVariableStatement(statement);
-                return;
-            case SyntaxKind.Block:
-                this.emitStatements(statement.statements);
-                return;
-            case SyntaxKind.EmptyStatement:
-            case SyntaxKind.DebuggerStatement:
-            case SyntaxKind.FunctionDeclaration:
-            case SyntaxKind.InterfaceDeclaration:
-            case SyntaxKind.TypeAliasDeclaration:
-                return; // functions are emitted at module scope
-            case SyntaxKind.IfStatement:
-                this.emitIf(statement);
-                return;
-            case SyntaxKind.WhileStatement:
-                this.emitWhile(statement);
-                return;
-            case SyntaxKind.DoStatement:
-                this.emitDo(statement);
-                return;
-            case SyntaxKind.ForStatement:
-                this.emitFor(statement);
-                return;
-            case SyntaxKind.ForOfStatement:
-            case SyntaxKind.ForInStatement:
-                this.emitForOf(statement);
-                return;
-            case SyntaxKind.SwitchStatement:
-                this.emitSwitch(statement);
-                return;
-            case SyntaxKind.TryStatement:
-                this.emitTry(statement);
-                return;
-            case SyntaxKind.ReturnStatement:
-                this.emitReturn(statement);
-                return;
-            case SyntaxKind.BreakStatement: {
-                const loop = this.current.loops[this.current.loops.length - 1];
-                if (loop) {
-                    this.popTryFramesTo(loop.tryDepth ?? 0);
-                    this.terminate(`br label %${loop.breakLabel}`);
-                }
-                return;
-            }
-            case SyntaxKind.ContinueStatement: {
-                const loop = this.current.loops[this.current.loops.length - 1];
-                if (loop) {
-                    this.popTryFramesTo(loop.tryDepth ?? 0);
-                    this.terminate(`br label %${loop.continueLabel}`);
-                }
-                return;
-            }
-            case SyntaxKind.ThrowStatement: {
-                const value = this.emitExpression(statement.expression);
-                this.emit(`  call void @xt_throw(i64 ${value})`);
-                this.terminate("unreachable");
-                return;
-            }
-            case SyntaxKind.ExportDeclaration: {
-                const declaration = statement.declaration;
-                if (declaration)
-                    this.emitStatement(declaration);
-                return;
-            }
-            default:
-                this.unsupported(statement, "statement");
-        }
-    }
-    emitVariableStatement(statement) {
-        for (const declaration of statement.declarationList.declarations) {
-            const symbol = this.binding.symbolOfDeclaration.get(declaration);
-            if (!symbol)
-                continue;
-            if (this.current.slots.has(symbol.id))
-                continue; // hoisted `var`
-            const initial = declaration.initializer
-                ? this.emitExpression(declaration.initializer)
-                : i64(XT_UNDEFINED);
-            this.declareSlot(symbol, initial);
-        }
-    }
-    emitIf(statement) {
-        const thenLabel = this.label("if.then");
-        const elseLabel = statement.elseStatement ? this.label("if.else") : undefined;
-        const endLabel = this.label("if.end");
-        const condition = this.emitExpression(statement.condition);
-        const truthy = this.reg();
-        this.emit(`  ${truthy} = call i32 @xt_truthy(i64 ${condition})`);
-        const nonzero = this.reg();
-        this.emit(`  ${nonzero} = icmp ne i32 ${truthy}, 0`);
-        this.terminate(`br i1 ${nonzero}, label %${thenLabel}, label %${elseLabel ?? endLabel}`);
-        this.startBlock(thenLabel);
-        this.emitStatement(statement.thenStatement);
-        if (!this.current.terminated)
-            this.terminate(`br label %${endLabel}`);
-        if (elseLabel) {
-            this.startBlock(elseLabel);
-            this.emitStatement(statement.elseStatement);
-            if (!this.current.terminated)
-                this.terminate(`br label %${endLabel}`);
-        }
-        this.startBlock(endLabel);
-    }
-    emitWhile(statement) {
-        const condLabel = this.label("while.cond");
-        const bodyLabel = this.label("while.body");
-        const endLabel = this.label("while.end");
-        this.terminate(`br label %${condLabel}`);
-        this.startBlock(condLabel);
-        const condition = this.emitExpression(statement.condition);
-        const truthy = this.reg();
-        this.emit(`  ${truthy} = call i32 @xt_truthy(i64 ${condition})`);
-        const nonzero = this.reg();
-        this.emit(`  ${nonzero} = icmp ne i32 ${truthy}, 0`);
-        this.terminate(`br i1 ${nonzero}, label %${bodyLabel}, label %${endLabel}`);
-        this.startBlock(bodyLabel);
-        this.current.loops.push({ breakLabel: endLabel, continueLabel: condLabel, tryDepth: this.current.tryFrames.length });
-        this.emitStatement(statement.statement);
-        this.current.loops.pop();
-        if (!this.current.terminated)
-            this.terminate(`br label %${condLabel}`);
-        this.startBlock(endLabel);
-    }
-    emitDo(statement) {
-        const bodyLabel = this.label("do.body");
-        const condLabel = this.label("do.cond");
-        const endLabel = this.label("do.end");
-        this.terminate(`br label %${bodyLabel}`);
-        this.startBlock(bodyLabel);
-        this.current.loops.push({ breakLabel: endLabel, continueLabel: condLabel, tryDepth: this.current.tryFrames.length });
-        this.emitStatement(statement.statement);
-        this.current.loops.pop();
-        if (!this.current.terminated)
-            this.terminate(`br label %${condLabel}`);
-        this.startBlock(condLabel);
-        const condition = this.emitExpression(statement.condition);
-        const truthy = this.reg();
-        this.emit(`  ${truthy} = call i32 @xt_truthy(i64 ${condition})`);
-        const nonzero = this.reg();
-        this.emit(`  ${nonzero} = icmp ne i32 ${truthy}, 0`);
-        this.terminate(`br i1 ${nonzero}, label %${bodyLabel}, label %${endLabel}`);
-        this.startBlock(endLabel);
-    }
-    emitFor(statement) {
-        if (statement.initializer && statement.initializer.kind === SyntaxKind.VariableDeclarationList) {
-            this.emitVariableStatement({
-                kind: SyntaxKind.VariableStatement,
-                declarationList: statement.initializer,
-                modifiers: [],
-                start: statement.initializer.start,
-                end: statement.initializer.end,
-            });
-        }
-        else if (statement.initializer) {
-            this.emitExpression(statement.initializer);
-        }
-        const condLabel = this.label("for.cond");
-        const bodyLabel = this.label("for.body");
-        const updateLabel = this.label("for.update");
-        const endLabel = this.label("for.end");
-        this.terminate(`br label %${condLabel}`);
-        this.startBlock(condLabel);
-        if (statement.condition) {
-            const condition = this.emitExpression(statement.condition);
-            const truthy = this.reg();
-            this.emit(`  ${truthy} = call i32 @xt_truthy(i64 ${condition})`);
-            const nonzero = this.reg();
-            this.emit(`  ${nonzero} = icmp ne i32 ${truthy}, 0`);
-            this.terminate(`br i1 ${nonzero}, label %${bodyLabel}, label %${endLabel}`);
-        }
-        else {
-            this.terminate(`br label %${bodyLabel}`);
-        }
-        this.startBlock(bodyLabel);
-        this.current.loops.push({ breakLabel: endLabel, continueLabel: updateLabel, tryDepth: this.current.tryFrames.length });
-        this.emitStatement(statement.statement);
-        this.current.loops.pop();
-        if (!this.current.terminated)
-            this.terminate(`br label %${updateLabel}`);
-        this.startBlock(updateLabel);
-        if (statement.incrementor)
-            this.emitExpression(statement.incrementor);
-        this.terminate(`br label %${condLabel}`);
-        this.startBlock(endLabel);
-    }
-    /** `for (const x of xs)` / `for (const k in obj)` over arrays, strings and objects. */
-    emitForOf(statement) {
-        const source = this.emitExpression(statement.expression);
-        const isForIn = statement.kind === SyntaxKind.ForInStatement;
-        // `for...in` iterates the enumerable keys (indices become strings);
-        // `for...of` iterates the values at each index.
-        const iterable = isForIn ? this.runtimeCall("xt_object_keys", [source]) : source;
-        const indexPtr = this.alloca();
-        this.emit(`  store i64 ${numberLiteral(0)}, i64* ${indexPtr}`);
-        const lengthValue = this.reg();
-        this.emit(`  ${lengthValue} = call i64 @xt_array_length(i64 ${iterable})`);
-        const condLabel = this.label("forof.cond");
-        const bodyLabel = this.label("forof.body");
-        const updateLabel = this.label("forof.update");
-        const endLabel = this.label("forof.end");
-        this.terminate(`br label %${condLabel}`);
-        this.startBlock(condLabel);
-        const index = this.reg();
-        this.emit(`  ${index} = load i64, i64* ${indexPtr}`);
-        const inRange = this.reg();
-        this.emit(`  ${inRange} = call i64 @xt_lt(i64 ${index}, i64 ${lengthValue})`);
-        const truthy = this.reg();
-        this.emit(`  ${truthy} = call i32 @xt_truthy(i64 ${inRange})`);
-        const nonzero = this.reg();
-        this.emit(`  ${nonzero} = icmp ne i32 ${truthy}, 0`);
-        this.terminate(`br i1 ${nonzero}, label %${bodyLabel}, label %${endLabel}`);
-        this.startBlock(bodyLabel);
-        const element = this.reg();
-        this.emit(`  ${element} = call i64 @xt_get(i64 ${iterable}, i64 ${index})`);
-        this.bindLoopVariable(statement.initializer, element);
-        this.current.loops.push({ breakLabel: endLabel, continueLabel: updateLabel, tryDepth: this.current.tryFrames.length });
-        this.emitStatement(statement.statement);
-        this.current.loops.pop();
-        if (!this.current.terminated)
-            this.terminate(`br label %${updateLabel}`);
-        this.startBlock(updateLabel);
-        const next = this.reg();
-        this.emit(`  ${next} = call i64 @xt_add(i64 ${index}, i64 ${numberLiteral(1)})`);
-        this.emit(`  store i64 ${next}, i64* ${indexPtr}`);
-        this.terminate(`br label %${condLabel}`);
-        this.startBlock(endLabel);
-    }
-    bindLoopVariable(initializer, value) {
-        if (initializer.kind === SyntaxKind.VariableDeclarationList) {
-            const declaration = initializer.declarations[0];
-            if (!declaration)
-                return;
-            const symbol = this.binding.symbolOfDeclaration.get(declaration);
-            if (symbol) {
-                if (this.current.slots.has(symbol.id))
-                    this.writeSlot(symbol, value);
-                else
-                    this.declareSlot(symbol, value);
-            }
-            return;
-        }
-        this.emitAssignmentTarget(initializer, value);
-    }
-    /**
-     * JavaScript `switch`: test each `case` with strict equality, then run the
-     * matched clause and fall through into the following clauses until `break`.
-     */
-    emitSwitch(statement) {
-        const discriminant = this.emitExpression(statement.expression);
-        const endLabel = this.label("switch.end");
-        const clauses = statement.clauses;
-        const labels = clauses.map(() => this.label("switch.case"));
-        const testLabels = clauses.map((clause) => clause.kind === SyntaxKind.CaseClause ? this.label("switch.test") : undefined);
-        const defaultIndex = clauses.findIndex((clause) => clause.kind === SyntaxKind.DefaultClause);
-        const defaultLabel = defaultIndex >= 0 ? labels[defaultIndex] : endLabel;
-        const caseIndexes = clauses
-            .map((clause, index) => ({ clause, index }))
-            .filter((entry) => entry.clause.kind === SyntaxKind.CaseClause);
-        this.terminate(`br label %${caseIndexes.length > 0 ? testLabels[caseIndexes[0].index] : defaultLabel}`);
-        for (let test = 0; test < caseIndexes.length; test++) {
-            const entry = caseIndexes[test];
-            this.startBlock(testLabels[entry.index]);
-            const caseValue = this.emitExpression(entry.clause.expression);
-            const equals = this.reg();
-            this.emit(`  ${equals} = call i64 @xt_seq(i64 ${discriminant}, i64 ${caseValue})`);
-            const truthy = this.reg();
-            this.emit(`  ${truthy} = call i32 @xt_truthy(i64 ${equals})`);
-            const condition = this.reg();
-            this.emit(`  ${condition} = icmp ne i32 ${truthy}, 0`);
-            const next = test + 1 < caseIndexes.length ? testLabels[caseIndexes[test + 1].index] : defaultLabel;
-            this.terminate(`br i1 ${condition}, label %${labels[entry.index]}, label %${next}`);
-        }
-        for (let index = 0; index < clauses.length; index++) {
-            this.startBlock(labels[index]);
-            const enclosing = this.current.loops[this.current.loops.length - 1];
-            this.current.loops.push({ breakLabel: endLabel, continueLabel: enclosing?.continueLabel ?? endLabel, tryDepth: this.current.tryFrames.length });
-            for (const child of clauses[index].statements) {
-                if (this.current.terminated)
-                    break;
-                this.emitStatement(child);
-            }
-            this.current.loops.pop();
-            if (!this.current.terminated) {
-                const next = index + 1 < clauses.length ? labels[index + 1] : endLabel;
-                this.terminate(`br label %${next}`);
-            }
-        }
-        this.startBlock(endLabel);
-    }
-    /**
-     * `try`/`catch`/`finally` via a runtime setjmp frame. The runtime keeps a
-     * stack of frames; `xt_throw` longjmps into the innermost one. A `return`
-     * that exits the protected region skips `finally` (a known limitation).
-     */
-    emitTry(statement) {
-        this.current.usesTry = true;
-        const frameSlot = this.alloca();
-        const exceptionSlot = this.alloca();
-        const flagSlot = this.alloca();
-        const tryLabel = this.label("try.body");
-        const catchLabel = this.label("try.catch");
-        const exceptionLabel = this.label("try.exception");
-        const rethrowLabel = this.label("try.rethrow");
-        const finallyLabel = statement.finallyBlock ? this.label("try.finally") : undefined;
-        const endLabel = this.label("try.end");
-        const hasCatch = !!statement.catchClause;
-        const frame = this.reg();
-        this.emit(`  ${frame} = call i8* @xt_try_enter()`);
-        this.emit(`  store i8* ${frame}, i8** ${frameSlot}`);
-        this.emit(`  store i64 0, i64* ${flagSlot}`);
-        const jump = this.reg();
-        this.emit(`  ${jump} = call i32 @_setjmp(i8* ${frame})`);
-        const isThrow = this.reg();
-        this.emit(`  ${isThrow} = icmp ne i32 ${jump}, 0`);
-        const exceptionTarget = hasCatch ? catchLabel : exceptionLabel;
-        this.terminate(`br i1 ${isThrow}, label %${exceptionTarget}, label %${tryLabel}`);
-        // Normal completion of the try block.
-        this.startBlock(tryLabel);
-        this.current.tryFrames.push(frameSlot);
-        this.emitStatements(statement.tryBlock.statements);
-        this.current.tryFrames.pop();
-        if (!this.current.terminated) {
-            const currentFrame = this.reg();
-            this.emit(`  ${currentFrame} = load i8*, i8** ${frameSlot}`);
-            this.emit(`  call void @xt_try_leave(i8* ${currentFrame})`);
-            this.terminate(`br label %${finallyLabel ?? endLabel}`);
-        }
-        if (hasCatch) {
-            this.startBlock(catchLabel);
-            const currentFrame = this.reg();
-            this.emit(`  ${currentFrame} = load i8*, i8** ${frameSlot}`);
-            const exception = this.reg();
-            this.emit(`  ${exception} = call i64 @xt_try_exception(i8* ${currentFrame})`);
-            this.emit(`  call void @xt_try_leave(i8* ${currentFrame})`);
-            this.bindCatchVariable(statement.catchClause.variable, exception);
-            this.emitStatements(statement.catchClause.block.statements);
-            if (!this.current.terminated)
-                this.terminate(`br label %${finallyLabel ?? endLabel}`);
-        }
-        else {
-            // Without a catch clause the exception is remembered, then rethrown
-            // after `finally` runs.
-            this.startBlock(exceptionLabel);
-            const currentFrame = this.reg();
-            this.emit(`  ${currentFrame} = load i8*, i8** ${frameSlot}`);
-            const exception = this.reg();
-            this.emit(`  ${exception} = call i64 @xt_try_exception(i8* ${currentFrame})`);
-            this.emit(`  call void @xt_try_leave(i8* ${currentFrame})`);
-            this.emit(`  store i64 ${exception}, i64* ${exceptionSlot}`);
-            this.emit(`  store i64 1, i64* ${flagSlot}`);
-            this.terminate(`br label %${finallyLabel ?? rethrowLabel}`);
-        }
-        if (finallyLabel) {
-            this.startBlock(finallyLabel);
-            this.emitStatements(statement.finallyBlock.statements);
-            if (!this.current.terminated) {
-                if (hasCatch) {
-                    this.terminate(`br label %${endLabel}`);
-                }
-                else {
-                    const flag = this.reg();
-                    this.emit(`  ${flag} = load i64, i64* ${flagSlot}`);
-                    const truthy = this.reg();
-                    this.emit(`  ${truthy} = call i32 @xt_truthy(i64 ${flag})`);
-                    const shouldRethrow = this.reg();
-                    this.emit(`  ${shouldRethrow} = icmp ne i32 ${truthy}, 0`);
-                    this.terminate(`br i1 ${shouldRethrow}, label %${rethrowLabel}, label %${endLabel}`);
-                }
-            }
-        }
-        if (!hasCatch) {
-            this.startBlock(rethrowLabel);
-            const exception = this.reg();
-            this.emit(`  ${exception} = load i64, i64* ${exceptionSlot}`);
-            this.emit(`  call void @xt_throw(i64 ${exception})`);
-            this.terminate("unreachable");
-        }
-        this.startBlock(endLabel);
-    }
-    bindCatchVariable(variable, value) {
-        if (!variable)
-            return;
-        const symbol = this.binding.symbolOfDeclaration.get(variable);
-        if (!symbol)
-            return;
-        if (this.current.slots.has(symbol.id))
-            this.writeSlot(symbol, value);
-        else
-            this.declareSlot(symbol, value);
-    }
-    emitReturn(statement) {
-        const value = statement.expression ? this.emitExpression(statement.expression) : i64(XT_UNDEFINED);
-        this.popTryFramesTo(0);
-        this.terminate(`ret i64 ${value}`);
-    }
-    /** Emit `xt_try_leave` for every active frame above `depth` (innermost first). */
-    popTryFramesTo(depth) {
-        for (let index = this.current.tryFrames.length - 1; index >= depth; index--) {
-            const slot = this.current.tryFrames[index];
-            const frame = this.reg();
-            this.emit(`  ${frame} = load i8*, i8** ${slot}`);
-            this.emit(`  call void @xt_try_leave(i8* ${frame})`);
-        }
-    }
-    // -- expressions ---------------------------------------------------------
-    emitExpression(node) {
-        switch (node.kind) {
-            case SyntaxKind.Identifier:
-                return this.emitIdentifier(node);
-            case SyntaxKind.NumericLiteral: {
-                const value = node.value;
-                return numberLiteral(value);
-            }
-            case SyntaxKind.BigIntLiteral:
-                return numberLiteral(Number(node.value));
-            case SyntaxKind.StringLiteral:
-                return this.stringValue(node.value);
-            case SyntaxKind.NoSubstitutionTemplateLiteral:
-                return this.stringValue(node.value);
-            case SyntaxKind.TemplateLiteral:
-                return this.emitTemplate(node);
-            case SyntaxKind.TrueKeyword:
-                return i64(XT_TRUE);
-            case SyntaxKind.FalseKeyword:
-                return i64(XT_FALSE);
-            case SyntaxKind.NullKeyword:
-                return i64(XT_NULL);
-            case SyntaxKind.UndefinedKeyword:
-                return i64(XT_UNDEFINED);
-            case SyntaxKind.ParenthesizedExpression:
-                return this.emitExpression(node.expression);
-            case SyntaxKind.AsExpression:
-            case SyntaxKind.SatisfiesExpression:
-            case SyntaxKind.NonNullExpression:
-                return this.emitExpression(node.expression);
-            case SyntaxKind.DeleteExpression:
-                return this.emitDelete(node);
-            case SyntaxKind.BinaryExpression:
-                return this.emitBinaryOrAssignment(node);
-            case SyntaxKind.PrefixUnaryExpression:
-                return this.emitPrefix(node);
-            case SyntaxKind.PostfixUnaryExpression:
-                return this.emitPostfix(node);
-            case SyntaxKind.ConditionalExpression:
-                return this.emitConditional(node);
-            case SyntaxKind.CallExpression:
-                return this.emitCall(node);
-            case SyntaxKind.PropertyAccessExpression:
-                return this.emitPropertyAccess(node);
-            case SyntaxKind.ElementAccessExpression:
-                return this.emitElementAccess(node);
-            case SyntaxKind.ArrayLiteralExpression:
-                return this.emitArrayLiteral(node);
-            case SyntaxKind.ObjectLiteralExpression:
-                return this.emitObjectLiteral(node);
-            case SyntaxKind.ArrowFunction:
-            case SyntaxKind.FunctionExpression:
-                return this.emitClosure(node);
-            default:
-                this.unsupported(node, "expression");
-                return i64(XT_UNDEFINED);
-        }
-    }
-    emitIdentifier(identifier) {
-        const symbol = this.binding.symbolOfIdentifier.get(identifier);
-        if (symbol) {
-            if (symbol.kind === SymbolKind.Function && !this.current.slots.has(symbol.id)) {
-                return this.emitFunctionValue(symbol);
-            }
-            return this.readSlot(symbol);
-        }
-        switch (identifier.text) {
-            case "undefined":
-                return i64(XT_UNDEFINED);
-            case "NaN":
-                return numberLiteral(NaN);
-            case "Infinity":
-                return numberLiteral(Infinity);
-            case "console":
-                return i64(XT_UNDEFINED);
-            case "arguments": {
-                const argc = this.reg();
-                this.emit(`  ${argc} = load i32, i32* %saved.argc`);
-                const argv = this.reg();
-                this.emit(`  ${argv} = load i64*, i64** %saved.argv`);
-                const rest = this.reg();
-                this.emit(`  ${rest} = call i64 @xt_rest_args(i32 ${argc}, i64* ${argv}, i32 0)`);
-                return rest;
-            }
-            default:
-                this.diagnostics.error(DiagnosticCode.CannotFindName, `Cannot find name '${identifier.text}'`, identifier, this.sourceFile.fileName);
-                return i64(XT_UNDEFINED);
-        }
-    }
-    emitFunctionValue(symbol) {
-        const declaration = symbol.declarations[0];
-        const fn = declaration ? this.binding.functionOfNode.get(declaration) : undefined;
-        if (!fn)
-            return i64(XT_UNDEFINED);
-        const cast = this.reg();
-        this.emit(`  ${cast} = bitcast 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)`);
-        return closure;
-    }
-    emitTemplate(node) {
-        let accumulator = this.stringValue(node.head);
-        for (const span of node.spans) {
-            const expression = this.emitExpression(span.expression);
-            const text = this.reg();
-            this.emit(`  ${text} = call i64 @xt_to_string(i64 ${expression})`);
-            const joined = this.reg();
-            this.emit(`  ${joined} = call i64 @xt_add(i64 ${accumulator}, i64 ${text})`);
-            accumulator = joined;
-            if (span.literal.length > 0) {
-                const literal = this.stringValue(span.literal);
-                const withLiteral = this.reg();
-                this.emit(`  ${withLiteral} = call i64 @xt_add(i64 ${accumulator}, i64 ${literal})`);
-                accumulator = withLiteral;
-            }
-        }
-        return accumulator;
-    }
-    emitBinaryOrAssignment(node) {
-        const operator = node.operator;
-        if (isAssignmentOperator(operator)) {
-            return this.emitAssignment(node);
-        }
-        switch (operator) {
-            case BinaryOperator.AmpersandAmpersand:
-                return this.emitShortCircuit(node, "and");
-            case BinaryOperator.BarBar:
-                return this.emitShortCircuit(node, "or");
-            case BinaryOperator.QuestionQuestion:
-                return this.emitShortCircuit(node, "nullish");
-            case BinaryOperator.Comma: {
-                this.emitExpression(node.left);
-                return this.emitExpression(node.right);
-            }
-            default:
-                break;
-        }
-        const left = this.emitExpression(node.left);
-        const right = this.emitExpression(node.right);
-        const runtime = BINARY_RUNTIME[operator];
-        if (!runtime) {
-            this.unsupported(node, `operator '${operator}'`);
-            return i64(XT_UNDEFINED);
-        }
-        const result = this.reg();
-        this.emit(`  ${result} = call i64 @${runtime}(i64 ${left}, i64 ${right})`);
-        return result;
-    }
-    emitShortCircuit(node, kind) {
-        const result = this.alloca();
-        const left = this.emitExpression(node.left);
-        this.emit(`  store i64 ${left}, i64* ${result}`);
-        const rightLabel = this.label("sc.right");
-        const endLabel = this.label("sc.end");
-        let condition;
-        if (kind === "and") {
-            const truthy = this.reg();
-            this.emit(`  ${truthy} = call i32 @xt_truthy(i64 ${left})`);
-            condition = this.reg();
-            this.emit(`  ${condition} = icmp ne i32 ${truthy}, 0`);
-        }
-        else if (kind === "or") {
-            const truthy = this.reg();
-            this.emit(`  ${truthy} = call i32 @xt_truthy(i64 ${left})`);
-            const isTruthy = this.reg();
-            this.emit(`  ${isTruthy} = icmp ne i32 ${truthy}, 0`);
-            condition = this.reg();
-            this.emit(`  ${condition} = xor i1 ${isTruthy}, true`);
-        }
-        else {
-            const nullish = this.reg();
-            this.emit(`  ${nullish} = call i64 @xt_is_nullish(i64 ${left})`);
-            const truthy = this.reg();
-            this.emit(`  ${truthy} = call i32 @xt_truthy(i64 ${nullish})`);
-            condition = this.reg();
-            this.emit(`  ${condition} = icmp ne i32 ${truthy}, 0`);
-        }
-        this.terminate(`br i1 ${condition}, label %${rightLabel}, label %${endLabel}`);
-        this.startBlock(rightLabel);
-        const right = this.emitExpression(node.right);
-        this.emit(`  store i64 ${right}, i64* ${result}`);
-        this.terminate(`br label %${endLabel}`);
-        this.startBlock(endLabel);
-        const value = this.reg();
-        this.emit(`  ${value} = load i64, i64* ${result}`);
-        return value;
-    }
-    emitConditional(node) {
-        const result = this.alloca();
-        const condition = this.emitExpression(node.condition);
-        const truthy = this.reg();
-        this.emit(`  ${truthy} = call i32 @xt_truthy(i64 ${condition})`);
-        const nonzero = this.reg();
-        this.emit(`  ${nonzero} = icmp ne i32 ${truthy}, 0`);
-        const trueLabel = this.label("cond.true");
-        const falseLabel = this.label("cond.false");
-        const endLabel = this.label("cond.end");
-        this.terminate(`br i1 ${nonzero}, label %${trueLabel}, label %${falseLabel}`);
-        this.startBlock(trueLabel);
-        const whenTrue = this.emitExpression(node.whenTrue);
-        this.emit(`  store i64 ${whenTrue}, i64* ${result}`);
-        this.terminate(`br label %${endLabel}`);
-        this.startBlock(falseLabel);
-        const whenFalse = this.emitExpression(node.whenFalse);
-        this.emit(`  store i64 ${whenFalse}, i64* ${result}`);
-        this.terminate(`br label %${endLabel}`);
-        this.startBlock(endLabel);
-        const value = this.reg();
-        this.emit(`  ${value} = load i64, i64* ${result}`);
-        return value;
-    }
-    emitPrefix(node) {
-        switch (node.operator) {
-            case PrefixUnaryOperator.Minus: {
-                const operand = this.emitExpression(node.operand);
-                const result = this.reg();
-                this.emit(`  ${result} = call i64 @xt_neg(i64 ${operand})`);
-                return result;
-            }
-            case PrefixUnaryOperator.Plus: {
-                const operand = this.emitExpression(node.operand);
-                const result = this.reg();
-                this.emit(`  ${result} = call i64 @xt_pos(i64 ${operand})`);
-                return result;
-            }
-            case PrefixUnaryOperator.Exclamation: {
-                const operand = this.emitExpression(node.operand);
-                const result = this.reg();
-                this.emit(`  ${result} = call i64 @xt_not(i64 ${operand})`);
-                return result;
-            }
-            case PrefixUnaryOperator.Tilde: {
-                const operand = this.emitExpression(node.operand);
-                const result = this.reg();
-                this.emit(`  ${result} = call i64 @xt_bit_not(i64 ${operand})`);
-                return result;
-            }
-            case PrefixUnaryOperator.TypeOf: {
-                const operand = this.emitExpression(node.operand);
-                const result = this.reg();
-                this.emit(`  ${result} = call i64 @xt_typeof(i64 ${operand})`);
-                return result;
-            }
-            case PrefixUnaryOperator.Void:
-                if (node.operand)
-                    this.emitExpression(node.operand);
-                return i64(XT_UNDEFINED);
-            case PrefixUnaryOperator.PlusPlus:
-            case PrefixUnaryOperator.MinusMinus: {
-                const one = numberLiteral(1);
-                const current = this.emitExpression(node.operand);
-                const fn = node.operator === PrefixUnaryOperator.PlusPlus ? "xt_add" : "xt_sub";
-                const next = this.reg();
-                this.emit(`  ${next} = call i64 @${fn}(i64 ${current}, i64 ${one})`);
-                this.emitAssignmentTarget(node.operand, next);
-                return next;
-            }
-            default:
-                this.unsupported(node, `unary operator '${node.operator}'`);
-                return i64(XT_UNDEFINED);
-        }
-    }
-    emitPostfix(node) {
-        const one = numberLiteral(1);
-        const current = this.emitExpression(node.operand);
-        const fn = node.operator === PostfixUnaryOperator.PlusPlus ? "xt_add" : "xt_sub";
-        const next = this.reg();
-        this.emit(`  ${next} = call i64 @${fn}(i64 ${current}, i64 ${one})`);
-        this.emitAssignmentTarget(node.operand, next);
-        return current;
-    }
-    emitAssignment(node) {
-        const operator = node.operator;
-        const target = node.left;
-        let value;
-        if (operator === AssignmentOperator.Assign) {
-            value = this.emitExpression(node.right);
-        }
-        else if (operator === AssignmentOperator.AmpersandAmpersandAssign ||
-            operator === AssignmentOperator.BarBarAssign ||
-            operator === AssignmentOperator.QuestionQuestionAssign) {
-            value = this.emitLogicalAssignment(node);
-        }
-        else {
-            const current = this.emitExpression(target);
-            const right = this.emitExpression(node.right);
-            const binaryOperator = compoundToBinary(operator);
-            const runtime = BINARY_RUNTIME[binaryOperator];
-            if (!runtime) {
-                this.unsupported(node, `assignment operator '${operator}'`);
-                return i64(XT_UNDEFINED);
-            }
-            const result = this.reg();
-            this.emit(`  ${result} = call i64 @${runtime}(i64 ${current}, i64 ${right})`);
-            value = result;
-        }
-        this.emitAssignmentTarget(target, value);
-        return value;
-    }
-    emitLogicalAssignment(node) {
-        const operator = node.operator;
-        const target = node.left;
-        const current = this.emitExpression(target);
-        const result = this.alloca();
-        this.emit(`  store i64 ${current}, i64* ${result}`);
-        const rightLabel = this.label("assign.right");
-        const endLabel = this.label("assign.end");
-        let condition;
-        if (operator === AssignmentOperator.AmpersandAmpersandAssign) {
-            const truthy = this.reg();
-            this.emit(`  ${truthy} = call i32 @xt_truthy(i64 ${current})`);
-            condition = this.reg();
-            this.emit(`  ${condition} = icmp ne i32 ${truthy}, 0`);
-        }
-        else if (operator === AssignmentOperator.BarBarAssign) {
-            const truthy = this.reg();
-            this.emit(`  ${truthy} = call i32 @xt_truthy(i64 ${current})`);
-            const isTruthy = this.reg();
-            this.emit(`  ${isTruthy} = icmp ne i32 ${truthy}, 0`);
-            condition = this.reg();
-            this.emit(`  ${condition} = xor i1 ${isTruthy}, true`);
-        }
-        else {
-            const nullish = this.reg();
-            this.emit(`  ${nullish} = call i64 @xt_is_nullish(i64 ${current})`);
-            const truthy = this.reg();
-            this.emit(`  ${truthy} = call i32 @xt_truthy(i64 ${nullish})`);
-            condition = this.reg();
-            this.emit(`  ${condition} = icmp ne i32 ${truthy}, 0`);
-        }
-        this.terminate(`br i1 ${condition}, label %${rightLabel}, label %${endLabel}`);
-        this.startBlock(rightLabel);
-        const right = this.emitExpression(node.right);
-        this.emit(`  store i64 ${right}, i64* ${result}`);
-        this.terminate(`br label %${endLabel}`);
-        this.startBlock(endLabel);
-        const value = this.reg();
-        this.emit(`  ${value} = load i64, i64* ${result}`);
-        this.emitAssignmentTarget(target, value);
-        return value;
-    }
-    emitAssignmentTarget(target, value) {
-        switch (target.kind) {
-            case SyntaxKind.Identifier: {
-                const symbol = this.binding.symbolOfIdentifier.get(target);
-                if (symbol)
-                    this.writeSlot(symbol, value);
-                return;
-            }
-            case SyntaxKind.PropertyAccessExpression: {
-                const access = target;
-                const object = this.emitExpression(access.expression);
-                const key = this.stringValue(access.name.text);
-                this.emit(`  call i64 @xt_set(i64 ${object}, i64 ${key}, i64 ${value})`);
-                return;
-            }
-            case SyntaxKind.ElementAccessExpression: {
-                const access = target;
-                const object = this.emitExpression(access.expression);
-                const key = this.emitExpression(access.argumentExpression);
-                this.emit(`  call i64 @xt_set(i64 ${object}, i64 ${key}, i64 ${value})`);
-                return;
-            }
-            case SyntaxKind.ParenthesizedExpression:
-                this.emitAssignmentTarget(target.expression, value);
-                return;
-            default:
-                this.unsupported(target, "assignment target");
-        }
-    }
-    emitCall(node) {
-        const callee = node.expression;
-        if (node.optional) {
-            const calleeValue = this.emitExpression(callee);
-            return this.emitOptional(calleeValue, () => {
-                const args = this.emitArguments(node.arguments);
-                const result = this.reg();
-                this.emit(`  ${result} = call i64 @xt_closure_call(i64 ${calleeValue}, i32 ${args.argc}, i64* ${args.ptr})`);
-                return result;
-            });
-        }
-        if ((callee.kind === SyntaxKind.PropertyAccessExpression || callee.kind === SyntaxKind.ElementAccessExpression) &&
-            callee.optional) {
-            // `obj?.method(args)` / `obj?.[key](args)`: guard the receiver, then
-            // dispatch through the runtime, which understands object methods as well
-            // as the built-in array/string methods.
-            const access = callee;
-            const object = this.emitExpression(access.expression);
-            return this.emitOptional(object, () => {
-                const name = access.kind === SyntaxKind.PropertyAccessExpression
-                    ? this.stringValue(access.name.text)
-                    : this.emitExpression(access.argumentExpression);
-                const args = this.emitArguments(node.arguments);
-                const result = this.reg();
-                this.emit(`  ${result} = call i64 @xt_call_method(i64 ${object}, i64 ${name}, i32 ${args.argc}, i64* ${args.ptr})`);
-                return result;
-            });
-        }
-        if (callee.kind === SyntaxKind.PropertyAccessExpression) {
-            const special = this.tryEmitBuiltinCall(node, callee);
-            if (special)
-                return special;
-        }
-        if (callee.kind === SyntaxKind.Identifier) {
-            const symbol = this.binding.symbolOfIdentifier.get(callee);
-            if (symbol && symbol.kind === SymbolKind.Function) {
-                const declaration = symbol.declarations[0];
-                const fn = declaration ? this.binding.functionOfNode.get(declaration) : undefined;
-                if (fn) {
-                    const args = this.emitArguments(node.arguments);
-                    const result = this.reg();
-                    this.emit(`  ${result} = call i64 @${this.functionName(fn)}(i64 ${i64(XT_UNDEFINED)}, i32 ${args.argc}, i64* ${args.ptr})`);
-                    return result;
-                }
-            }
-            const globalFunction = !symbol ? GLOBAL_FUNCTIONS[callee.text] : undefined;
-            if (globalFunction) {
-                const args = this.emitArguments(node.arguments);
-                const result = this.reg();
-                this.emit(`  ${result} = call i64 @${globalFunction}(i32 ${args.argc}, i64* ${args.ptr})`);
-                return result;
-            }
-            const builtin = this.builtins[callee.text];
-            if (!symbol && builtin) {
-                this.extraDeclarations.add(builtin.returnVoid ? `declare void @${builtin.symbol}(i32, i64*)` : `declare i64 @${builtin.symbol}(i32, i64*)`);
-                const args = this.emitArguments(node.arguments);
-                if (builtin.returnVoid) {
-                    this.emit(`  call void @${builtin.symbol}(i32 ${args.argc}, i64* ${args.ptr})`);
-                    return i64(XT_UNDEFINED);
-                }
-                const result = this.reg();
-                this.emit(`  ${result} = call i64 @${builtin.symbol}(i32 ${args.argc}, i64* ${args.ptr})`);
-                return result;
-            }
-        }
-        const calleeValue = this.emitExpression(callee);
-        const args = this.emitArguments(node.arguments);
-        const result = this.reg();
-        this.emit(`  ${result} = call i64 @xt_closure_call(i64 ${calleeValue}, i32 ${args.argc}, i64* ${args.ptr})`);
-        return result;
-    }
-    tryEmitBuiltinCall(node, callee) {
-        const target = callee.expression;
-        const method = callee.name.text;
-        const targetIdentifier = target.kind === SyntaxKind.Identifier ? target : undefined;
-        const targetSymbol = targetIdentifier ? this.binding.symbolOfIdentifier.get(targetIdentifier) : undefined;
-        if (targetIdentifier && targetIdentifier.text === "console" && !targetSymbol) {
-            const consoleFn = CONSOLE_METHODS[method];
-            if (consoleFn) {
-                const args = this.emitArguments(node.arguments);
-                this.emit(`  call void @${consoleFn}(i32 ${args.argc}, i64* ${args.ptr})`);
-                return i64(XT_UNDEFINED);
-            }
-            return undefined;
-        }
-        if (targetIdentifier && targetIdentifier.text === "Math" && !targetSymbol) {
-            if (!MATH_FUNCTIONS.has(method))
-                return undefined;
-            const name = this.stringValue(method);
-            const args = this.emitArguments(node.arguments);
-            const result = this.reg();
-            this.emit(`  ${result} = call i64 @xt_math_call(i64 ${name}, i32 ${args.argc}, i64* ${args.ptr})`);
-            return result;
-        }
-        if (targetIdentifier && targetIdentifier.text === "Object" && !targetSymbol) {
-            if (method === "keys" || method === "values" || method === "entries") {
-                const argument = node.arguments.length > 0 ? this.emitExpression(node.arguments[0]) : i64(XT_UNDEFINED);
-                const fn = method === "keys" ? "xt_object_keys" : method === "values" ? "xt_object_values" : "xt_object_entries";
-                return this.runtimeCall(fn, [argument]);
-            }
-            if (method === "assign") {
-                const args = this.emitArguments(node.arguments);
-                const result = this.reg();
-                this.emit(`  ${result} = call i64 @xt_object_assign(i32 ${args.argc}, i64* ${args.ptr})`);
-                return result;
-            }
-            return undefined;
-        }
-        if (BUILTIN_METHODS.has(method)) {
-            const object = this.emitExpression(target);
-            const name = this.stringValue(method);
-            const args = this.emitArguments(node.arguments);
-            const result = this.reg();
-            this.emit(`  ${result} = call i64 @xt_call_method(i64 ${object}, i64 ${name}, i32 ${args.argc}, i64* ${args.ptr})`);
-            return result;
-        }
-        return undefined;
-    }
-    runtimeCall(name, args) {
-        const result = this.reg();
-        this.emit(`  ${result} = call i64 @${name}(${args.map((a) => `i64 ${a}`).join(", ")})`);
-        return result;
-    }
-    emitArguments(args) {
-        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}`);
-        }
-        return { argc: args.length, ptr };
-    }
-    emitDelete(node) {
-        const target = node.expression;
-        if (target.kind === SyntaxKind.PropertyAccessExpression) {
-            const access = target;
-            const object = this.emitExpression(access.expression);
-            const key = this.stringValue(access.name.text);
-            return this.runtimeCall("xt_delete", [object, key]);
-        }
-        if (target.kind === SyntaxKind.ElementAccessExpression) {
-            const access = target;
-            const object = this.emitExpression(access.expression);
-            const key = this.emitExpression(access.argumentExpression);
-            return this.runtimeCall("xt_delete", [object, key]);
-        }
-        return i64(XT_TRUE);
-    }
-    emitPropertyAccess(node) {
-        if (node.name.text in MATH_CONSTANTS &&
-            node.expression.kind === SyntaxKind.Identifier &&
-            node.expression.text === "Math" &&
-            !this.binding.symbolOfIdentifier.get(node.expression)) {
-            return numberLiteral(MATH_CONSTANTS[node.name.text]);
-        }
-        const object = this.emitExpression(node.expression);
-        const access = () => {
-            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();
-    }
-    emitElementAccess(node) {
-        const object = this.emitExpression(node.expression);
-        const access = () => {
-            const key = this.emitExpression(node.argumentExpression);
-            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();
-    }
-    /**
-     * Evaluate `object` once and, when it is neither `null` nor `undefined`, run
-     * `compute` to produce the value; otherwise short-circuit to `undefined`.
-     */
-    emitOptional(objectValue, compute) {
-        const result = this.alloca();
-        this.emit(`  store i64 ${i64(XT_UNDEFINED)}, i64* ${result}`);
-        const nullish = this.reg();
-        this.emit(`  ${nullish} = call i64 @xt_is_nullish(i64 ${objectValue})`);
-        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 someLabel = this.label("opt.some");
-        const endLabel = this.label("opt.end");
-        this.terminate(`br i1 ${condition}, label %${endLabel}, label %${someLabel}`);
-        this.startBlock(someLabel);
-        const value = compute();
-        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;
-    }
-    emitArrayLiteral(node) {
-        const hasSpread = node.elements.some((element) => element.kind === SyntaxKind.SpreadElement);
-        if (!hasSpread) {
-            const args = this.emitArguments(node.elements);
-            const result = this.reg();
-            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`]);
-        for (const element of node.elements) {
-            if (element.kind === SyntaxKind.SpreadElement) {
-                const spread = this.emitExpression(element.expression);
-                array = this.runtimeCall("xt_array_spread", [array, spread]);
-            }
-            else {
-                const value = this.emitExpression(element);
-                array = this.runtimeCall("xt_array_push", [array, value]);
-            }
-        }
-        return array;
-    }
-    emitObjectLiteral(node) {
-        const object = this.reg();
-        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 value = this.emitExpression(property.initializer);
-                this.emit(`  call i64 @xt_set(i64 ${object}, i64 ${key}, i64 ${value})`);
-            }
-            else if (property.kind === SyntaxKind.ShorthandPropertyAssignment) {
-                const identifier = property.name;
-                const key = this.stringValue(identifier.text);
-                const value = this.emitIdentifier(identifier);
-                this.emit(`  call i64 @xt_set(i64 ${object}, i64 ${key}, i64 ${value})`);
-            }
-            else if (property.kind === SyntaxKind.SpreadElement) {
-                const spread = this.emitExpression(property.expression);
-                this.emit(`  call i64 @xt_object_spread(i64 ${object}, i64 ${spread})`);
-            }
-            else {
-                this.unsupported(property, "object spread");
-            }
-        }
-        return object;
-    }
-    emitClosure(node) {
-        const fn = this.binding.functionOfNode.get(node);
-        if (!fn) {
-            this.unsupported(node, "closure");
-            return i64(XT_UNDEFINED);
-        }
-        let envPtr = "null";
-        if (fn.captures.length > 0) {
-            envPtr = `%env${this.current.allocas.length}`;
-            this.current.allocas.push(`${envPtr} = alloca i64, i32 ${fn.captures.length}`);
-            for (let index = 0; index < fn.captures.length; index++) {
-                const symbol = fn.captures[index];
-                // The current function must be able to read the capture: either from
-                // its own slot (local) or from one of its own capture slots.
-                const slot = this.current.slots.get(symbol.id);
-                let raw;
-                if (slot) {
-                    raw = this.reg();
-                    this.emit(`  ${raw} = load i64, i64* ${slot.ptr}`);
-                }
-                else {
-                    const outer = this.binding.functionOfNode.get(node);
-                    void outer;
-                    raw = i64(XT_UNDEFINED);
-                }
-                const target = this.reg();
-                this.emit(`  ${target} = getelementptr i64, i64* ${envPtr}, i32 ${index}`);
-                this.emit(`  store i64 ${raw}, i64* ${target}`);
-            }
-        }
-        const cast = this.reg();
-        this.emit(`  ${cast} = bitcast i64 (i64, i32, i64*)* @${this.functionName(fn)} to i8*`);
-        const closure = this.reg();
-        this.emit(`  ${closure} = call i64 @xt_closure_new(i8* ${cast}, i32 ${fn.captures.length}, i64* ${envPtr})`);
-        return closure;
-    }
-    // -- string pool ---------------------------------------------------------
-    stringValue(text) {
-        const entry = this.internString(text);
-        const result = this.reg();
-        this.emit(`  ${result} = call i64 @xt_string_new(i8* ${entry.label}, i64 ${entry.length})`);
-        return result;
-    }
-    internString(text) {
-        const existing = this.strings.get(text);
-        if (existing)
-            return existing;
-        const label = `@.str.${this.stringCounter++}`;
-        const bytes = utf8Bytes(text);
-        const entry = { label, length: bytes.length };
-        this.strings.set(text, entry);
-        this.globals.push(`${label} = private unnamed_addr constant [${bytes.length + 1} x i8] c"${escapeBytes(bytes)}\\00"`);
-        return entry;
-    }
-    unsupported(node, what) {
-        const label = kindName(node.kind);
-        this.diagnostics.error(DiagnosticCode.UnsupportedFeature, `xbintsc does not yet support this ${what} (${label})`, node, this.sourceFile.fileName);
-    }
-}
-const BINARY_RUNTIME = {
-    [BinaryOperator.Add]: "xt_add",
-    [BinaryOperator.Subtract]: "xt_sub",
-    [BinaryOperator.Multiply]: "xt_mul",
-    [BinaryOperator.Divide]: "xt_div",
-    [BinaryOperator.Remainder]: "xt_mod",
-    [BinaryOperator.Exponent]: "xt_pow",
-    [BinaryOperator.LessThan]: "xt_lt",
-    [BinaryOperator.LessThanEquals]: "xt_le",
-    [BinaryOperator.GreaterThan]: "xt_gt",
-    [BinaryOperator.GreaterThanEquals]: "xt_ge",
-    [BinaryOperator.EqualsEquals]: "xt_eq",
-    [BinaryOperator.ExclamationEquals]: "xt_ne",
-    [BinaryOperator.EqualsEqualsEquals]: "xt_seq",
-    [BinaryOperator.ExclamationEqualsEquals]: "xt_sne",
-    [BinaryOperator.Ampersand]: "xt_bit_and",
-    [BinaryOperator.Bar]: "xt_bit_or",
-    [BinaryOperator.Caret]: "xt_bit_xor",
-    [BinaryOperator.LessThanLessThan]: "xt_shl",
-    [BinaryOperator.GreaterThanGreaterThan]: "xt_shr",
-    [BinaryOperator.GreaterThanGreaterThanGreaterThan]: "xt_ushr",
-    [BinaryOperator.In]: "xt_in",
-};
-const CONSOLE_METHODS = {
-    log: "xt_console_log",
-    info: "xt_console_info",
-    warn: "xt_console_warn",
-    error: "xt_console_error",
-};
-const MATH_FUNCTIONS = new Set([
-    "abs", "floor", "ceil", "round", "trunc", "sqrt", "cbrt", "pow", "exp", "log", "log2", "log10",
-    "sin", "cos", "tan", "asin", "acos", "atan", "atan2", "hypot", "sign", "random", "min", "max",
-]);
-const MATH_CONSTANTS = {
-    PI: Math.PI,
-    E: Math.E,
-    LN2: Math.LN2,
-    LN10: Math.LN10,
-    LOG2E: Math.LOG2E,
-    LOG10E: Math.LOG10E,
-    SQRT2: Math.SQRT2,
-    SQRT1_2: Math.SQRT1_2,
-};
-const GLOBAL_FUNCTIONS = {
-    parseInt: "xt_parse_int",
-    parseFloat: "xt_parse_float",
-    isNaN: "xt_is_nan",
-    isFinite: "xt_is_finite",
-    Number: "xt_number_ctor",
-    String: "xt_string_ctor",
-    Boolean: "xt_boolean_ctor",
-};
-const BUILTIN_METHODS = new Set([
-    "push", "pop", "shift", "unshift", "join", "slice", "indexOf", "includes", "map", "forEach", "filter",
-    "reduce", "concat", "reverse", "charAt", "charCodeAt", "substring", "substr", "split", "toUpperCase",
-    "toLowerCase", "trim", "replace", "repeat", "startsWith", "endsWith",
-]);
-const ASSIGNMENT_OPERATORS = new Set([
-    "=",
-    "+=",
-    "-=",
-    "*=",
-    "/=",
-    "%=",
-    "**=",
-    "<<=",
-    ">>=",
-    ">>>=",
-    "&=",
-    "|=",
-    "^=",
-    "&&=",
-    "||=",
-    "??=",
-]);
-function isAssignmentOperator(operator) {
-    return ASSIGNMENT_OPERATORS.has(operator);
-}
-function compoundToBinary(operator) {
-    const text = operator.slice(0, -1);
-    return text;
-}
-function propertyNameText(name) {
-    switch (name.kind) {
-        case SyntaxKind.Identifier:
-        case SyntaxKind.PrivateIdentifier:
-            return name.text;
-        case SyntaxKind.StringLiteral:
-            return name.value;
-        case SyntaxKind.NumericLiteral:
-            return String(name.value);
-        default:
-            return "";
-    }
-}
-/** Human readable syntax kind for diagnostics (const enums have no reverse map). */
-function kindName(kind) {
-    const entry = KIND_NAMES.get(kind);
-    return entry ?? String(kind);
-}
-const KIND_NAMES = new Map([
-    [SyntaxKind.CallExpression, "call expression"],
-    [SyntaxKind.NewExpression, "new expression"],
-    [SyntaxKind.ClassDeclaration, "class declaration"],
-    [SyntaxKind.ClassExpression, "class expression"],
-    [SyntaxKind.EnumDeclaration, "enum declaration"],
-    [SyntaxKind.SwitchStatement, "switch statement"],
-    [SyntaxKind.TryStatement, "try statement"],
-    [SyntaxKind.SpreadElement, "spread element"],
-    [SyntaxKind.ThisKeyword, "this expression"],
-    [SyntaxKind.RegularExpressionLiteral, "regular expression"],
-    [SyntaxKind.TaggedTemplateExpression, "tagged template"],
-    [SyntaxKind.DeleteExpression, "delete expression"],
-    [SyntaxKind.AwaitExpression, "await expression"],
-    [SyntaxKind.YieldExpression, "yield expression"],
-    [SyntaxKind.SwitchStatement, "switch statement"],
-]);
-function utf8Bytes(text) {
-    const bytes = [];
-    for (const character of text) {
-        const code = character.codePointAt(0);
-        if (code < 0x80)
-            bytes.push(code);
-        else if (code < 0x800) {
-            bytes.push(0xc0 | (code >> 6), 0x80 | (code & 0x3f));
-        }
-        else if (code < 0x10000) {
-            bytes.push(0xe0 | (code >> 12), 0x80 | ((code >> 6) & 0x3f), 0x80 | (code & 0x3f));
-        }
-        else {
-            bytes.push(0xf0 | (code >> 18), 0x80 | ((code >> 12) & 0x3f), 0x80 | ((code >> 6) & 0x3f), 0x80 | (code & 0x3f));
-        }
-    }
-    return bytes;
-}
-function escapeBytes(bytes) {
-    return bytes
-        .map((byte) => {
-        if (byte === 0x22)
-            return '\\22';
-        if (byte === 0x5c)
-            return '\\5C';
-        if (byte >= 0x20 && byte < 0x7f)
-            return String.fromCharCode(byte);
-        return `\\${byte.toString(16).toUpperCase().padStart(2, "0")}`;
-    })
-        .join("");
-}
+export { generate } from "./generator/generator.js";
 //# sourceMappingURL=llvm.js.map