xbintsc 0.5.6 → 0.5.21

package/src/cli/main.ts

@@ -30,7 +30,6 @@ import {
   thrownFailure,
   toolchainPointer,
   UNEXPECTED_FAILURE_HINT,
-  type DocumentationPointer,
 } from "./hints.js";
 import { createDefaultRegistry, type ExtensionRegistry } from "../extensions/registry.js";
 import { bundledExtensions } from "../extensions/catalog.js";
@@ -44,6 +43,10 @@ import {
   type AppConfig,
   type ProjectConfig,
 } from "../driver/config.js";
+import { fingerprintTree, startWatching } from "./watch.js";
+
+/** Sentinel: watch mode keeps the process alive instead of exiting. */
+const KEEP_RUNNING = -1;
 
 export interface CliIo {
   readonly stdout: (text: string) => void;
@@ -80,6 +83,8 @@ const VALUE_FLAGS = new Set([
   "icon",
   "app-id",
   "app-name",
+  "pgo-generate",
+  "pgo-use",
 ]);
 
 function parseArgs(argv: readonly string[]): ParsedArgs {
@@ -200,22 +205,29 @@ function emitHint(io: CliIo, line: string): void {
  * the question.
  */
 function reportThrown(error: unknown, io: CliIo): number {
-  const message =
-    error instanceof ToolchainError
-      ? `xbintsc: ${error.message}`
-      : `xbintsc: ${error instanceof Error ? error.message : String(error)}`;
-  io.stderr(`${message.trimEnd()}\n`);
-  const text = error instanceof ToolchainError ? error.message : message;
-  const pointer = error instanceof ToolchainError ? toolchainPointer(text) : thrownPointer(text);
-  emitHint(io, `hint: ${pointer.text} — see ${pointer.path}`);
+  if (error instanceof ToolchainError) {
+    io.stderr(`xbintsc: ${error.message.trimEnd()}\n`);
+    const pointer = toolchainPointer(error.message);
+    emitHint(io, `hint: ${pointer.text} — see ${pointer.path}`);
+    return 1;
+  }
+  const message = error instanceof Error ? error.message : String(error);
+  const failure = thrownFailure(message);
+  if (failure === undefined) {
+    /* An uncaught exception that is not a known toolchain/setup failure is a
+     * compiler bug: say so instead of blaming the user's source or toolchain. */
+    io.stderr(`xbintsc: internal error: ${message.trimEnd()}\n`);
+    emitHint(
+      io,
+      `hint: this is a bug in xbintsc, not in your program — please report it with the input that triggered it — see ${UNEXPECTED_FAILURE_HINT.path}`,
+    );
+    return 1;
+  }
+  io.stderr(`xbintsc: ${message.trimEnd()}\n`);
+  emitHint(io, `hint: ${failure.pointer.text} — see ${failure.pointer.path}`);
   return 1;
 }
 
-/** The document that explains a failure the CLI reports as a plain message. */
-function thrownPointer(message: string): DocumentationPointer {
-  return thrownFailure(message)?.pointer ?? UNEXPECTED_FAILURE_HINT;
-}
-
 /** Report a project-config failure, which never becomes a diagnostic bag. */
 function reportConfigError(error: string, io: CliIo): number {
   io.stderr(`xbintsc: ${error}\n`);
@@ -231,6 +243,8 @@ const HELP = `xbintsc ${COMPILER_VERSION} - TypeScript binary compiler
 Usage:
   xbintsc build <file.ts> [options]   Compile to a native binary
   xbintsc run <file.ts> [-- args]     Compile and execute
+  xbintsc check <file.ts>             Parse and bind without linking
+  xbintsc watch <file.ts> [options]   Rebuild whenever the source tree changes
   xbintsc emit <file.ts>              Print LLVM IR
   xbintsc doctor                      Report the resolved toolchain
   xbintsc version                     Print the version
@@ -255,11 +269,15 @@ Options:
       --verbose         Print progress information
       --time            Print per-phase build timings
       --debug           Emit debug info (DWARF/CodeView) and keep frame pointers
+      --lto             Compile program and runtime to LTO bitcode; link with lld
+      --pgo-generate [dir]  Build an instrumented binary writing profiles to dir
+      --pgo-use [dir]   Build with the profiles collected from --pgo-generate
+      --json            Print diagnostics as a JSON array on stdout
       --no-hints        Do not append the "hint: … see <doc>" line to failures
 
 xbintsc compiles a subset of TypeScript to a native binary. Types are erased
-(never checked), Node modules need --ext node, third-party npm imports are not
-supported, and clang 16+ is required to link.
+(never checked), Node built-ins need --ext node, packages in node_modules are
+bundled at build time, and clang 16+ is required to link.
 
 Docs: doc/ai/README.md (task guide) - doc/ai/language-support.md (subset) -
 doc/ai/troubleshooting.md (failures) - llms.txt (index of every document)
@@ -323,7 +341,7 @@ function doctor(io: CliIo): number {
   try {
     if (!toolchain) throw new Error("no toolchain");
     const resource = resolveResourceCompiler(realRunner, toolchain.clang);
-    io.stdout(`icon res   : ${resource ? `${resource.tool} (${resource.kind})` : "none (.exe icon disabled)"}\n`);
+    io.stdout(`icon res   : ${resource ? resource.tool : "none (.exe icon disabled)"}\n`);
   } catch {
     io.stdout("icon res   : unknown\n");
   }
@@ -414,6 +432,57 @@ function dispatch(argv: readonly string[], io: CliIo): number {
     return 0;
   }
 
+  if (command === "check") {
+    const cliEntry = args.positionals[0];
+    const resolved = resolveProjectConfig(args.flags, cliEntry);
+    if (!resolved.ok) return reportConfigError(resolved.error, io);
+    const entry = cliEntry ?? resolved.config.entry;
+    if (!entry) {
+      io.stderr(`xbintsc: check requires a source file (or 'entry' in ${CONFIG_FILE_NAME})\n`);
+      emitHint(io, `hint: pass the entry file, or set 'entry' in ${CONFIG_FILE_NAME} — see ${DOC_CLI}`);
+      return 1;
+    }
+    const extNames = listFlag(args.flags, "ext") ?? resolved.config.extensions ?? [];
+    const nativeManifests = listFlag(args.flags, "ext-native") ?? resolved.config.extNative ?? [];
+    const registry = buildRegistry(extNames, nativeManifests);
+    /* Front-end only: parse, bundle and lower far enough to report binder /
+     * unsupported-feature diagnostics, but never invoke clang or write output. */
+    const { diagnostics } = compileEntry(entry, registry);
+    const failed = diagnostics.some((diagnostic) => diagnostic.category === "error");
+    if (args.flags.has("json")) {
+      io.stdout(`${JSON.stringify(diagnostics)}\n`);
+    } else if (failed) {
+      printDiagnostics(diagnostics, entry, io);
+    }
+    return failed ? 1 : 0;
+  }
+
+  if (command === "watch") {
+    const cliEntry = args.positionals[0];
+    const resolved = resolveProjectConfig(args.flags, cliEntry);
+    if (!resolved.ok) return reportConfigError(resolved.error, io);
+    const entry = cliEntry ?? resolved.config.entry;
+    if (!entry) {
+      io.stderr(`xbintsc: watch requires a source file (or 'entry' in ${CONFIG_FILE_NAME})\n`);
+      emitHint(io, `hint: pass the entry file, or set 'entry' in ${CONFIG_FILE_NAME} — see ${DOC_CLI}`);
+      return 1;
+    }
+    /* Re-enter the normal build path with the same flags, exactly as if the
+     * user had typed `build`; the config is re-read on every rebuild too. */
+    const forwarded = ["build", ...argv.slice(1)];
+    run(forwarded, io);
+    const root = dirname(resolve(entry));
+    startWatching({
+      scan: () => fingerprintTree(root),
+      onRebuild: () => {
+        io.stdout("\n");
+        run(forwarded, io);
+      },
+    });
+    io.stdout(`xbintsc: watching ${root} for changes (Ctrl+C to stop)\n`);
+    return KEEP_RUNNING;
+  }
+
   if (command === "emit") {
     const cliEntry = args.positionals[0];
     const resolved = resolveProjectConfig(args.flags, cliEntry);
@@ -429,6 +498,10 @@ function dispatch(argv: readonly string[], io: CliIo): number {
     const registry = buildRegistry(extNames, nativeManifests);
     const { ir, diagnostics } = compileEntry(entry, registry, { debug: Boolean(args.flags.get("debug")) });
     if (diagnostics.some((d) => d.category === "error")) {
+      if (args.flags.has("json")) {
+        io.stdout(`${JSON.stringify(diagnostics)}\n`);
+        return 1;
+      }
       printDiagnostics(diagnostics, entry, io);
       return 1;
     }
@@ -452,6 +525,24 @@ function dispatch(argv: readonly string[], io: CliIo): number {
     const extNames = listFlag(args.flags, "ext") ?? config.extensions ?? [];
     const nativeManifests = listFlag(args.flags, "ext-native") ?? config.extNative ?? [];
     const registry = buildRegistry(extNames, nativeManifests);
+    const pgoGenerate = args.flags.get("pgo-generate");
+    const pgoUse = args.flags.get("pgo-use");
+    if (pgoGenerate !== undefined && pgoUse !== undefined) {
+      io.stderr("xbintsc: --pgo-generate and --pgo-use are mutually exclusive\n");
+      return 1;
+    }
+    const pgo =
+      pgoGenerate !== undefined
+        ? ("generate" as const)
+        : pgoUse !== undefined
+          ? ("use" as const)
+          : config.pgo;
+    const pgoDir =
+      typeof pgoGenerate === "string"
+        ? pgoGenerate
+        : typeof pgoUse === "string"
+          ? pgoUse
+          : config.pgoDir;
 
     const result = build(entry, {
       output: typeof args.flags.get("output") === "string" ? (args.flags.get("output") as string) : config.output,
@@ -463,9 +554,16 @@ function dispatch(argv: readonly string[], io: CliIo): number {
       extensions: registry,
       app: mergeAppConfig(args.flags, config),
       debug: Boolean(args.flags.get("debug")),
+      lto: Boolean(args.flags.get("lto")) || config.lto === true,
+      ...(pgo ? { pgo } : {}),
+      ...(pgoDir ? { pgoDir } : {}),
     });
 
     if (result.diagnostics.some((d) => d.category === "error")) {
+      if (args.flags.has("json")) {
+        io.stdout(`${JSON.stringify(result.diagnostics)}\n`);
+        return 1;
+      }
       printDiagnostics(result.diagnostics, entry, io);
       return 1;
     }
@@ -493,5 +591,8 @@ function dispatch(argv: readonly string[], io: CliIo): number {
 const isMain =
   process.argv[1] !== undefined && import.meta.url === pathToFileURL(process.argv[1]).href;
 if (isMain) {
-  process.exit(run(process.argv.slice(2)));
+  const status = run(process.argv.slice(2));
+  /* Watch mode returns KEEP_RUNNING; the polling interval keeps the process
+   * alive, so calling process.exit here would stop it immediately. */
+  if (status !== KEEP_RUNNING) process.exit(status);
 }

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 = {