xbintsc 0.5.23 → 0.5.32

package/src/codegen/generator/generator.ts

@@ -9,6 +9,8 @@
 
 import type { SourceFileNode } from "../../ast/nodes.js";
 import type { DiagnosticBag } from "../../diagnostics/diagnostic.js";
+import { bind } from "../../binder/binder.js";
+import { checkProgram } from "../../checker/checker.js";
 import { GeneratorContext } from "./context.js";
 import { moduleMethods, type ModuleMethods } from "./module.js";
 import { statementMethods, type StatementMethods } from "./statements.js";
@@ -45,6 +47,14 @@ export function generate(
   diagnostics: DiagnosticBag,
   options: CodegenOptions = {},
 ): CodegenResult {
-  const generator = new Generator(sourceFile, diagnostics, options);
+  // Bind once: the checker and the generator must see the same symbol table.
+  const binding = bind(sourceFile);
+  if (options.check !== false) {
+    checkProgram(sourceFile, binding, diagnostics, {
+      builtins: options.builtins ?? {},
+      globalValues: options.globalValues ?? {},
+    });
+  }
+  const generator = new Generator(sourceFile, diagnostics, options, binding);
   return { ir: generator.run(), binding: generator.binding };
 }

package/src/codegen/generator/module.ts

@@ -9,11 +9,13 @@ import {
   type ArrowFunction,
   type Block,
   type Expression,
+  type FunctionDeclaration,
   type Parameter,
 } from "../../ast/nodes.js";
 import type { ClassInfo, FunctionInfo, SymbolInfo } from "../../binder/binder.js";
 import { SymbolKind } from "../../binder/binder.js";
 import { i64, XT_UNDEFINED } from "../values.js";
+import { ARTIFACT_LINE_ENDING, artifactPath } from "../../canonical.js";
 import { RUNTIME_DECLARATIONS, type FunctionState } from "./state.js";
 import { propertyNameText } from "./tables.js";
 import type { Generator } from "./generator.js";
@@ -38,12 +40,15 @@ function symbolSuffix(name: string): string {
 export interface ModuleMethods {
   run(this: Generator): string;
   emitFunction(this: Generator, fn: FunctionInfo): void;
+  emitHoistedFunctions(this: Generator, fn: FunctionInfo): void;
   emitFunctionReturn(this: Generator, value: string): void;
   emitMain(this: Generator): void;
   functionName(this: Generator, fn: FunctionInfo): string;
   classGlobal(this: Generator, classInfo: ClassInfo): string;
   emitClassReference(this: Generator, classInfo: ClassInfo): string;
   emitClassSetup(this: Generator, classInfo: ClassInfo): void;
+  memberKey(this: Generator, method: FunctionInfo): string;
+  emitMemberDefine(this: Generator, target: string, method: FunctionInfo, key: string, fnValue: string): void;
   emitDefaultParameter(this: Generator, symbol: SymbolInfo, value: string, initializer: Expression): void;
 }
 
@@ -75,7 +80,7 @@ export const moduleMethods: ModuleMethods = {
     // the self-hosting fixpoint) is identical whether the compiler runs on
     // Node (which uses `\` on Windows) or as a compiled binary (which always
     // produces `/`).
-    const sourceName = this.sourceFile.fileName.split("\\").join("/");
+    const sourceName = artifactPath(this.sourceFile.fileName);
     const header = [
       "; ModuleID = 'xbintsc'",
       "source_filename = \"" + sourceName + "\"",
@@ -93,7 +98,7 @@ export const moduleMethods: ModuleMethods = {
       ...this.functions,
       "",
       ...this.debugMetadataLines(),
-    ].join("\n");
+    ].join(ARTIFACT_LINE_ENDING);
   },
 
   // -- module level --------------------------------------------------------
@@ -149,7 +154,7 @@ export const moduleMethods: ModuleMethods = {
       /* Normalise separators like `source_filename`: the compiler may run under
        * Node (`\`) or as a self-hosted binary (`/`), and the IR must stay
        * byte-identical across the two. */
-      const filePointer = this.internStatic(this.fileNameOf(fn.node).split("\\").join("/"));
+      const filePointer = this.internStatic(artifactPath(this.fileNameOf(fn.node)));
       this.emit(
         `  call void @xt_stack_push(i8* ${namePointer}, i8* ${filePointer}, i32 ${this.lineOf(fn.node)})`,
       );
@@ -189,6 +194,14 @@ export const moduleMethods: ModuleMethods = {
       this.defineCaptureSlot(symbol, value);
     }
 
+    // Hoisted function declarations: create their closure values in this
+    // frame (before the body runs) so a nested function that references one
+    // gets the closure built against the declaring frame, not against the
+    // caller's slots. Captured function symbols are boxed by the binder, so
+    // the second pass publishes the closures into those boxes and mutual
+    // recursion sees the same values.
+    this.emitHoistedFunctions(fn);
+
     // Arrow functions inherit `this` lexically; it travels as an extra capture.
     if (fn.isArrow && fn.capturesThis) {
       const inherited = this.reg();
@@ -267,7 +280,7 @@ export const moduleMethods: ModuleMethods = {
       ? state.escapePointers.map((ptr) => `  call void asm sideeffect "", "r"(i64* ${ptr})`)
       : [];
     const lines = [...state.allocas.map((a) => `  ${a}`), ...escapes, ...state.buffer];
-    this.functions.push([header, ...lines, "}", ""].join("\n"));
+    this.functions.push([header, ...lines, "}", ""].join(ARTIFACT_LINE_ENDING));
   },
 
   emitMain(): void {
@@ -307,7 +320,7 @@ export const moduleMethods: ModuleMethods = {
         "  ret i32 0",
         "}",
         "",
-      ].join("\n"),
+      ].join(ARTIFACT_LINE_ENDING),
     );
   },
 
@@ -334,6 +347,46 @@ export const moduleMethods: ModuleMethods = {
     return name;
   },
 
+  emitHoistedFunctions(fn: FunctionInfo): void {
+    if (fn.isModule) return;
+    const body = (fn.node as { body?: Block }).body;
+    if (!body || body.kind !== SyntaxKind.Block) return;
+    const declarations: FunctionDeclaration[] = [];
+    for (const statement of body.statements) {
+      if (statement.kind === SyntaxKind.FunctionDeclaration) {
+        declarations.push(statement as FunctionDeclaration);
+      }
+    }
+    if (declarations.length === 0) return;
+    /* Captured locals of this frame may be declared textually after the
+     * function that uses them. Function declarations are hoisted, so create
+     * their boxes now; the `let`/`const`/`var` statement fills the box when it
+     * runs (emitVariableStatement writes into an existing slot). */
+    for (const declaration of declarations) {
+      const child = this.binding.functionOfNode.get(declaration);
+      if (!child) continue;
+      for (const captured of child.captures) {
+        if (captured.fn !== fn) continue;
+        if (!this.current.slots.has(captured.id)) this.declareSlot(captured, i64(XT_UNDEFINED));
+      }
+    }
+    /* First pass: a slot (and a box, when captured) exists for every name
+     * before any closure is built, so sibling references cannot observe an
+     * uninitialised slot. */
+    const ready: Array<{ symbol: SymbolInfo; child: FunctionInfo }> = [];
+    for (const declaration of declarations) {
+      const symbol = this.binding.symbolOfDeclaration.get(declaration);
+      const child = this.binding.functionOfNode.get(declaration);
+      if (!symbol || !child) continue;
+      if (!this.current.slots.has(symbol.id)) this.declareSlot(symbol, i64(XT_UNDEFINED));
+      ready.push({ symbol, child });
+    }
+    /* Second pass: build and store the closures. */
+    for (const entry of ready) {
+      this.writeSlot(entry.symbol, this.emitClosureValue(entry.child));
+    }
+  },
+
   emitClassReference(classInfo: ClassInfo): string {
     const globalName = this.classGlobal(classInfo);
     const value = this.reg();
@@ -346,18 +399,23 @@ export const moduleMethods: ModuleMethods = {
     const globalName = this.classGlobal(classInfo);
     const proto = this.reg();
     this.emit(`  ${proto} = call i64 @xt_object_new()`);
+    /* The parent constructor value, emitted once: it is used both for the
+     * instance prototype and for static inheritance (`Dog.kind` sees
+     * `Animal.kind`), and evaluating `extends mixin()` twice would run the
+     * expression twice. */
+    let parentValue: string | undefined;
     if (classInfo.parentExpression) {
       // `extends Error` / `extends TypeError` / other host builtins: chain the
       // subclass prototype onto the builtin's prototype so `instanceof` works.
       const parent = classInfo.parentExpression;
       const errorName = this.errorFamilyName(parent);
+      parentValue = this.emitExpression(parent);
       if (errorName) {
         const nameValue = this.stringValue(errorName);
         const parentProto = this.reg();
         this.emit(`  ${parentProto} = call i64 @xt_error_prototype(i64 ${nameValue})`);
         this.emit(`  call i64 @xt_object_set_prototype(i64 ${proto}, i64 ${parentProto})`);
       } else {
-        const parentValue = this.emitExpression(parent);
         const parentProto = this.reg();
         this.emit(`  ${parentProto} = call i64 @xt_function_get_prototype(i64 ${parentValue})`);
         this.emit(`  call i64 @xt_object_set_prototype(i64 ${proto}, i64 ${parentProto})`);
@@ -365,36 +423,69 @@ export const moduleMethods: ModuleMethods = {
     }
     for (const method of classInfo.methods) {
       const fnValue = this.emitClosureValue(method);
-      const key = method.computedKey
-        ? this.emitExpression(method.computedKey)
-        : this.stringValue(method.name);
-      const accessor = (method.node as { accessor?: "get" | "set" }).accessor;
-      if (accessor === "get") {
-        this.emit(`  call i64 @xt_object_define_getter(i64 ${proto}, i64 ${key}, i64 ${fnValue})`);
-      } else if (accessor === "set") {
-        this.emit(`  call i64 @xt_object_define_setter(i64 ${proto}, i64 ${key}, i64 ${fnValue})`);
-      } else {
-        this.emit(`  call i64 @xt_set(i64 ${proto}, i64 ${key}, i64 ${fnValue})`);
-      }
+      const key = this.memberKey(method);
+      this.emitMemberDefine(proto, method, key, fnValue);
     }
     const ctor = this.emitClosureValue(classInfo.ctor!);
     this.emit(`  call i64 @xt_function_set_prototype(i64 ${ctor}, i64 ${proto})`);
+    /* Static members are inherited through the constructor's property bag. */
+    if (parentValue) {
+      this.emit(`  call i64 @xt_object_set_prototype(i64 ${ctor}, i64 ${parentValue})`);
+    }
+    /* `A.prototype.constructor === A`: the standard property, and what
+     * `new this.constructor()` (Three.js `Matrix3.clone`, …) relies on. The
+     * hidden `__ctor` beside it is the internal hook `super(...)` and the
+     * implicit derived constructor read; keeping both means `constructor` can
+     * be overwritten by user code without breaking inheritance. */
     const ctorKey = this.stringValue("__ctor");
     this.emit(`  call i64 @xt_set(i64 ${proto}, i64 ${ctorKey}, i64 ${ctor})`);
+    const constructorKey = this.stringValue("constructor");
+    this.emit(`  call i64 @xt_set(i64 ${proto}, i64 ${constructorKey}, i64 ${ctor})`);
+    /* Publish the constructor before static fields and blocks run: they may
+     * refer to the class by name (`static { A.count = 1 }`), and by then the
+     * class binding is already initialised in JavaScript. */
+    this.emit(`  store i64 ${ctor}, i64* ${globalName}`);
     for (const method of classInfo.statics) {
       const fnValue = this.emitClosureValue(method);
-      const key = method.computedKey
-        ? this.emitExpression(method.computedKey)
-        : this.stringValue(method.name);
-      this.emit(`  call i64 @xt_set(i64 ${ctor}, i64 ${key}, i64 ${fnValue})`);
+      const key = this.memberKey(method);
+      /* `static get x()` / `static set x(v)` are accessors on the constructor
+       * value, not plain data properties. */
+      this.emitMemberDefine(ctor, method, key, fnValue);
     }
-    for (const field of classInfo.fields) {
-      if (!field.isStatic) continue;
+    for (const entry of classInfo.staticInit) {
+      if (entry.kind === "block") {
+        /* `static { ... }` blocks run once, in order, with `this` bound to the
+         * class constructor. They are compiled as static methods and called
+         * immediately, which gives them their own scope and a normal `this`. */
+        const fnValue = this.emitClosureValue(entry.fn);
+        this.emit(`  call i64 @xt_call_with_this(i64 ${fnValue}, i64 ${ctor}, i32 0, i64* null)`);
+        continue;
+      }
+      const field = entry.field;
       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}`);
+  },
+
+  /** The property key of a class member: evaluated when computed. */
+  memberKey(method: FunctionInfo): string {
+    return method.computedKey
+      ? this.emitExpression(method.computedKey)
+      : this.stringValue(method.name);
+  },
+
+  /** Install a class member as a data property, or as an accessor when it was
+   *  declared with `get` / `set`. */
+  emitMemberDefine(target: string, method: FunctionInfo, key: string, fnValue: string): void {
+    const accessor = (method.node as { accessor?: "get" | "set" }).accessor;
+    if (accessor === "get") {
+      this.emit(`  call i64 @xt_object_define_getter(i64 ${target}, i64 ${key}, i64 ${fnValue})`);
+    } else if (accessor === "set") {
+      this.emit(`  call i64 @xt_object_define_setter(i64 ${target}, i64 ${key}, i64 ${fnValue})`);
+    } else {
+      this.emit(`  call i64 @xt_set(i64 ${target}, i64 ${key}, i64 ${fnValue})`);
+    }
   },
 
   emitDefaultParameter(symbol: SymbolInfo, value: string, initializer: Expression): void {

package/src/codegen/generator/state.ts

@@ -4,7 +4,7 @@
 
 import type { FunctionInfo } from "../../binder/binder.js";
 import type { BindResult } from "../../binder/binder.js";
-import type { BuiltinFunction, ExtensionModule } from "../../extensions/registry.js";
+import type { BuiltinFunction, ExtensionModule, GlobalValue } from "../../extensions/registry.js";
 import type { Block } from "../../ast/nodes.js";
 
 export interface Slot {
@@ -70,6 +70,8 @@ export interface CodegenResult {
 export interface CodegenOptions {
   /** Global names supplied by registered extensions. */
   readonly builtins?: Readonly<Record<string, BuiltinFunction>>;
+  /** Global *values* supplied by registered extensions (`window`, `document`). */
+  readonly globalValues?: Readonly<Record<string, GlobalValue>>;
   /** Importable modules supplied by registered extensions. */
   readonly modules?: Readonly<Record<string, ExtensionModule>>;
   /**
@@ -91,6 +93,14 @@ export interface CodegenOptions {
    * debugging; `xbintsc build --debug` turns it on.
    */
   readonly debug?: boolean;
+  /**
+   * Run the semantic checker before lowering (default **true**). It reports
+   * unresolved names, redeclarations and call-arity mismatches; `--no-check`
+   * (or `check: false` programmatically) restores the previous permissive
+   * behaviour. Code generation skips its own unresolved-name diagnostic while
+   * the checker is on, so the error is reported exactly once.
+   */
+  readonly check?: boolean;
 }
 
 export const RUNTIME_DECLARATIONS: readonly string[] = [

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

@@ -33,9 +33,12 @@ export const variableStatementMethods: VariableStatementMethods = {
           continue;
         }
         if (this.current.slots.has(symbol.id)) {
-          // Hoisted `var` (or an already-declared slot): keep evaluating the
-          // initializer for its side effects, but do not redeclare the slot.
-          if (declaration.initializer) this.emitExpression(declaration.initializer);
+          // Hoisted `var`, or a box created early for a captured binding
+          // declared textually after a hoisted function: do not redeclare the
+          // slot, but assigning an initializer is still part of the statement.
+          if (declaration.initializer) {
+            this.writeSlot(symbol, this.emitExpression(declaration.initializer));
+          }
           continue;
         }
         if (symbol.boxed) {
@@ -107,17 +110,34 @@ export const variableStatementMethods: VariableStatementMethods = {
     }
   },
 
-  /** `x = fallback` in a binding pattern: only apply when `x` is `undefined`. */
+  /**
+   * `x = fallback` in a binding pattern: only apply when `x` is `undefined`.
+   *
+   * The initializer is emitted inside its own block, so it is evaluated *only*
+   * when the property is missing — the specification's order. A `select` cannot
+   * do that: it would evaluate the fallback unconditionally, which runs side
+   * effects and throws for defaults like `canvas = createCanvasElement()` that
+   * assume they are only reached when the caller passed nothing.
+   */
   emitBindingDefault(value: string, initializer: Expression): string {
-    const fallback = this.emitExpression(initializer);
+    const slot = this.alloca();
+    this.emit(`  store i64 ${value}, i64* ${slot}`);
     const isUndefined = this.reg();
     this.emit(`  ${isUndefined} = call i64 @xt_seq(i64 ${value}, i64 ${i64(XT_UNDEFINED)})`);
     const truthy = this.reg();
     this.emit(`  ${truthy} = call i32 @xt_truthy(i64 ${isUndefined})`);
     const condition = this.reg();
     this.emit(`  ${condition} = icmp ne i32 ${truthy}, 0`);
+    const defaultLabel = this.label("bind.default");
+    const endLabel = this.label("bind.end");
+    this.terminate(`br i1 ${condition}, label %${defaultLabel}, label %${endLabel}`);
+    this.startBlock(defaultLabel);
+    const fallback = this.emitExpression(initializer);
+    this.emit(`  store i64 ${fallback}, i64* ${slot}`);
+    this.terminate(`br label %${endLabel}`);
+    this.startBlock(endLabel);
     const result = this.reg();
-    this.emit(`  ${result} = select i1 ${condition}, i64 ${fallback}, i64 ${value}`);
+    this.emit(`  ${result} = load i64, i64* ${slot}`);
     return result;
   },
 

package/src/codegen/generator/tables.ts

@@ -283,6 +283,11 @@ export const SYMBOL_WELL_KNOWN = new Set<string>([
   "unscopables",
 ]);
 
+/** Namespaces that also exist as a first-class object value (`Math.cos`). */
+export const NAMESPACE_VALUES: Record<string, string> = {
+  Math: "xt_math_object",
+};
+
 /** Namespace identifiers whose property access maps to a runtime getter. */
 export const NAMESPACE_PROPERTIES: Record<string, string> = {
   process: "xt_process_get",

package/src/driver/build-key.ts

@@ -27,6 +27,8 @@ export interface CacheKeyInput {
   readonly app: AppConfig;
   readonly debug: boolean;
   readonly lto: boolean;
+  /** Whether the semantic checker ran (default true). */
+  readonly check?: boolean;
   readonly pgo?: PgoMode;
   readonly pgoDir: string;
 }
@@ -49,6 +51,7 @@ export function buildCacheKey(input: CacheKeyInput): string {
     app.bundleId ?? "",
     String(input.debug),
     String(input.lto),
+    String(input.check !== false),
     pgo ?? "",
     pgo ? input.pgoDir : "",
   ]);

package/src/driver/bundler/graph.ts

@@ -14,7 +14,7 @@ import { Parser } from "../../parser/parser.js";
 import type { AssetLoader } from "../../extensions/registry.js";
 import { classifyDependency } from "./resolve.js";
 import { collectRequireSites, isNodeModulesPath, usesCommonJS } from "./commonjs.js";
-import type { ModuleRecord } from "./types.js";
+import type { ModuleRecord, OriginRange } from "./types.js";
 
 /**
  * True when an import has no runtime binding, so it is not a module edge:
@@ -109,9 +109,12 @@ export function loadGraph(
      * module before it is parsed. The core only sees the transformed text. */
     const loader = assetLoaders[extname(path).toLowerCase()];
     let text = raw;
+    let originRanges: readonly OriginRange[] | undefined;
     if (loader) {
       try {
-        text = loader(path, raw).moduleSource;
+        const loaded = loader(path, raw);
+        text = loaded.moduleSource;
+        originRanges = loaded.sourceRanges;
       } catch (error) {
         diagnostics.error(
           DiagnosticCode.CodegenError,
@@ -136,6 +139,7 @@ export function loadGraph(
       originalNames: new Map(),
       finalNames: new Map(),
       commonjs: false,
+      originRanges,
     };
     // `require` / `module` / `exports` are only honoured inside `node_modules`,
     // so user code keeps its ESM-only diagnostic.

package/src/driver/bundler/merge.ts

@@ -176,9 +176,22 @@ export function bundleModules(
    * diagnostic can name the right file and line instead of pointing into the
    * entry module (whose text happens to start at the same offsets). */
   const origins = new Map<object, string>();
+  /* A synthesized module (an extension asset loader such as the `gui` `.html`
+   * transform) may contain spans copied from another file — a `<script
+   * src="app.js">` body, say. Nodes inside such a span keep that file, so a
+   * diagnostic points at real source and a plain-`.js` script stays exempt
+   * from the type checker. */
+  const originOf = (record: ModuleRecord, node: Node): string => {
+    const ranges = record.originRanges;
+    if (ranges === undefined) return record.path;
+    for (const range of ranges) {
+      if (node.start >= range.start && node.end <= range.end) return range.file;
+    }
+    return record.path;
+  };
   const trackOrigin = (record: ModuleRecord, root: Node): void => {
     const visit = (node: Node): void => {
-      origins.set(node, record.path);
+      origins.set(node, originOf(record, node));
       const fields = node as unknown as Record<string, unknown>;
       for (const key of Object.keys(fields)) {
         if (key === "kind" || key === "start" || key === "end" || key === "text" || key === "value" || key === "raw") {

package/src/driver/bundler/types.ts

@@ -5,6 +5,13 @@
 import type { SourceFileNode } from "../../ast/nodes.js";
 import type { BindResult } from "../../binder/binder.js";
 
+/** A `[start, end)` span of a synthesized module that came from `file`. */
+export interface OriginRange {
+  readonly start: number;
+  readonly end: number;
+  readonly file: string;
+}
+
 export interface ModuleRecord {
   readonly path: string;
   readonly text: string;
@@ -25,6 +32,12 @@ export interface ModuleRecord {
   commonjs: boolean;
   /** Synthetic `module` object for a CommonJS module (`<prefix>$cjs_module`). */
   cjsModule?: string;
+  /**
+   * Spans of a *synthesized* module text that were copied from another file
+   * (an extension asset loader's `sourceRanges`). Nodes inside one keep that
+   * file as their origin instead of `path`.
+   */
+  originRanges?: readonly OriginRange[];
 }
 
 export interface BundleResult {

package/src/driver/compiler.ts

@@ -31,7 +31,7 @@ import { buildCacheKey } from "./build-key.js";
 import type { BuildOptions, BuildResult, EmitKind, PhaseTiming } from "./options.js";
 
 export { COMPILER_VERSION } from "./version.js";
-export { compileString, compileEntry, parseEntry, type ParsedEntry } from "./frontend.js";
+export { compileString, compileEntry, parseEntry, type FrontendOptions, type ParsedEntry } from "./frontend.js";
 export { RUNTIME_SOURCES, type RuntimeObjects } from "./runtime-objects.js";
 export type { BuildOptions, BuildResult, CompileStringResult, EmitKind, PhaseTiming } from "./options.js";
 
@@ -128,6 +128,7 @@ export function build(entryPath: string, options: BuildOptions = {}): BuildResul
     app,
     debug: options.debug === true,
     lto,
+    check: options.check !== false,
     pgo,
     pgoDir,
   });
@@ -149,9 +150,11 @@ export function build(entryPath: string, options: BuildOptions = {}): BuildResul
   const codegenStarted = Date.now();
   const { ir } = generate(parsed.sourceFile, diagnostics, {
     builtins: registry.builtins(),
+    globalValues: registry.globalValues(),
     modules: registry.modules(),
     moduleHints: registry.moduleHints(),
     debug: options.debug === true,
+    check: options.check !== false,
   });
   timings.push({ phase: "codegen", ms: Date.now() - codegenStarted });
 

package/src/driver/fingerprint.ts

@@ -11,6 +11,7 @@ import { existsSync, readFileSync, readdirSync } from "node:fs";
 import { dirname, join, relative, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 import type { ExtensionRegistry } from "../extensions/registry.js";
+import { artifactPath } from "../canonical.js";
 import { hashParts } from "./cache.js";
 
 /** Runtime sources, headers and `#include`d `.inc` fragments, plus prebuilt archives. */
@@ -56,7 +57,7 @@ export function compilerFingerprint(): string {
         if (entry.isDirectory()) {
           walk(full);
         } else if (entry.name.endsWith(".ts")) {
-          parts.push(relative(sourceRoot, full).replace(/\\/g, "/"), readFileSync(full, "utf8"));
+          parts.push(artifactPath(relative(sourceRoot, full)), readFileSync(full, "utf8"));
         }
       }
     };

package/src/driver/frontend.ts

@@ -32,6 +32,13 @@ function externalModuleSpecifiers(registry: ExtensionRegistry): Set<string> {
   ]);
 }
 
+/** Front-end switches shared by `compileString` and `compileEntry`. */
+export interface FrontendOptions {
+  readonly debug?: boolean;
+  /** Run the semantic checker (default true; `--no-check` disables it). */
+  readonly check?: boolean;
+}
+
 /** A parsed (and, for module entries, already bundled) entry file. */
 export interface ParsedEntry {
   readonly absoluteEntry: string;
@@ -78,7 +85,7 @@ export function compileString(
   source: string,
   fileName = "input.ts",
   extensions?: ExtensionRegistry,
-  options: { readonly debug?: boolean } = {},
+  options: FrontendOptions = {},
 ): CompileStringResult {
   const file = new SourceFile(fileName, source);
   const diagnostics = new DiagnosticBag();
@@ -90,9 +97,11 @@ export function compileString(
   if (diagnostics.hasErrors) return { ir: "", diagnostics: diagnostics.diagnostics };
   const { ir } = generate(sourceFile, diagnostics, {
     builtins: registry.builtins(),
+    globalValues: registry.globalValues(),
     modules: registry.modules(),
     moduleHints: registry.moduleHints(),
     debug: options.debug === true,
+    check: options.check !== false,
   });
   return { ir, diagnostics: diagnostics.diagnostics };
 }
@@ -104,7 +113,7 @@ export function compileString(
 export function compileEntry(
   entryPath: string,
   extensions?: ExtensionRegistry,
-  options: { readonly debug?: boolean } = {},
+  options: FrontendOptions = {},
 ): CompileStringResult {
   const registry = extensions ?? createDefaultRegistry();
   const diagnostics = new DiagnosticBag();
@@ -112,9 +121,11 @@ export function compileEntry(
   if (diagnostics.hasErrors) return { ir: "", diagnostics: diagnostics.diagnostics };
   const { ir } = generate(parsed.sourceFile, diagnostics, {
     builtins: registry.builtins(),
+    globalValues: registry.globalValues(),
     modules: registry.modules(),
     moduleHints: registry.moduleHints(),
     debug: options.debug === true,
+    check: options.check !== false,
   });
   return { ir, diagnostics: diagnostics.diagnostics };
 }

package/src/driver/options.ts

@@ -35,6 +35,12 @@ export interface BuildOptions {
   readonly app?: AppConfig;
   /** Emit LLVM debug metadata so `-g` produces DWARF/CodeView (default false). */
   readonly debug?: boolean;
+  /**
+   * Run the semantic checker before lowering (default true). `--no-check`
+   * disables it; the incremental cache keys on this flag, so a checked and an
+   * unchecked build of the same source cannot reuse each other's artifacts.
+   */
+  readonly check?: boolean;
   /** Compile the program and runtime to LTO bitcode and link with lld. */
   readonly lto?: boolean;
   /**

package/src/driver/version.ts

@@ -9,4 +9,4 @@
  * `main`/`master` only (see `.githooks/pre-commit`), so feature branches never
  * change this line and merging two of them cannot conflict here.
  */
-export const COMPILER_VERSION = "0.5.23";
+export const COMPILER_VERSION = "0.5.32";