xbintsc 0.3.87 → 0.5.20

package/src/cli/watch.ts

@@ -0,0 +1,101 @@
+/**
+ * `xbintsc watch` support: fingerprint a source tree and rebuild when it
+ * changes.
+ *
+ * The scan is deliberately polling-based. A self-hosted xbintsc binary has no
+ * `fs.watch` backend in the Node extension, and polling works identically on
+ * every platform. The tree is the entry file's directory, with build outputs
+ * and dependency directories excluded; package sources inside `node_modules`
+ * are not watched (run the build once after installing a dependency).
+ */
+
+import { readFileSync, readdirSync, statSync, type Dirent } from "node:fs";
+import { extname, join, resolve } from "node:path";
+
+const WATCHED_EXTENSIONS = new Set([
+  ".ts",
+  ".tsx",
+  ".js",
+  ".mjs",
+  ".cjs",
+  ".json",
+  ".html",
+  ".css",
+]);
+
+const IGNORED_DIRECTORIES = new Set([
+  "node_modules",
+  ".git",
+  ".github",
+  ".xbintsc",
+  ".xbintsc-cache",
+  "build",
+  "dist",
+  "coverage",
+  "scratch",
+  "target",
+  "vendor",
+]);
+
+/** One string that changes whenever a watched file changes. */
+export function fingerprintTree(root: string): string {
+  const entries: string[] = [];
+  collect(resolve(root), entries);
+  entries.sort();
+  return entries.join("|");
+}
+
+function collect(directory: string, out: string[]): void {
+  let entries: Dirent[];
+  try {
+    entries = readdirSync(directory, { withFileTypes: true });
+  } catch {
+    return; // the directory disappeared between scans
+  }
+  for (const entry of entries) {
+    const path = join(directory, entry.name);
+    if (entry.isDirectory()) {
+      if (!IGNORED_DIRECTORIES.has(entry.name)) collect(path, out);
+      continue;
+    }
+    if (!entry.isFile()) continue;
+    if (!WATCHED_EXTENSIONS.has(extname(entry.name).toLowerCase())) continue;
+    try {
+      const stat = statSync(path);
+      /* mtime resolution is coarse on some filesystems (and on Windows two
+       * same-size writes can share a timestamp), so hash the bytes as well. */
+      let hash = 2166136261;
+      const contents = readFileSync(path);
+      for (let i = 0; i < contents.length; i++) {
+        hash = Math.imul(hash ^ (contents[i] ?? 0), 16777619);
+      }
+      out.push(`${path}:${stat.mtimeMs}:${stat.size}:${hash >>> 0}`);
+    } catch {
+      // A file removed during the scan is picked up by the next iteration.
+    }
+  }
+}
+
+export interface WatchOptions {
+  /** Current fingerprint of everything that should trigger a rebuild. */
+  readonly scan: () => string;
+  /** Called after the fingerprint changes. Must be synchronous. */
+  readonly onRebuild: () => void;
+  /** Poll interval; defaults to 300 ms. */
+  readonly intervalMs?: number;
+}
+
+/**
+ * Start polling. Returns a stop function. The caller performs the initial
+ * build, so this never fires `onRebuild` for the state it starts in.
+ */
+export function startWatching(options: WatchOptions): () => void {
+  let previous = options.scan();
+  const timer = setInterval(() => {
+    const next = options.scan();
+    if (next === previous) return;
+    previous = next;
+    options.onRebuild();
+  }, options.intervalMs ?? 300);
+  return () => clearInterval(timer);
+}

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

@@ -13,7 +13,7 @@ import {
   type PropertyAccessExpression,
 } from "../../../ast/nodes.js";
 import { i64, numberLiteral, XT_TRUE, XT_UNDEFINED } from "../../values.js";
-import { MATH_CONSTANTS, NAMESPACE_PROPERTIES, NUMBER_CONSTANTS, TYPED_ARRAYS } from "../tables.js";
+import { MATH_CONSTANTS, NAMESPACE_PROPERTIES, NUMBER_CONSTANTS, SYMBOL_WELL_KNOWN, TYPED_ARRAYS } from "../tables.js";
 import type { Generator } from "../generator.js";
 
 export interface AccessCallMethods {
@@ -85,7 +85,12 @@ export const accessCallMethods: AccessCallMethods = {
       !this.binding.symbolOfIdentifier.get(node.expression as Identifier)
     ) {
       const getter = NAMESPACE_PROPERTIES[(node.expression as Identifier).text];
-      if (getter) {
+      /* `Symbol.iterator` & friends are well-known symbol values, but
+       * `Symbol.prototype` / `.name` / `.length` are ordinary properties of
+       * the first-class constructor value. */
+      const symbolGetter =
+        (node.expression as Identifier).text === "Symbol" && SYMBOL_WELL_KNOWN.has(node.name.text);
+      if (getter && (getter !== "xt_symbol_get" || symbolGetter)) {
         const key = this.stringValue(node.name.text);
         const result = this.reg();
         this.emit(`  ${result} = call i64 @${getter}(i64 ${key})`);
@@ -138,7 +143,14 @@ export const accessCallMethods: AccessCallMethods = {
     const access = (): string => {
       const key = this.emitExpression(node.argumentExpression);
       const result = this.reg();
-      this.emit(`  ${result} = call i64 @xt_get(i64 ${object}, i64 ${key})`);
+      /* Array-index reads are not object property layouts, so skip the IC for
+       * a numeric literal; every other key may benefit from it. */
+      if (node.argumentExpression.kind === SyntaxKind.NumericLiteral) {
+        this.emit(`  ${result} = call i64 @xt_get(i64 ${object}, i64 ${key})`);
+      } else {
+        const cache = this.icCachePointer();
+        this.emit(`  ${result} = call i64 @xt_get_ic(i64 ${object}, i64 ${key}, i64* ${cache})`);
+      }
       return result;
     };
     return node.optional ? this.emitOptional(object, access) : access();
@@ -153,8 +165,9 @@ export const accessCallMethods: AccessCallMethods = {
       return result;
     }
     const key = this.stringValue(name);
+    const cache = this.icCachePointer();
     const result = this.reg();
-    this.emit(`  ${result} = call i64 @xt_get(i64 ${object}, i64 ${key})`);
+    this.emit(`  ${result} = call i64 @xt_get_ic(i64 ${object}, i64 ${key}, i64* ${cache})`);
     return result;
   },
 

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

@@ -79,6 +79,17 @@ export const closureCallMethods: ClosureCallMethods = {
     if (fn.isConstructor && fn.classInfo) name = fn.classInfo.name;
     const nameValue = this.stringValue(name);
     this.emit(`  call i64 @xt_function_set_metadata(i64 ${closure}, i64 ${nameValue}, i32 ${arity})`);
-    if (fn.isGenerator) this.emit(`  call i64 @xt_function_set_generator(i64 ${closure})`);
+    if (fn.isAsync && fn.isGenerator) {
+      /* `async function*`: a generator whose `.next()` returns promises. The
+       * runtime needs both flags, so use the combined marker instead of the
+       * two separate setters. */
+      this.emit(`  call i64 @xt_function_set_async_generator(i64 ${closure})`);
+    } else if (fn.isGenerator) {
+      this.emit(`  call i64 @xt_function_set_generator(i64 ${closure})`);
+    } else if (fn.isAsync) {
+      /* `async` functions run on a coroutine: the runtime must know at call
+       * time so it can return a promise and suspend at `await`. */
+      this.emit(`  call i64 @xt_function_set_async(i64 ${closure})`);
+    }
   },
 };

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

@@ -109,9 +109,10 @@ export const invocationCallMethods: InvocationCallMethods = {
       if (symbol && symbol.kind === SymbolKind.Function) {
         const declaration = symbol.declarations[0];
         const fn = declaration ? this.binding.functionOfNode.get(declaration) : undefined;
-        /* Generator functions are not called directly: the call must create a
-         * suspended generator, so fall through to the closure-call path. */
-        if (fn && !fn.isGenerator) {
+        /* Generator and `async` functions are not called directly: the call
+         * must create a suspended generator / start a coroutine, so fall
+         * through to the closure-call path. */
+        if (fn && !fn.isGenerator && !fn.isAsync) {
           const args = this.emitArguments(node.arguments);
           const result = this.reg();
           this.emit(

package/src/codegen/generator/context.ts

@@ -64,6 +64,8 @@ export class GeneratorContext {
   readonly lineStartsByFile = new Map<string, number[]>();
   stringCounter = 0;
   staticCounter = 0;
+  /** Monotonic id for per-property-access inline-cache globals. */
+  icCounter = 0;
   /**
    * How many `UnsupportedFeature` diagnostics the function currently being
    * emitted produced. Unsupported constructs can leave the generator with a
@@ -187,8 +189,8 @@ export class GeneratorContext {
     if (!symbols.some((symbol) => this.usedAsValue(symbol))) return;
     this.diagnostics.error(
       DiagnosticCode.ModuleNotFound,
-      `module '${specifier}' is not supported: xbintsc can import built-in platform modules, ` +
-        "relative '.ts' files and ESM packages under node_modules; CommonJS packages are not supported",
+      `module '${specifier}' is not supported: expected a Node built-in ` +
+        "(with --ext node), a relative .ts/.js file, or a package in node_modules",
       declaration.moduleSpecifier,
       this.fileNameOf(declaration.moduleSpecifier),
     );
@@ -309,6 +311,19 @@ export class GeneratorContext {
     return ptr;
   }
 
+  /**
+   * Allocate a two-word inline cache for one property-access site and return
+   * the `i64*` the runtime fills with (shape, property index). The global is
+   * zero-initialised, which the runtime treats as an empty cache.
+   */
+  icCachePointer(): string {
+    const name = `@ic.${this.icCounter++}`;
+    this.globals.push(`${name} = internal global [2 x i64] zeroinitializer`);
+    const ptr = this.reg();
+    this.emit(`  ${ptr} = getelementptr [2 x i64], [2 x i64]* ${name}, i64 0, i64 0`);
+    return ptr;
+  }
+
   /** Lay already-computed values out as a contiguous `i64*` argument buffer. */
   emitValueArguments(values: readonly string[]): { argc: string; ptr: string } {
     if (values.length === 0) return { argc: "0", ptr: "null" };
@@ -517,10 +532,15 @@ export class GeneratorContext {
 
   unsupported(node: Node, what: string): void {
     const label = kindName(node.kind);
+    const hasName = label !== String(node.kind);
+    /* `unsupported(statement, "statement")` is the generic fallback; when the
+     * syntax kind has a human name, use it directly instead of appending a
+     * redundant "(statement)". */
+    const subject = what === "statement" && hasName ? `this ${label}` : `this ${what} (${label})`;
     this.unsupportedCount++;
     this.diagnostics.error(
       DiagnosticCode.UnsupportedFeature,
-      `xbintsc does not yet support this ${what} (${label})`,
+      `xbintsc does not yet support ${subject}`,
       node,
       this.fileNameOf(node),
     );

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

@@ -24,6 +24,15 @@ function isStringLike(node: Expression): boolean {
   return node.kind === SyntaxKind.StringLiteral || node.kind === SyntaxKind.NoSubstitutionTemplateLiteral;
 }
 
+/** True for a numeric literal (optionally signed), whose tag check can be skipped. */
+function isNumericLiteral(node: Expression): boolean {
+  if (node.kind === SyntaxKind.NumericLiteral) return true;
+  if (node.kind !== SyntaxKind.PrefixUnaryExpression) return false;
+  const prefix = node as PrefixUnaryExpression;
+  if (prefix.operator !== PrefixUnaryOperator.Minus && prefix.operator !== PrefixUnaryOperator.Plus) return false;
+  return prefix.operand.kind === SyntaxKind.NumericLiteral;
+}
+
 /**
  * The built-in constructor a right-hand `instanceof` operand names, if any.
  * A user binding with the same name shadows it.
@@ -84,7 +93,15 @@ export const operatorExpressionMethods: OperatorExpressionMethods = {
     // `+` concatenates when either side is known to be a string; skip the
     // numeric tag checks for that shape and call the runtime directly.
     const knownStringConcat = operator === "+" && (isStringLike(node.left) || isStringLike(node.right));
-    return this.emitBinaryOperation(left, right, operator, runtime, !knownStringConcat);
+    return this.emitBinaryOperation(
+      left,
+      right,
+      operator,
+      runtime,
+      !knownStringConcat,
+      isNumericLiteral(node.left),
+      isNumericLiteral(node.right),
+    );
   },
 
   emitShortCircuit(node: BinaryExpression, kind: "and" | "or" | "nullish"): string {
@@ -95,15 +112,9 @@ export const operatorExpressionMethods: OperatorExpressionMethods = {
     const endLabel = this.label("sc.end");
     let condition: string;
     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`);
+      condition = this.emitTruthiness(left, node.left);
     } 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`);
+      const isTruthy = this.emitTruthiness(left, node.left);
       condition = this.reg();
       this.emit(`  ${condition} = xor i1 ${isTruthy}, true`);
     } else {
@@ -128,10 +139,7 @@ export const operatorExpressionMethods: OperatorExpressionMethods = {
   emitConditional(node: ConditionalExpression): string {
     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 nonzero = this.emitTruthiness(condition, node.condition);
     const trueLabel = this.label("cond.true");
     const falseLabel = this.label("cond.false");
     const endLabel = this.label("cond.end");
@@ -195,6 +203,9 @@ export const operatorExpressionMethods: OperatorExpressionMethods = {
           one,
           node.operator === PrefixUnaryOperator.PlusPlus ? "+" : "-",
           fn,
+          true,
+          false,
+          true,
         );
         this.emitAssignmentTarget(node.operand, next);
         return next;
@@ -214,6 +225,9 @@ export const operatorExpressionMethods: OperatorExpressionMethods = {
       one,
       node.operator === PostfixUnaryOperator.PlusPlus ? "+" : "-",
       fn,
+      true,
+      false,
+      true,
     );
     this.emitAssignmentTarget(node.operand, next);
     return current;

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

@@ -28,7 +28,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 { BUILTIN_FUNCTION_VALUES, CTOR_FUNCTIONS, ERROR_CONSTRUCTORS } from "../tables.js";
+import { BUILTIN_FUNCTION_VALUES, CTOR_FUNCTIONS, ERROR_CONSTRUCTORS, FIRST_CLASS_CONSTRUCTORS } from "../tables.js";
 import type { Generator } from "../generator.js";
 
 export interface PrimaryExpressionMethods {
@@ -218,6 +218,11 @@ export const primaryExpressionMethods: PrimaryExpressionMethods = {
         return rest;
       }
       default: {
+        if (FIRST_CLASS_CONSTRUCTORS.has(identifier.text)) {
+          // `const A = Array`, `arr.filter(Boolean)`, `new (Map)()`: the
+          // constructor is an ordinary function value backed by the runtime.
+          return this.runtimeCall("xt_builtin_constructor", [this.stringValue(identifier.text)]);
+        }
         const builtinValue = BUILTIN_FUNCTION_VALUES[identifier.text];
         if (builtinValue) {
           // A global like `Boolean` used as a value (`arr.filter(Boolean)`):
@@ -240,6 +245,10 @@ export const primaryExpressionMethods: PrimaryExpressionMethods = {
           this.reportRequireUse(identifier);
           return i64(XT_UNDEFINED);
         }
+        /* The parser's recovery node for a missing expression. The syntax
+         * error has already been reported; "Cannot find name '<error>'" is
+         * pure noise on top of it. */
+        if (identifier.text === "<error>") return i64(XT_UNDEFINED);
         this.diagnostics.error(
           DiagnosticCode.CannotFindName,
           `Cannot find name '${identifier.text}'`,

package/src/codegen/generator/module.ts

@@ -41,7 +41,6 @@ export interface ModuleMethods {
   emitFunctionReturn(this: Generator, value: string): 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;
@@ -101,13 +100,6 @@ export const moduleMethods: ModuleMethods = {
 
   emitFunction(fn: FunctionInfo): void {
     this.unsupportedCount = 0;
-    // `async function*` would need an async iterator and a promise-returning
-    // `.next()`; the generator/async lowering below would silently produce a
-    // synchronous generator instead, so reject it rather than miscompile.
-    if (fn.isAsync && fn.isGenerator) {
-      this.unsupported(fn.node, "async generator function");
-      return;
-    }
     const name = this.functionName(fn);
     const debugSubprogram = this.debugSubprogramFor(fn);
     const state: FunctionState = {
@@ -124,7 +116,11 @@ export const moduleMethods: ModuleMethods = {
       finallyStack: [],
       escapePointers: [],
       usesTry: false,
-      trackFrames: !fn.isGenerator,
+      /* Generator and async bodies run on a private coroutine stack that can be
+       * suspended in the middle of a call. Their shadow frame would then sit on
+       * the shadow stack while the caller unwinds its own, so leave them out of
+       * `Error.stack` frames (nesting calls inside them are still recorded). */
+      trackFrames: !fn.isGenerator && !fn.isAsync,
       ...(debugSubprogram ? { debugSubprogram } : {}),
     };
     this.current = state;
@@ -254,15 +250,17 @@ export const moduleMethods: ModuleMethods = {
       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.emitFunctionReturn(fn.isAsync ? this.wrapAsync(value) : value);
+      this.emitFunctionReturn(value);
     } else {
       const body = (fn.node as { body: Block }).body;
       if (body) this.emitStatements(body.statements);
     }
 
     if (!this.current.terminated) {
-      const fallback = fn.isAsync ? this.wrapAsync(i64(XT_UNDEFINED)) : i64(XT_UNDEFINED);
-      this.emitFunctionReturn(fallback);
+      /* An `async` body returns its value plainly: the runtime's async
+       * coroutine settles the returned promise (and adopts a returned
+       * promise), so wrapping here would add a redundant promise. */
+      this.emitFunctionReturn(i64(XT_UNDEFINED));
     }
 
     const escapes = state.usesTry
@@ -327,13 +325,6 @@ export const moduleMethods: ModuleMethods = {
     this.terminate(`ret i64 ${value}`);
   },
 
-  /** 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;

package/src/codegen/generator/numeric.ts

@@ -12,9 +12,41 @@
  * mask and the operation is `bitcast` → `fadd`/`fcmp` → `bitcast`.
  */
 
+import {
+  BinaryOperator,
+  PrefixUnaryOperator,
+  SyntaxKind,
+  type BinaryExpression,
+  type Expression,
+  type PrefixUnaryExpression,
+} from "../../ast/nodes.js";
 import { i64, XT_FALSE, XT_NUMBER_MASK, XT_TRUE } from "../values.js";
 import type { Generator } from "./generator.js";
 
+/** Operators whose runtime result is always `XT_TRUE` / `XT_FALSE`. */
+const BOOLEAN_BINARY: ReadonlySet<string> = new Set([
+  BinaryOperator.LessThan,
+  BinaryOperator.LessThanEquals,
+  BinaryOperator.GreaterThan,
+  BinaryOperator.GreaterThanEquals,
+  BinaryOperator.EqualsEquals,
+  BinaryOperator.ExclamationEquals,
+  BinaryOperator.EqualsEqualsEquals,
+  BinaryOperator.ExclamationEqualsEquals,
+  BinaryOperator.In,
+  BinaryOperator.InstanceOf,
+]);
+
+/** True when the expression's value is a boolean tag, not an arbitrary value. */
+function isBooleanValue(node: Expression): boolean {
+  if (node.kind === SyntaxKind.TrueKeyword || node.kind === SyntaxKind.FalseKeyword) return true;
+  if (node.kind === SyntaxKind.BinaryExpression) {
+    return BOOLEAN_BINARY.has((node as BinaryExpression).operator as string);
+  }
+  return node.kind === SyntaxKind.PrefixUnaryExpression &&
+    (node as PrefixUnaryExpression).operator === PrefixUnaryOperator.Exclamation;
+}
+
 export interface NumericMethods {
   /**
    * Emit `left <operator> right`, using an inline double fast path when both
@@ -27,11 +59,31 @@ export interface NumericMethods {
     operator: string,
     runtime: string,
     allowFastPath?: boolean,
+    leftKnownNumber?: boolean,
+    rightKnownNumber?: boolean,
+  ): string;
+  emitNumericBinary(
+    this: Generator,
+    left: string,
+    right: string,
+    instruction: string,
+    runtime: string,
+    leftKnownNumber?: boolean,
+    rightKnownNumber?: boolean,
+  ): string;
+  emitNumericComparison(
+    this: Generator,
+    left: string,
+    right: string,
+    predicate: string,
+    runtime: string,
+    leftKnownNumber?: boolean,
+    rightKnownNumber?: boolean,
   ): string;
-  emitNumericBinary(this: Generator, left: string, right: string, instruction: string, runtime: string): string;
-  emitNumericComparison(this: Generator, left: string, right: string, predicate: string, runtime: string): string;
   /** Emit an i1 SSA value that is true when `value` is an unboxed double. */
   isNumberValue(this: Generator, value: string): string;
+  /** Emit an i1 branch condition, folding boolean producers to a tag compare. */
+  emitTruthiness(this: Generator, value: string, expression?: Expression): string;
 }
 
 /** Canonical quiet NaN; the runtime uses the same pattern in `xt_from_double`. */
@@ -57,12 +109,16 @@ const NUMERIC_COMPARISON: Record<string, string | undefined> = {
 };
 
 export const numericMethods: NumericMethods = {
-  emitBinaryOperation(left, right, operator, runtime, allowFastPath = true) {
+  emitBinaryOperation(left, right, operator, runtime, allowFastPath = true, leftKnownNumber = false, rightKnownNumber = false) {
     if (allowFastPath) {
       const instruction = NUMERIC_ARITHMETIC[operator];
-      if (instruction) return this.emitNumericBinary(left, right, instruction, runtime);
+      if (instruction) {
+        return this.emitNumericBinary(left, right, instruction, runtime, leftKnownNumber, rightKnownNumber);
+      }
       const predicate = NUMERIC_COMPARISON[operator];
-      if (predicate) return this.emitNumericComparison(left, right, predicate, runtime);
+      if (predicate) {
+        return this.emitNumericComparison(left, right, predicate, runtime, leftKnownNumber, rightKnownNumber);
+      }
     }
     const result = this.reg();
     this.emit(`  ${result} = call i64 @${runtime}(i64 ${left}, i64 ${right})`);
@@ -78,10 +134,10 @@ export const numericMethods: NumericMethods = {
     return result;
   },
 
-  emitNumericBinary(left, right, instruction, runtime) {
+  emitNumericBinary(left, right, instruction, runtime, leftKnownNumber = false, rightKnownNumber = false) {
     const result = this.alloca();
-    const leftIsNumber = this.isNumberValue(left);
-    const rightIsNumber = this.isNumberValue(right);
+    const leftIsNumber = leftKnownNumber ? "true" : this.isNumberValue(left);
+    const rightIsNumber = rightKnownNumber ? "true" : this.isNumberValue(right);
     const bothNumbers = this.reg();
     this.emit(`  ${bothNumbers} = and i1 ${leftIsNumber}, ${rightIsNumber}`);
     const fast = this.label("num.fast");
@@ -119,10 +175,10 @@ export const numericMethods: NumericMethods = {
     return value;
   },
 
-  emitNumericComparison(left, right, predicate, runtime) {
+  emitNumericComparison(left, right, predicate, runtime, leftKnownNumber = false, rightKnownNumber = false) {
     const result = this.alloca();
-    const leftIsNumber = this.isNumberValue(left);
-    const rightIsNumber = this.isNumberValue(right);
+    const leftIsNumber = leftKnownNumber ? "true" : this.isNumberValue(left);
+    const rightIsNumber = rightKnownNumber ? "true" : this.isNumberValue(right);
     const bothNumbers = this.reg();
     this.emit(`  ${bothNumbers} = and i1 ${leftIsNumber}, ${rightIsNumber}`);
     const fast = this.label("cmp.fast");
@@ -155,4 +211,22 @@ export const numericMethods: NumericMethods = {
     this.emit(`  ${merged} = load i64, i64* ${result}`);
     return merged;
   },
+
+  /**
+   * A comparison, `in`/`instanceof` or `!` already evaluates to a boolean tag,
+   * so its truthiness is a tag compare instead of an `xt_truthy` call. This is
+   * the hot condition in `for (let i = 0; i < n; i++)` loops.
+   */
+  emitTruthiness(value, expression) {
+    if (expression && isBooleanValue(expression)) {
+      const result = this.reg();
+      this.emit(`  ${result} = icmp eq i64 ${value}, ${i64(XT_TRUE)}`);
+      return result;
+    }
+    const truthy = this.reg();
+    this.emit(`  ${truthy} = call i32 @xt_truthy(i64 ${value})`);
+    const result = this.reg();
+    this.emit(`  ${result} = icmp ne i32 ${truthy}, 0`);
+    return result;
+  },
 };

package/src/codegen/generator/state.ts

@@ -104,6 +104,10 @@ export const RUNTIME_DECLARATIONS: readonly string[] = [
   "declare i64 @xt_closure_new(i8*, i32, i64*)",
   "declare i64 @xt_function_set_metadata(i64, i64, i32)",
   "declare i64 @xt_function_set_generator(i64)",
+  "declare i64 @xt_function_set_async(i64)",
+  "declare i64 @xt_function_set_async_generator(i64)",
+  "declare i64 @xt_async_iter_open(i64)",
+  "declare i64 @xt_async_iter_next(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*)",
@@ -111,6 +115,9 @@ export const RUNTIME_DECLARATIONS: readonly string[] = [
   "declare i64 @xt_new(i64, i32, i64*)",
   "declare i64 @xt_instance_of(i64, i64)",
   "declare i64 @xt_instance_of_builtin(i64, i32)",
+  "declare i64 @xt_builtin_constructor(i64)",
+  "declare i64 @xt_array_ctor(i32, i64*)",
+  "declare i64 @xt_object_ctor(i32, i64*)",
   "declare i64 @xt_function_set_prototype(i64, i64)",
   "declare i64 @xt_function_get_prototype(i64)",
   "declare i64 @xt_object_new_with_proto(i64)",
@@ -176,8 +183,17 @@ export const RUNTIME_DECLARATIONS: readonly string[] = [
   "declare i64 @xt_process_get(i64)",
   "declare i64 @xt_map_ctor(i32, i64*)",
   "declare i64 @xt_set_ctor(i32, i64*)",
+  "declare i64 @xt_weak_map_ctor(i32, i64*)",
+  "declare i64 @xt_weak_set_ctor(i32, i64*)",
+  "declare i64 @xt_weak_ref_ctor(i32, i64*)",
+  "declare i64 @xt_text_encoder_ctor(i32, i64*)",
+  "declare i64 @xt_text_decoder_ctor(i32, i64*)",
   "declare i64 @xt_date_ctor(i32, i64*)",
   "declare i64 @xt_regexp_ctor(i32, i64*)",
+  "declare i64 @xt_url_search_params_ctor(i32, i64*)",
+  "declare i64 @xt_array_buffer_ctor(i32, i64*)",
+  "declare i64 @xt_array_buffer_static(i64, i32, i64*)",
+  "declare i64 @xt_data_view_ctor(i32, i64*)",
   "declare i64 @xt_error_ctor(i32, i64*)",
   "declare i64 @xt_type_error_ctor(i32, i64*)",
   "declare i64 @xt_range_error_ctor(i32, i64*)",
@@ -260,6 +276,12 @@ export const RUNTIME_DECLARATIONS: readonly string[] = [
   "declare i64 @xt_clear_timeout(i32, i64*)",
   "declare i64 @xt_set_interval(i32, i64*)",
   "declare i64 @xt_clear_interval(i32, i64*)",
+  "declare i64 @xt_set_immediate(i32, i64*)",
+  "declare i64 @xt_clear_immediate(i32, i64*)",
+  "declare i64 @xt_queue_microtask(i32, i64*)",
+  "declare i64 @xt_performance_get(i64)",
+  "declare i64 @xt_performance_call(i64, i32, i64*)",
+  "declare i64 @xt_structured_clone(i32, i64*)",
   "declare i64 @xt_fetch(i32, i64*)",
   "declare i64 @xt_number_ctor(i32, i64*)",
   "declare i64 @xt_bigint_ctor(i32, i64*)",
@@ -296,6 +318,10 @@ export const RUNTIME_DECLARATIONS: readonly string[] = [
   "declare i64 @xt_builtin_value_clearTimeout(i64, i64, i32, i64*)",
   "declare i64 @xt_builtin_value_setInterval(i64, i64, i32, i64*)",
   "declare i64 @xt_builtin_value_clearInterval(i64, i64, i32, i64*)",
+  "declare i64 @xt_builtin_value_setImmediate(i64, i64, i32, i64*)",
+  "declare i64 @xt_builtin_value_clearImmediate(i64, i64, i32, i64*)",
+  "declare i64 @xt_builtin_value_queueMicrotask(i64, i64, i32, i64*)",
+  "declare i64 @xt_builtin_value_structuredClone(i64, i64, i32, i64*)",
   "declare i64 @xt_builtin_value_fetch(i64, i64, i32, i64*)",
   "declare i64 @xt_builtin_value_number(i64, i64, i32, i64*)",
   "declare i64 @xt_builtin_value_string(i64, i64, i32, i64*)",
@@ -306,6 +332,7 @@ export const RUNTIME_DECLARATIONS: readonly string[] = [
   "declare i64 @xt_symbol_static(i64, i32, i64*)",
   "declare i64 @xt_symbol_get(i64)",
   "declare i64 @xt_get(i64, i64)",
+  "declare i64 @xt_get_ic(i64, i64, i64*)",
   "declare i64 @xt_set(i64, i64, i64)",
   "declare i64 @xt_box_new(i64)",
   "declare i64 @xt_box_get(i64)",

package/src/codegen/generator/statements/control-flow.ts

@@ -71,10 +71,7 @@ export const controlFlowStatementMethods: ControlFlowStatementMethods = {
     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`);
+    const nonzero = this.emitTruthiness(condition, statement.condition);
     this.terminate(`br i1 ${nonzero}, label %${thenLabel}, label %${elseLabel ?? endLabel}`);
 
     this.startBlock(thenLabel);
@@ -250,8 +247,7 @@ export const controlFlowStatementMethods: ControlFlowStatementMethods = {
   },
 
   emitReturn(statement: ReturnStatement): void {
-    let value = statement.expression ? this.emitExpression(statement.expression) : i64(XT_UNDEFINED);
-    if (this.current.fn.isAsync) value = this.wrapAsync(value);
+    const value = statement.expression ? this.emitExpression(statement.expression) : i64(XT_UNDEFINED);
     this.runFinallysBeforeExit(0);
     if (this.current.terminated) return;
     this.popTryFramesTo(0);