xbintsc 0.1.8 → 0.1.9

package/src/codegen/generator/expressions.ts

@@ -7,14 +7,17 @@ import {
   SyntaxKind,
   type ArrayLiteralExpression,
   type ArrowFunction,
+  type AwaitExpression,
   type BinaryExpression,
   type CallExpression,
+  type ClassExpression,
   type ConditionalExpression,
   type DeleteExpression,
   type ElementAccessExpression,
   type Expression,
   type FunctionExpression,
   type Identifier,
+  type NewExpression,
   type ObjectLiteralExpression,
   type PostfixUnaryExpression,
   type PrefixUnaryExpression,
@@ -30,7 +33,7 @@ import {
 import { SymbolKind, type SymbolInfo } from "../../binder/binder.js";
 import { DiagnosticCode } from "../../diagnostics/diagnostic.js";
 import { i64, numberLiteral, XT_FALSE, XT_NULL, XT_TRUE, XT_UNDEFINED } from "../values.js";
-import { BINARY_RUNTIME, compoundToBinary, isAssignmentOperator } from "./tables.js";
+import { BINARY_RUNTIME, compoundToBinary, isAssignmentOperator, CTOR_FUNCTIONS } from "./tables.js";
 import type { Generator } from "./generator.js";
 
 export interface ExpressionMethods {
@@ -46,6 +49,9 @@ export interface ExpressionMethods {
   emitAssignment(this: Generator, node: BinaryExpression): string;
   emitLogicalAssignment(this: Generator, node: BinaryExpression): string;
   emitAssignmentTarget(this: Generator, target: Expression, value: string): void;
+  emitThis(this: Generator): string;
+  emitNew(this: Generator, node: NewExpression): string;
+  emitAwait(this: Generator, node: AwaitExpression): string;
 }
 
 export const expressionMethods: ExpressionMethods = {
@@ -81,6 +87,21 @@ export const expressionMethods: ExpressionMethods = {
         return this.emitExpression((node as { expression: Expression }).expression);
       case SyntaxKind.DeleteExpression:
         return this.emitDelete(node as DeleteExpression);
+      case SyntaxKind.ThisKeyword:
+        return this.emitThis();
+      case SyntaxKind.NewExpression:
+        return this.emitNew(node as NewExpression);
+      case SyntaxKind.AwaitExpression:
+        return this.emitAwait(node as AwaitExpression);
+      case SyntaxKind.ClassExpression: {
+        const info = this.binding.classOfNode.get(node);
+        if (!info) {
+          this.unsupported(node, "class expression");
+          return i64(XT_UNDEFINED);
+        }
+        this.emitClassSetup(info);
+        return this.emitClassReference(info);
+      }
       case SyntaxKind.BinaryExpression:
         return this.emitBinaryOrAssignment(node as BinaryExpression);
       case SyntaxKind.PrefixUnaryExpression:
@@ -111,6 +132,11 @@ export const expressionMethods: ExpressionMethods = {
   emitIdentifier(identifier: Identifier): string {
     const symbol = this.binding.symbolOfIdentifier.get(identifier);
     if (symbol) {
+      if (symbol.kind === SymbolKind.Class) {
+        const declaration = symbol.declarations[0];
+        const info = declaration ? this.binding.classOfNode.get(declaration) : undefined;
+        if (info) return this.emitClassReference(info);
+      }
       if (symbol.kind === SymbolKind.Function && !this.current.slots.has(symbol.id)) {
         return this.emitFunctionValue(symbol);
       }
@@ -150,12 +176,63 @@ export const expressionMethods: ExpressionMethods = {
     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*`);
+    this.emit(`  ${cast} = bitcast i64 (i64, i64, i32, i64*)* @${this.functionName(fn)} to i8*`);
     const closure = this.reg();
     this.emit(`  ${closure} = call i64 @xt_closure_new(i8* ${cast}, i32 0, i64* null)`);
     return closure;
   },
 
+  emitThis(): string {
+    if (!this.current.thisPtr) return i64(XT_UNDEFINED);
+    const value = this.reg();
+    this.emit(`  ${value} = load i64, i64* ${this.current.thisPtr}`);
+    return value;
+  },
+
+  emitAwait(node: AwaitExpression): string {
+    const value = this.emitExpression(node.expression);
+    const result = this.reg();
+    this.emit(`  ${result} = call i64 @xt_await(i64 ${value})`);
+    return result;
+  },
+
+  emitNew(node: NewExpression): string {
+    const callee = node.expression;
+    if (callee.kind === SyntaxKind.Identifier) {
+      const identifier = callee as Identifier;
+      const symbol = this.binding.symbolOfIdentifier.get(identifier);
+      if (symbol && symbol.kind === SymbolKind.Class) {
+        const declaration = symbol.declarations[0];
+        const info = declaration ? this.binding.classOfNode.get(declaration) : undefined;
+        if (info) {
+          const ctor = this.emitClassReference(info);
+          const args = this.emitArguments(node.arguments);
+          const result = this.reg();
+          this.emit(`  ${result} = call i64 @xt_new(i64 ${ctor}, i32 ${args.argc}, i64* ${args.ptr})`);
+          return result;
+        }
+      }
+      if (!symbol) {
+        const ctor = CTOR_FUNCTIONS[identifier.text];
+        if (ctor) {
+          const args = this.emitArguments(node.arguments);
+          const result = this.reg();
+          this.emit(`  ${result} = call i64 @${ctor}(i32 ${args.argc}, i64* ${args.ptr})`);
+          return result;
+        }
+        if (identifier.text === "Object") {
+          if (node.arguments.length > 0) return this.emitExpression(node.arguments[0]!);
+          return this.runtimeCall("xt_object_new", []);
+        }
+      }
+    }
+    const ctorValue = this.emitExpression(callee);
+    const args = this.emitArguments(node.arguments);
+    const result = this.reg();
+    this.emit(`  ${result} = call i64 @xt_new(i64 ${ctorValue}, i32 ${args.argc}, i64* ${args.ptr})`);
+    return result;
+  },
+
   emitTemplate(node: TemplateLiteral): string {
     let accumulator = this.stringValue(node.head);
     for (const span of node.spans) {

package/src/codegen/generator/module.ts

@@ -10,7 +10,8 @@ import {
   type Expression,
   type Parameter,
 } from "../../ast/nodes.js";
-import type { FunctionInfo, SymbolInfo } from "../../binder/binder.js";
+import type { ClassInfo, FunctionInfo, SymbolInfo } from "../../binder/binder.js";
+import { SymbolKind } from "../../binder/binder.js";
 import { i64, XT_UNDEFINED } from "../values.js";
 import { RUNTIME_DECLARATIONS, type FunctionState } from "./state.js";
 import type { Generator } from "./generator.js";
@@ -20,11 +21,32 @@ export interface ModuleMethods {
   emitFunction(this: Generator, fn: FunctionInfo): void;
   emitMain(this: Generator): void;
   functionName(this: Generator, fn: FunctionInfo): string;
+  wrapAsync(this: Generator, value: string): string;
+  classGlobal(this: Generator, classInfo: ClassInfo): string;
+  emitClassReference(this: Generator, classInfo: ClassInfo): string;
+  emitClassSetup(this: Generator, classInfo: ClassInfo): void;
   emitDefaultParameter(this: Generator, symbol: SymbolInfo, value: string, initializer: Expression): void;
 }
 
 export const moduleMethods: ModuleMethods = {
   run(): string {
+    for (const classInfo of this.binding.classes) {
+      const globalName = `@class.${classInfo.id}`;
+      this.classGlobals.set(classInfo.id, globalName);
+      this.globals.push(`${globalName} = internal global i64 0`);
+    }
+    // Module-level bindings captured by functions live in globals so that a
+    // top-level function can see them without a closure environment.
+    const moduleScope = this.binding.scopes.get(this.sourceFile);
+    if (moduleScope) {
+      for (const symbol of moduleScope.symbols.values()) {
+        const isVariable = symbol.kind === SymbolKind.Var || symbol.kind === SymbolKind.Let || symbol.kind === SymbolKind.Const;
+        if (!isVariable || !symbol.boxed || !symbol.fn.isModule) continue;
+        const globalName = `@g.${symbol.id}`;
+        this.moduleGlobals.set(symbol.id, globalName);
+        this.globals.push(`${globalName} = internal global i64 ${i64(XT_UNDEFINED)}`);
+      }
+    }
     for (const fn of this.binding.functions) this.emitFunction(fn);
     this.emitMain();
     const header = ["; ModuleID = 'xbintsc'", "source_filename = \"" + this.sourceFile.fileName + "\"", ""];
@@ -50,9 +72,12 @@ export const moduleMethods: ModuleMethods = {
     };
     this.current = state;
 
-    const header = `define i64 @${name}(i64 %env, i32 %argc, i64* %argv) {`;
+    const header = `define i64 @${name}(i64 %this, i64 %env, i32 %argc, i64* %argv) {`;
     this.emit(`%saved.env = alloca i64`);
     this.emit(`store i64 %env, i64* %saved.env`);
+    this.emit(`%saved.this = alloca i64`);
+    this.emit(`store i64 %this, i64* %saved.this`);
+    state.thisPtr = "%saved.this";
     this.emit(`%saved.argc = alloca i32`);
     this.emit(`store i32 %argc, i32* %saved.argc`);
     this.emit(`%saved.argv = alloca i64*`);
@@ -77,24 +102,46 @@ export const moduleMethods: ModuleMethods = {
 
     // Captures threaded through the environment.
     for (const symbol of fn.captures) {
+      if (this.moduleGlobals.has(symbol.id)) continue;
       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);
     }
 
+    // Arrow functions inherit `this` lexically; it travels as an extra capture.
+    if (fn.isArrow && fn.capturesThis) {
+      const inherited = this.reg();
+      this.emit(`  ${inherited} = call i64 @xt_closure_env(i64 %env, i32 ${fn.captures.length})`);
+      this.emit(`  store i64 ${inherited}, i64* %saved.this`);
+    }
+
+    // Instance field initializers run before the constructor body.
+    if (fn.isConstructor && fn.classInfo) {
+      const thisValue = this.emitThis();
+      for (const field of fn.classInfo.fields) {
+        if (field.isStatic) continue;
+        const key = this.stringValue(field.name);
+        const value = field.initializer ? this.emitExpression(field.initializer) : i64(XT_UNDEFINED);
+        this.emit(`  call i64 @xt_set(i64 ${thisValue}, i64 ${key}, i64 ${value})`);
+      }
+    }
+
     // Body.
     if (fn.node.kind === SyntaxKind.SourceFile) {
       this.emitStatements(this.sourceFile.statements);
     } else if (fn.node.kind === SyntaxKind.ArrowFunction && (fn.node as ArrowFunction).body.kind !== SyntaxKind.Block) {
       const value = this.emitExpression((fn.node as ArrowFunction).body as Expression);
-      this.terminate(`ret i64 ${value}`);
+      this.terminate(`ret i64 ${fn.isAsync ? this.wrapAsync(value) : value}`);
     } else {
       const body = (fn.node as { body: Block }).body;
-      this.emitStatements(body.statements);
+      if (body) this.emitStatements(body.statements);
     }
 
-    if (!this.current.terminated) this.terminate(`ret i64 ${i64(XT_UNDEFINED)}`);
+    if (!this.current.terminated) {
+      const fallback = fn.isAsync ? this.wrapAsync(i64(XT_UNDEFINED)) : i64(XT_UNDEFINED);
+      this.terminate(`ret i64 ${fallback}`);
+    }
 
     const escapes = state.usesTry
       ? state.escapePointers.map((ptr) => `  call void asm sideeffect "", "r"(i64* ${ptr})`)
@@ -108,7 +155,8 @@ export const moduleMethods: ModuleMethods = {
     this.functions.push(
       [
         "define i32 @main(i32 %argc, i8** %argv) {",
-        `  %result = call i64 @${moduleName}(i64 ${i64(XT_UNDEFINED)}, i32 0, i64* null)`,
+        `  %result = call i64 @${moduleName}(i64 ${i64(XT_UNDEFINED)}, i64 ${i64(XT_UNDEFINED)}, i32 0, i64* null)`,
+        "  call void @xt_drain_microtasks()",
         "  ret i32 0",
         "}",
         "",
@@ -120,6 +168,63 @@ export const moduleMethods: ModuleMethods = {
     return fn.isModule ? "xt_module" : `xt_fn_${fn.id}`;
   },
 
+  /** Wrap a returned value in a resolved promise (for `async` functions). */
+  wrapAsync(value: string): string {
+    const result = this.reg();
+    this.emit(`  ${result} = call i64 @xt_promise_resolve(i64 ${value})`);
+    return result;
+  },
+
+  classGlobal(classInfo: ClassInfo): string {
+    const existing = this.classGlobals.get(classInfo.id);
+    if (existing) return existing;
+    const name = `@class.${classInfo.id}`;
+    this.classGlobals.set(classInfo.id, name);
+    this.globals.push(`${name} = internal global i64 0`);
+    return name;
+  },
+
+  emitClassReference(classInfo: ClassInfo): string {
+    const globalName = this.classGlobal(classInfo);
+    const value = this.reg();
+    this.emit(`  ${value} = load i64, i64* ${globalName}`);
+    return value;
+  },
+
+  /** Build a class value (constructor closure + prototype) and store it in its global. */
+  emitClassSetup(classInfo: ClassInfo): void {
+    const globalName = this.classGlobal(classInfo);
+    const proto = this.reg();
+    this.emit(`  ${proto} = call i64 @xt_object_new()`);
+    if (classInfo.parentExpression) {
+      const parent = this.emitExpression(classInfo.parentExpression);
+      const parentProto = this.reg();
+      this.emit(`  ${parentProto} = call i64 @xt_function_get_prototype(i64 ${parent})`);
+      this.emit(`  call i64 @xt_object_set_prototype(i64 ${proto}, i64 ${parentProto})`);
+    }
+    for (const method of classInfo.methods) {
+      const fnValue = this.emitClosureValue(method);
+      const key = this.stringValue(method.name);
+      this.emit(`  call i64 @xt_set(i64 ${proto}, i64 ${key}, i64 ${fnValue})`);
+    }
+    const ctor = this.emitClosureValue(classInfo.ctor!);
+    this.emit(`  call i64 @xt_function_set_prototype(i64 ${ctor}, i64 ${proto})`);
+    const ctorKey = this.stringValue("__ctor");
+    this.emit(`  call i64 @xt_set(i64 ${proto}, i64 ${ctorKey}, i64 ${ctor})`);
+    for (const method of classInfo.statics) {
+      const fnValue = this.emitClosureValue(method);
+      const key = this.stringValue(method.name);
+      this.emit(`  call i64 @xt_set(i64 ${ctor}, i64 ${key}, i64 ${fnValue})`);
+    }
+    for (const field of classInfo.fields) {
+      if (!field.isStatic) continue;
+      const key = this.stringValue(field.name);
+      const value = field.initializer ? this.emitExpression(field.initializer) : i64(XT_UNDEFINED);
+      this.emit(`  call i64 @xt_set(i64 ${ctor}, i64 ${key}, i64 ${value})`);
+    }
+    this.emit(`  store i64 ${ctor}, i64* ${globalName}`);
+  },
+
   emitDefaultParameter(symbol: SymbolInfo, value: string, initializer: Expression): void {
     const isUndefined = this.reg();
     this.emit(`  ${isUndefined} = call i64 @xt_seq(i64 ${value}, i64 ${i64(XT_UNDEFINED)})`);

package/src/codegen/generator/state.ts

@@ -30,6 +30,8 @@ export interface FunctionState {
   readonly loops: LoopLabels[];
   readonly tryFrames: string[];
   readonly escapePointers: string[];
+  /** Alloca holding the `this` binding for the current function. */
+  thisPtr?: string;
   /** Set when the function contains a `try`, forcing locals to live in memory. */
   usesTry: boolean;
 }
@@ -55,6 +57,47 @@ export const RUNTIME_DECLARATIONS: readonly string[] = [
   "declare i64 @xt_closure_new(i8*, i32, i64*)",
   "declare i64 @xt_closure_call(i64, i32, i64*)",
   "declare i64 @xt_closure_env(i64, i32)",
+  "declare i64 @xt_call_with_this(i64, i64, i32, i64*)",
+  "declare i64 @xt_this()",
+  "declare i64 @xt_new(i64, i32, i64*)",
+  "declare i64 @xt_instance_of(i64, i64)",
+  "declare i64 @xt_function_set_prototype(i64, i64)",
+  "declare i64 @xt_function_get_prototype(i64)",
+  "declare i64 @xt_object_new_with_proto(i64)",
+  "declare i64 @xt_object_get_prototype(i64)",
+  "declare i64 @xt_object_set_prototype(i64, i64)",
+  "declare i64 @xt_await(i64)",
+  "declare void @xt_drain_microtasks()",
+  "declare i64 @xt_promise_resolve(i64)",
+  "declare i64 @xt_promise_reject(i64)",
+  "declare i64 @xt_promise_ctor(i32, i64*)",
+  "declare i64 @xt_promise_static(i64, i32, i64*)",
+  "declare i64 @xt_array_static(i64, i32, i64*)",
+  "declare i64 @xt_object_static(i64, i32, i64*)",
+  "declare i64 @xt_number_static(i64, i32, i64*)",
+  "declare i64 @xt_string_static(i64, i32, i64*)",
+  "declare i64 @xt_date_static(i64, i32, i64*)",
+  "declare i64 @xt_map_ctor(i32, i64*)",
+  "declare i64 @xt_set_ctor(i32, i64*)",
+  "declare i64 @xt_date_ctor(i32, i64*)",
+  "declare i64 @xt_regexp_ctor(i32, i64*)",
+  "declare i64 @xt_json_parse(i32, i64*)",
+  "declare i64 @xt_json_stringify(i32, i64*)",
+  "declare i64 @xt_object_from_entries(i64)",
+  "declare i64 @xt_object_freeze(i64)",
+  "declare i32 @xt_object_is_frozen(i64)",
+  "declare i64 @xt_object_has_own(i64, i64)",
+  "declare i64 @xt_console_dir(i32, i64*)",
+  "declare i64 @xt_console_trace(i32, i64*)",
+  "declare i64 @xt_console_assert(i32, i64*)",
+  "declare i64 @xt_console_count(i32, i64*)",
+  "declare i64 @xt_console_count_reset(i32, i64*)",
+  "declare i64 @xt_console_group(i32, i64*)",
+  "declare i64 @xt_console_group_end(i32, i64*)",
+  "declare i64 @xt_console_table(i32, i64*)",
+  "declare i64 @xt_console_time(i32, i64*)",
+  "declare i64 @xt_console_time_end(i32, i64*)",
+  "declare i64 @xt_console_time_log(i32, i64*)",
   "declare i32 @xt_truthy(i64)",
   "declare double @xt_to_number(i64)",
   "declare i64 @xt_to_string(i64)",

package/src/codegen/generator/statements.ts

@@ -67,6 +67,11 @@ export const statementMethods: StatementMethods = {
       case SyntaxKind.InterfaceDeclaration:
       case SyntaxKind.TypeAliasDeclaration:
         return; // functions are emitted at module scope
+      case SyntaxKind.ClassDeclaration: {
+        const info = this.binding.classOfNode.get(statement);
+        if (info) this.emitClassSetup(info);
+        return;
+      }
       case SyntaxKind.IfStatement:
         this.emitIf(statement as IfStatement);
         return;
@@ -457,7 +462,8 @@ export const statementMethods: StatementMethods = {
   },
 
   emitReturn(statement: ReturnStatement): void {
-    const value = statement.expression ? this.emitExpression(statement.expression) : i64(XT_UNDEFINED);
+    let value = statement.expression ? this.emitExpression(statement.expression) : i64(XT_UNDEFINED);
+    if (this.current.fn.isAsync) value = this.wrapAsync(value);
     this.popTryFramesTo(0);
     this.terminate(`ret i64 ${value}`);
   },

package/src/codegen/generator/tables.ts

@@ -31,6 +31,7 @@ export const BINARY_RUNTIME: Record<string, string | undefined> = {
   [BinaryOperator.GreaterThanGreaterThan]: "xt_shr",
   [BinaryOperator.GreaterThanGreaterThanGreaterThan]: "xt_ushr",
   [BinaryOperator.In]: "xt_in",
+  [BinaryOperator.InstanceOf]: "xt_instance_of",
 };
 
 export const CONSOLE_METHODS: Record<string, string> = {
@@ -38,11 +39,23 @@ export const CONSOLE_METHODS: Record<string, string> = {
   info: "xt_console_info",
   warn: "xt_console_warn",
   error: "xt_console_error",
+  dir: "xt_console_dir",
+  trace: "xt_console_trace",
+  assert: "xt_console_assert",
+  count: "xt_console_count",
+  countReset: "xt_console_count_reset",
+  group: "xt_console_group",
+  groupEnd: "xt_console_group_end",
+  table: "xt_console_table",
+  time: "xt_console_time",
+  timeEnd: "xt_console_time_end",
+  timeLog: "xt_console_time_log",
 };
 
 export const MATH_FUNCTIONS = new Set<string>([
   "abs", "floor", "ceil", "round", "trunc", "sqrt", "cbrt", "pow", "exp", "log", "log2", "log10",
   "sin", "cos", "tan", "asin", "acos", "atan", "atan2", "hypot", "sign", "random", "min", "max",
+  "log1p", "expm1", "sinh", "cosh", "tanh", "asinh", "acosh", "atanh", "fround", "imul", "clz32",
 ]);
 
 export const MATH_CONSTANTS: Record<string, number> = {
@@ -66,6 +79,28 @@ export const GLOBAL_FUNCTIONS: Record<string, string> = {
   Boolean: "xt_boolean_ctor",
 };
 
+/** Global namespaces whose static methods map to runtime dispatchers. */
+export const NAMESPACE_STATICS: Record<string, string> = {
+  Math: "xt_math_call",
+  JSON: "xt_json",
+  Array: "xt_array_static",
+  Object: "xt_object_static",
+  Number: "xt_number_static",
+  String: "xt_string_static",
+  Date: "xt_date_static",
+  Promise: "xt_promise_static",
+};
+
+/** Global constructors called as `new X(...)` (all have signature `(i32, i64*)`). */
+export const CTOR_FUNCTIONS: Record<string, string> = {
+  Array: "xt_array_new",
+  Map: "xt_map_ctor",
+  Set: "xt_set_ctor",
+  Date: "xt_date_ctor",
+  RegExp: "xt_regexp_ctor",
+  Promise: "xt_promise_ctor",
+};
+
 export const BUILTIN_METHODS = new Set<string>([
   "push", "pop", "shift", "unshift", "join", "slice", "indexOf", "includes", "map", "forEach", "filter",
   "reduce", "concat", "reverse", "charAt", "charCodeAt", "substring", "substr", "split", "toUpperCase",

package/src/driver/compiler.ts

@@ -13,6 +13,8 @@ import { DiagnosticBag, type Diagnostic } from "../diagnostics/diagnostic.js";
 import { SourceFile } from "../diagnostics/source.js";
 import { Parser } from "../parser/parser.js";
 import { generate } from "../codegen/llvm.js";
+import { SyntaxKind } from "../ast/nodes.js";
+import { bundleModules } from "./modules.js";
 import { createDefaultRegistry, type ExtensionRegistry } from "../extensions/registry.js";
 import { BuildCache, hashParts } from "./cache.js";
 import { findRuntimeDir } from "./paths.js";
@@ -94,9 +96,31 @@ export function build(entryPath: string, options: BuildOptions = {}): BuildResul
         ? resolve(options.output ?? join(outDir, baseName + ".o"))
         : executableName(absoluteEntry, outDir, options.output);
 
+  // -- front end -----------------------------------------------------------
+  const file = new SourceFile(absoluteEntry, sourceText);
+  const diagnostics = new DiagnosticBag();
+  const parser = new Parser(file, diagnostics);
+  let sourceFile = parser.parseSourceFile();
+
+  // Lower `import`/`export` by merging every reachable module into one file.
+  const isModule = sourceFile.statements.some(
+    (statement) =>
+      statement.kind === SyntaxKind.ImportDeclaration ||
+      statement.kind === SyntaxKind.ExportDeclaration ||
+      statement.kind === SyntaxKind.ExportAssignment,
+  );
+  let cacheText = sourceText;
+  if (isModule) {
+    const bundled = bundleModules(absoluteEntry, diagnostics);
+    if (bundled) {
+      sourceFile = bundled.sourceFile;
+      cacheText = bundled.text;
+    }
+  }
+
   const cacheKey = hashParts([
     COMPILER_VERSION,
-    sourceText,
+    cacheText,
     emit,
     optimize,
     process.platform,
@@ -105,15 +129,10 @@ export function build(entryPath: string, options: BuildOptions = {}): BuildResul
 
   const cache = new BuildCache(cacheDir);
   const outputs = [outputPath];
-  if (!options.force && cache.isFresh(cacheKey, outputs)) {
+  if (!options.force && !diagnostics.hasErrors && cache.isFresh(cacheKey, outputs)) {
     return { outputPath, cached: true, diagnostics: [] };
   }
 
-  // -- front end -----------------------------------------------------------
-  const file = new SourceFile(absoluteEntry, sourceText);
-  const diagnostics = new DiagnosticBag();
-  const parser = new Parser(file, diagnostics);
-  const sourceFile = parser.parseSourceFile();
   const { ir } = generate(sourceFile, diagnostics, { builtins: registry.builtins() });
 
   if (options.verbose) {
@@ -174,6 +193,8 @@ const RUNTIME_SOURCES = [
   "xt_values.c",
   "xt_containers.c",
   "xt_stdlib.c",
+  "xt_stdlib2.c",
+  "xt_promise.c",
   "xt_builtins.c",
   "xt_io.c",
 ] as const;