xbintsc 0.5.6 → 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

@@ -143,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();
@@ -158,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,9 +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})`);
-    /* `async` functions run on a coroutine: the runtime must know at call time
-     * so it can return a promise and suspend at `await`. */
-    if (fn.isAsync) this.emit(`  call i64 @xt_function_set_async(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/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

@@ -245,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

@@ -100,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 = {

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

@@ -105,6 +105,9 @@ export const RUNTIME_DECLARATIONS: readonly string[] = [
   "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*)",
@@ -180,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*)",
@@ -264,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*)",
@@ -300,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*)",
@@ -310,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);

package/src/codegen/generator/statements/loops.ts

@@ -12,7 +12,7 @@ import {
   type VariableDeclarationList,
   type WhileStatement,
 } from "../../../ast/nodes.js";
-import { numberLiteral } from "../../values.js";
+import { i64, numberLiteral, XT_TRUE } from "../../values.js";
 import type { Generator } from "../generator.js";
 import type { LoopLabels } from "../state.js";
 
@@ -48,10 +48,7 @@ export const loopStatementMethods: LoopStatementMethods = {
     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`);
+    const nonzero = this.emitTruthiness(condition, statement.condition);
     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, labels: this.takePendingLabels() });
@@ -74,10 +71,7 @@ export const loopStatementMethods: LoopStatementMethods = {
 
     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`);
+    const nonzero = this.emitTruthiness(condition, statement.condition);
     this.terminate(`br i1 ${nonzero}, label %${bodyLabel}, label %${endLabel}`);
     this.startBlock(endLabel);
   },
@@ -103,10 +97,7 @@ export const loopStatementMethods: LoopStatementMethods = {
     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`);
+      const nonzero = this.emitTruthiness(condition, statement.condition);
       this.terminate(`br i1 ${nonzero}, label %${bodyLabel}, label %${endLabel}`);
     } else {
       this.terminate(`br label %${bodyLabel}`);
@@ -128,6 +119,50 @@ export const loopStatementMethods: LoopStatementMethods = {
   emitForOf(statement: ForOfStatement | ForInStatement): void {
     const source = this.emitExpression(statement.expression);
     const isForIn = statement.kind === SyntaxKind.ForInStatement;
+    /* `for await (const x of xs)`: resolve the async iteration protocol once,
+     * await one step per iteration, then bind its `value`. Running the await
+     * inside the surrounding async coroutine is what makes the loop suspend
+     * between elements instead of blocking the event loop. */
+    if (!isForIn && (statement as ForOfStatement).awaitModifier) {
+      const iterable = this.runtimeCall("xt_async_iter_open", [source]);
+      const condLabel = this.label("forawait.cond");
+      const bodyLabel = this.label("forawait.body");
+      const updateLabel = this.label("forawait.update");
+      const endLabel = this.label("forawait.end");
+      this.terminate(`br label %${condLabel}`);
+
+      this.startBlock(condLabel);
+      const next = this.runtimeCall("xt_async_iter_next", [iterable]);
+      const step = this.runtimeCall("xt_await", [next]);
+      const doneKey = this.stringValue("done");
+      const done = this.runtimeCall("xt_get", [step, doneKey]);
+      /* `xt_truthy` returns i32, so it cannot go through `runtimeCall`
+       * (which types every result as i64). */
+      const truthy = this.reg();
+      this.emit(`  ${truthy} = call i32 @xt_truthy(i64 ${done})`);
+      const nonzero = this.reg();
+      this.emit(`  ${nonzero} = icmp ne i32 ${truthy}, 0`);
+      this.terminate(`br i1 ${nonzero}, label %${endLabel}, label %${bodyLabel}`);
+
+      this.startBlock(bodyLabel);
+      const valueKey = this.stringValue("value");
+      const element = this.runtimeCall("xt_get", [step, valueKey]);
+      this.bindLoopVariable(statement.initializer, element);
+      this.current.loops.push({
+        breakLabel: endLabel,
+        continueLabel: updateLabel,
+        tryDepth: this.current.tryFrames.length,
+        labels: this.takePendingLabels(),
+      });
+      this.emitStatement(statement.statement);
+      this.current.loops.pop();
+      if (!this.current.terminated) this.terminate(`br label %${updateLabel}`);
+
+      this.startBlock(updateLabel);
+      this.terminate(`br label %${condLabel}`);
+      this.startBlock(endLabel);
+      return;
+    }
     // `for...in` iterates the enumerable keys (indices become strings);
     // `for...of` resolves the iteration protocol once, then walks it.
     const iterable = isForIn
@@ -148,10 +183,9 @@ export const loopStatementMethods: LoopStatementMethods = {
     /* `xt_iter_has` covers generators too, which cannot be sized up front. */
     const hasValue = this.reg();
     this.emit(`  ${hasValue} = call i64 @xt_iter_has(i64 ${iterable}, i64 ${index})`);
-    const truthy = this.reg();
-    this.emit(`  ${truthy} = call i32 @xt_truthy(i64 ${hasValue})`);
+    /* `xt_iter_has` always returns a boolean tag, so skip `xt_truthy`. */
     const nonzero = this.reg();
-    this.emit(`  ${nonzero} = icmp ne i32 ${truthy}, 0`);
+    this.emit(`  ${nonzero} = icmp eq i64 ${hasValue}, ${i64(XT_TRUE)}`);
     this.terminate(`br i1 ${nonzero}, label %${bodyLabel}, label %${endLabel}`);
 
     this.startBlock(bodyLabel);