xbintsc 0.1.3 → 0.1.6

package/README.md

@@ -178,6 +178,11 @@ to the C symbol with the uniform `(argc, argv)` calling convention. Adding a
 module means dropping a folder under `src/extensions/node/` and its C
 counterpart under `runtime/ext_node/`; the core compiler never changes.
 
+Node module coverage:
+
+- [Node extension: implemented](./doc/node-implemented.md)
+- [Node extension: unimplemented](./doc/node-unimplemented.md)
+
 ## Tests
 
 ```bash
@@ -196,12 +201,5 @@ Tests are organised by module under `tests/` (`lexer`, `parser`, `binder`,
 
 ## Language subset
 
-Implemented today: functions, arrow functions and closures, `let`/`const`/`var`,
-all common operators, `if`/`while`/`do`/`for`/`for…of`/`for…in`, `break`/
-`continue`/`return`/`throw`, objects, arrays, member/element access, assignments,
-template literals, `console.log`, extension builtins, and the TypeScript type
-syntax is parsed and ignored (types are erased).
-
-Not yet implemented: classes, enums, `switch`, `try`/`catch`, `new`, `this`,
-object spread, `async`/generators, and most standard library methods (`Array`
-methods other than `push`, `Math`, etc.).
+- [Implemented features](./doc/implemented.md)
+- [Unimplemented features](./doc/unimplemented.md)

package/dist/src/codegen/llvm.js

@@ -64,6 +64,23 @@ const RUNTIME_DECLARATIONS = [
     "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)",
@@ -75,7 +92,14 @@ const RUNTIME_DECLARATIONS = [
     "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);
@@ -117,6 +141,9 @@ class Generator {
             label: 0,
             terminated: false,
             loops: [],
+            tryFrames: [],
+            escapePointers: [],
+            usesTry: false,
         };
         this.current = state;
         const header = `define i64 @${name}(i64 %env, i32 %argc, i64* %argv) {`;
@@ -127,11 +154,21 @@ class Generator {
         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) {
@@ -154,7 +191,10 @@ class Generator {
         }
         if (!this.current.terminated)
             this.terminate(`ret i64 ${i64(XT_UNDEFINED)}`);
-        const lines = [...state.allocas.map((a) => `  ${a}`), ...state.buffer];
+        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() {
@@ -191,6 +231,7 @@ class Generator {
     alloca() {
         const ptr = `%slot${this.current.allocas.length}`;
         this.current.allocas.push(`${ptr} = alloca i64`);
+        this.current.escapePointers.push(ptr);
         return ptr;
     }
     const(hex) {
@@ -245,6 +286,22 @@ class Generator {
         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) {
@@ -286,19 +343,29 @@ class Generator {
             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)
+                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)
+                if (loop) {
+                    this.popTryFramesTo(loop.tryDepth ?? 0);
                     this.terminate(`br label %${loop.continueLabel}`);
+                }
                 return;
             }
             case SyntaxKind.ThrowStatement: {
@@ -365,7 +432,7 @@ class Generator {
         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 });
+        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)
@@ -378,7 +445,7 @@ class Generator {
         const endLabel = this.label("do.end");
         this.terminate(`br label %${bodyLabel}`);
         this.startBlock(bodyLabel);
-        this.current.loops.push({ breakLabel: endLabel, continueLabel: condLabel });
+        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)
@@ -423,7 +490,7 @@ class Generator {
             this.terminate(`br label %${bodyLabel}`);
         }
         this.startBlock(bodyLabel);
-        this.current.loops.push({ breakLabel: endLabel, continueLabel: updateLabel });
+        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)
@@ -434,9 +501,13 @@ class Generator {
         this.terminate(`br label %${condLabel}`);
         this.startBlock(endLabel);
     }
-    /** `for (const x of xs)` / `for (const k in obj)` over arrays and objects. */
+    /** `for (const x of xs)` / `for (const k in obj)` over arrays, strings and objects. */
     emitForOf(statement) {
-        const iterable = this.emitExpression(statement.expression);
+        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();
@@ -460,7 +531,7 @@ class Generator {
         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 });
+        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)
@@ -488,10 +559,167 @@ class Generator {
         }
         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) {
@@ -523,6 +751,8 @@ class Generator {
             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:
@@ -566,6 +796,15 @@ class Generator {
                 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);
@@ -854,6 +1093,32 @@ class Generator {
     }
     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)
@@ -871,6 +1136,13 @@ class Generator {
                     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*)`);
@@ -893,32 +1165,47 @@ class Generator {
     tryEmitBuiltinCall(node, callee) {
         const target = callee.expression;
         const method = callee.name.text;
-        if (target.kind === SyntaxKind.Identifier && target.text === "console") {
+        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);
-            this.emit(`  call void @xt_console_log(i32 ${args.argc}, i64* ${args.ptr})`);
-            return i64(XT_UNDEFINED);
+            const result = this.reg();
+            this.emit(`  ${result} = call i64 @xt_math_call(i64 ${name}, i32 ${args.argc}, i64* ${args.ptr})`);
+            return result;
         }
-        // Array and string methods.
-        if (method === "push" || method === "pop" || method === "shift" || method === "unshift" || method === "join" || method === "slice" || method === "indexOf" || method === "includes" || method === "map" || method === "forEach" || method === "filter" || method === "reduce") {
-            if (method === "push") {
-                const object = this.emitExpression(target);
+        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);
-                let last = object;
-                if (args.argc === 0)
-                    return this.runtimeCall("xt_array_length", [object]);
-                for (let index = 0; index < args.argc; index++) {
-                    const ptr = this.reg();
-                    this.emit(`  ${ptr} = getelementptr i64, i64* ${args.ptr}, i32 ${index}`);
-                    const element = this.reg();
-                    this.emit(`  ${element} = load i64, i64* ${ptr}`);
-                    const previous = last;
-                    last = this.reg();
-                    this.emit(`  ${last} = call i64 @xt_array_push(i64 ${previous}, i64 ${element})`);
-                }
-                return last;
+                const result = this.reg();
+                this.emit(`  ${result} = call i64 @xt_object_assign(i32 ${args.argc}, i64* ${args.ptr})`);
+                return result;
             }
-            this.unsupported(node, `array method '${method}'`);
-            return i64(XT_UNDEFINED);
+            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;
     }
@@ -940,25 +1227,77 @@ class Generator {
         }
         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 === "length") {
-            const object = this.emitExpression(node.expression);
-            const result = this.reg();
-            this.emit(`  ${result} = call i64 @xt_array_length(i64 ${object})`);
-            return result;
+        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 key = this.stringValue(node.name.text);
-        const result = this.reg();
-        this.emit(`  ${result} = call i64 @xt_get(i64 ${object}, i64 ${key})`);
-        return result;
+        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 key = this.emitExpression(node.argumentExpression);
-        const result = this.reg();
-        this.emit(`  ${result} = call i64 @xt_get(i64 ${object}, i64 ${key})`);
-        return result;
+        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);
@@ -997,6 +1336,10 @@ class Generator {
                 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");
             }
@@ -1083,7 +1426,42 @@ const BINARY_RUNTIME = {
     [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([
     "=",
     "+=",