xbintsc 0.3.81 → 0.3.87

package/src/cli/main.ts

@@ -18,11 +18,11 @@ import { dirname, resolve } from "node:path";
 import { pathToFileURL } from "node:url";
 import { formatDiagnostic, type Diagnostic } from "../diagnostics/diagnostic.js";
 import { SourceFile } from "../diagnostics/source.js";
-import { build, compileEntry, COMPILER_VERSION, type EmitKind } from "../driver/compiler.js";
+import { build, compileEntry, COMPILER_VERSION, type EmitKind, type PhaseTiming } from "../driver/compiler.js";
 import { findRuntimeDir, platformSlug } from "../driver/paths.js";
 import { runtimeLibDir } from "../driver/runtime-lib.js";
-import { resolveToolchain } from "../driver/toolchain-provider.js";
-import { realRunner, ToolchainError } from "../driver/toolchain.js";
+import { resolveToolchain, type ResolvedToolchain } from "../driver/toolchain-provider.js";
+import { MINIMUM_CLANG_MAJOR, probeClang, realRunner, ToolchainError } from "../driver/toolchain.js";
 import {
   DOC_CLI,
   DOC_TROUBLESHOOTING,
@@ -154,23 +154,39 @@ function buildRegistry(extNames: readonly string[], nativeManifests: readonly st
 }
 
 function printDiagnostics(diagnostics: readonly Diagnostic[], fileName: string, io: CliIo): void {
-  let source: SourceFile | undefined;
-  try {
-    source = new SourceFile(fileName, readFileSync(fileName, "utf8"));
-  } catch {
-    source = undefined;
-  }
+  /* A diagnostic can come from any module in a bundled program, so load (and
+   * cache) the source of the file it names instead of always using the entry:
+   * reusing the entry's text is what used to print another file's line with a
+   * caret under unrelated code. */
+  const sources = new Map<string, SourceFile | undefined>();
+  const sourceFor = (name: string): SourceFile | undefined => {
+    if (!sources.has(name)) {
+      try {
+        sources.set(name, new SourceFile(name, readFileSync(name, "utf8")));
+      } catch {
+        sources.set(name, undefined);
+      }
+    }
+    return sources.get(name);
+  };
   for (const diagnostic of diagnostics) {
     // Driver-level diagnostics (icon, config, …) have no source location.
     if (diagnostic.fileName === undefined && diagnostic.start === undefined) {
       io.stderr(`error TS${diagnostic.code}: ${diagnostic.message}\n`);
       continue;
     }
+    const source = sourceFor(diagnostic.fileName ?? fileName);
     io.stderr(formatDiagnostic(diagnostic, source) + "\n");
   }
   for (const hint of documentationHints(diagnostics)) emitHint(io, hint);
 }
 
+/** Print the phases collected by `--time`. */
+function printTimings(timings: readonly PhaseTiming[], io: CliIo): void {
+  const text = timings.map((timing) => `${timing.phase} ${timing.ms}ms`).join(", ");
+  io.stdout(`xbintsc: timing (${text})\n`);
+}
+
 /** Print one `hint:` line unless the caller asked for plain output. */
 function emitHint(io: CliIo, line: string): void {
   if (hintsDisabled) return;
@@ -237,6 +253,8 @@ Options:
       --app-id <id>     macOS bundle identifier (e.g. com.example.demo)
       --force           Ignore the incremental cache
       --verbose         Print progress information
+      --time            Print per-phase build timings
+      --debug           Emit debug info (DWARF/CodeView) and keep frame pointers
       --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
@@ -247,26 +265,47 @@ Docs: doc/ai/README.md (task guide) - doc/ai/language-support.md (subset) -
 doc/ai/troubleshooting.md (failures) - llms.txt (index of every document)
 `;
 
-function firstLine(text: string): string {
-  const index = text.indexOf("\n");
-  return (index === -1 ? text : text.slice(0, index)).trim();
-}
-
-/** Report the resolved toolchain and runtime locations. */
+/**
+ * Report the resolved toolchain and runtime locations.
+ *
+ * Returns non-zero when the resolved compiler cannot build anything (missing,
+ * or older than {@link MINIMUM_CLANG_MAJOR}), so CI and scripts can use it as a
+ * preflight instead of discovering the problem halfway through a build.
+ */
 function doctor(io: CliIo): number {
   io.stdout(`xbintsc ${COMPILER_VERSION}\n`);
   io.stdout(`platform   : ${platformSlug()}\n`);
 
+  let toolchain: ResolvedToolchain | undefined;
+  let usable = false;
   try {
-    const toolchain = resolveToolchain();
-    const version = realRunner.run(toolchain.clang, ["--version"], { env: toolchain.env }).stdout;
+    toolchain = resolveToolchain();
+    const probe = probeClang(realRunner, toolchain.clang, toolchain.env);
     io.stdout(`toolchain  : ${toolchain.clang} (${toolchain.source})\n`);
-    io.stdout(`compiler   : ${firstLine(version) || "unknown"}\n`);
-  } catch {
-    io.stdout("toolchain  : not found\n");
-    io.stdout("  install one of: Xcode Command Line Tools (`xcode-select --install`) on macOS,\n");
-    io.stdout("  clang+lld (apt/dnf/pacman) on Linux, or LLVM + Visual Studio C++ build tools on Windows,\n");
-    io.stdout("  then re-run; or set xbintsc_CLANG to a clang binary. See doc/requirements.md.\n");
+    io.stdout(`compiler   : ${probe.summary || "unknown"}\n`);
+    const version = toolchain.version ?? probe.version;
+    if (!version) {
+      // An explicit wrapper need not print a clang-style version; let it run.
+      usable = true;
+      io.stdout(`status     : version unknown (requires clang >= ${MINIMUM_CLANG_MAJOR})\n`);
+    } else if (version.major >= MINIMUM_CLANG_MAJOR) {
+      usable = true;
+      io.stdout(`status     : ok (requires clang >= ${MINIMUM_CLANG_MAJOR})\n`);
+    } else {
+      io.stdout(
+        `status     : too old: clang ${version.major}.${version.minor}.${version.patch} ` +
+          `(requires >= ${MINIMUM_CLANG_MAJOR})\n`,
+      );
+      io.stdout("  set xbintsc_CLANG to a newer clang; on Windows Visual Studio ships one under\n");
+      io.stdout("  <VS install>\\VC\\Tools\\Llvm\\x64\\bin\\clang.exe. See doc/requirements.md.\n");
+    }
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    io.stdout("toolchain  : not usable\n");
+    for (const line of message.split("\n")) {
+      if (line.trim().length > 0) io.stdout(`  ${line.trim()}\n`);
+    }
+    io.stdout("  See doc/requirements.md for the per-platform install steps, or set xbintsc_CLANG.\n");
   }
 
   try {
@@ -282,13 +321,13 @@ function doctor(io: CliIo): number {
   }
 
   try {
-    const toolchain = resolveToolchain();
+    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`);
   } catch {
     io.stdout("icon res   : unknown\n");
   }
-  return 0;
+  return usable ? 0 : 1;
 }
 
 type ConfigResolution =
@@ -388,7 +427,7 @@ function dispatch(argv: readonly string[], io: CliIo): number {
     const extNames = listFlag(args.flags, "ext") ?? resolved.config.extensions ?? [];
     const nativeManifests = listFlag(args.flags, "ext-native") ?? resolved.config.extNative ?? [];
     const registry = buildRegistry(extNames, nativeManifests);
-    const { ir, diagnostics } = compileEntry(entry, registry);
+    const { ir, diagnostics } = compileEntry(entry, registry, { debug: Boolean(args.flags.get("debug")) });
     if (diagnostics.some((d) => d.category === "error")) {
       printDiagnostics(diagnostics, entry, io);
       return 1;
@@ -423,6 +462,7 @@ function dispatch(argv: readonly string[], io: CliIo): number {
       verbose: Boolean(args.flags.get("verbose")),
       extensions: registry,
       app: mergeAppConfig(args.flags, config),
+      debug: Boolean(args.flags.get("debug")),
     });
 
     if (result.diagnostics.some((d) => d.category === "error")) {
@@ -430,6 +470,8 @@ function dispatch(argv: readonly string[], io: CliIo): number {
       return 1;
     }
 
+    if (args.flags.has("time") && result.timings) printTimings(result.timings, io);
+
     if (command === "build") {
       const bundle = result.bundlePath ? ` (bundle: ${result.bundlePath})` : "";
       io.stdout(`xbintsc: wrote ${result.outputPath}${result.cached ? " (cached)" : ""}${bundle}\n`);

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

@@ -19,6 +19,7 @@ import {
   BUILTIN_METHODS,
   CONSOLE_METHODS,
   CTOR_FUNCTIONS,
+  ERROR_CONSTRUCTORS,
   GLOBAL_FUNCTIONS,
   MATH_FUNCTIONS,
   NAMESPACE_STATICS,
@@ -142,6 +143,10 @@ export const invocationCallMethods: InvocationCallMethods = {
       }
       const ctor = !symbol ? CTOR_FUNCTIONS[(callee as Identifier).text] : undefined;
       if (ctor) {
+        // `Error("x")` without `new`: point the innermost frame at the call.
+        if (ERROR_CONSTRUCTORS[(callee as Identifier).text]) {
+          this.emit(`  call void @xt_stack_set_line(i32 ${this.lineOf(node)})`);
+        }
         const args = this.emitArguments(node.arguments);
         const result = this.reg();
         this.emit(`  ${result} = call i64 @${ctor}(i32 ${args.argc}, i64* ${args.ptr})`);

package/src/codegen/generator/context.ts

@@ -54,11 +54,35 @@ export class GeneratorContext {
   readonly importDefaults = new Map<number, ModuleExport>();
   readonly globals: string[] = [];
   readonly functions: string[] = [];
-  readonly strings = new Map<string, { label: string; length: number }>();
+  readonly strings = new Map<string, { label: string; length: number; slot: string }>();
   readonly classGlobals = new Map<number, string>();
   readonly moduleGlobals = new Map<number, string>();
   readonly extraDeclarations = new Set<string>();
+  /** Static C strings used only as metadata (stack frame names/files). */
+  readonly staticStrings = new Map<string, string>();
+  /** Lazily built line-start indexes per source file, for stack frames. */
+  readonly lineStartsByFile = new Map<string, number[]>();
   stringCounter = 0;
+  staticCounter = 0;
+  /**
+   * How many `UnsupportedFeature` diagnostics the function currently being
+   * emitted produced. Unsupported constructs can leave the generator with a
+   * partially-bound tree; reporting the resulting invariant failures as
+   * "Internal: …" only buries the actionable error, so they are suppressed
+   * while this is non-zero.
+   */
+  unsupportedCount = 0;
+  /** Emit DWARF debug metadata (`--debug`). */
+  readonly debug: boolean;
+  /** Numbered metadata definitions, emitted after the functions. */
+  metadataCounter = 0;
+  readonly metadata: string[] = [];
+  readonly debugFiles = new Map<string, string>();
+  readonly debugSubprograms = new Map<number, string>();
+  readonly debugLocations = new Map<string, string>();
+  debugUnit?: string;
+  debugFlags: string[] = [];
+  debugSubroutineType?: string;
   current!: FunctionState;
 
   constructor(sourceFile: SourceFileNode, diagnostics: DiagnosticBag, options: CodegenOptions = {}) {
@@ -69,6 +93,7 @@ export class GeneratorContext {
     this.modules = options.modules ?? {};
     this.moduleHints = options.moduleHints ?? {};
     this.target = options.target ?? { platform: process.platform, arch: process.arch };
+    this.debug = options.debug === true;
     this.resolveImports();
   }
 
@@ -120,7 +145,7 @@ export class GeneratorContext {
               DiagnosticCode.ModuleNotFound,
               `Module '"${specifier}"' has no exported member '${importedName}'`,
               specifierNode.name,
-              this.sourceFile.fileName,
+              this.fileNameOf(specifierNode.name),
             );
             this.missingModuleSymbols.add(symbol.id);
           }
@@ -148,7 +173,7 @@ export class GeneratorContext {
         DiagnosticCode.ModuleNotFound,
         `module '${specifier}' is provided by the '${provider}' extension; pass --ext ${provider}`,
         declaration.moduleSpecifier,
-        this.sourceFile.fileName,
+        this.fileNameOf(declaration.moduleSpecifier),
       );
       this.markMissingModuleSymbols(declaration);
       return;
@@ -165,7 +190,7 @@ export class GeneratorContext {
       `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",
       declaration.moduleSpecifier,
-      this.sourceFile.fileName,
+      this.fileNameOf(declaration.moduleSpecifier),
     );
     for (const symbol of symbols) this.missingModuleSymbols.add(symbol.id);
   }
@@ -230,11 +255,12 @@ export class GeneratorContext {
   // -- emission primitives -------------------------------------------------
 
   emit(line: string): void {
-    this.current.buffer.push(line);
+    const location = this.debug ? this.current.debugLocation : undefined;
+    this.current.buffer.push(location === undefined ? line : `${line}, !dbg ${location}`);
   }
 
   terminate(line: string): void {
-    this.current.buffer.push(`  ${line}`);
+    this.emit(`  ${line}`);
     this.current.terminated = true;
   }
 
@@ -283,6 +309,19 @@ export class GeneratorContext {
     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" };
+    const ptr = `%args${this.current.allocas.length}`;
+    this.current.allocas.push(`${ptr} = alloca i64, i32 ${values.length}`);
+    for (let index = 0; index < values.length; index++) {
+      const slot = this.reg();
+      this.emit(`  ${slot} = getelementptr i64, i64* ${ptr}, i32 ${index}`);
+      this.emit(`  store i64 ${values[index]}, i64* ${slot}`);
+    }
+    return { argc: String(values.length), ptr };
+  }
+
   const(value: bigint): string {
     return i64(value);
   }
@@ -333,11 +372,15 @@ export class GeneratorContext {
     const slot = this.current.slots.get(symbol.id);
     if (!slot) {
       // Referenced from an inner function without a capture slot: this should
-      // be impossible once the binder has run, but stay defensive.
-      this.diagnostics.error(
-        DiagnosticCode.CodegenError,
-        `Internal: no slot for '${symbol.name}' in ${this.current.fn.name}`,
-      );
+      // be impossible once the binder has run, but stay defensive. After an
+      // unsupported construct the tree can be partially bound, so do not add
+      // an "Internal" error on top of the actionable one.
+      if (this.unsupportedCount === 0) {
+        this.diagnostics.error(
+          DiagnosticCode.CodegenError,
+          `Internal: no slot for '${symbol.name}' in ${this.current.fn.name}`,
+        );
+      }
       return i64(XT_UNDEFINED);
     }
     const value = this.reg();
@@ -362,7 +405,9 @@ export class GeneratorContext {
     }
     const slot = this.current.slots.get(symbol.id);
     if (!slot) {
-      this.diagnostics.error(DiagnosticCode.CodegenError, `Internal: no slot for '${symbol.name}'`);
+      if (this.unsupportedCount === 0) {
+        this.diagnostics.error(DiagnosticCode.CodegenError, `Internal: no slot for '${symbol.name}'`);
+      }
       return;
     }
     if (!slot.boxed) {
@@ -390,28 +435,94 @@ export class GeneratorContext {
   stringValue(text: string): string {
     const entry = this.internString(text);
     const result = this.reg();
-    this.emit(`  ${result} = call i64 @xt_string_new(i8* ${entry.label}, i64 ${entry.length})`);
+    // The value is created once in `main` and shared by every use, so a string
+    // literal (especially a property name in a hot loop) no longer allocates on
+    // each evaluation.
+    this.emit(`  ${result} = load i64, i64* ${entry.slot}`);
     return result;
   }
 
-  internString(text: string): { label: string; length: number } {
+  internString(text: string): { label: string; length: number; slot: string } {
     const existing = this.strings.get(text);
     if (existing) return existing;
-    const label = `@.str.${this.stringCounter++}`;
+    const index = this.stringCounter++;
+    const label = `@.str.${index}`;
+    const slot = `@.strv.${index}`;
     const bytes = utf8Bytes(text);
-    const entry = { label, length: bytes.length };
+    const entry = { label, length: bytes.length, slot };
     this.strings.set(text, entry);
     this.globals.push(`${label} = private unnamed_addr constant [${bytes.length + 1} x i8] c"${escapeBytes(bytes)}\\00"`);
+    // A GC-rooted global holding the runtime string value, initialised in main.
+    this.globals.push(`${slot} = internal global i64 0`);
     return entry;
   }
 
+  /**
+   * Intern a string purely as static module data (no `xt_string` value), for
+   * metadata such as shadow-stack frame names and file paths.
+   */
+  internStatic(text: string): string {
+    const existing = this.staticStrings.get(text);
+    if (existing) return existing;
+    const label = `@.meta.${this.staticCounter++}`;
+    const bytes = utf8Bytes(text);
+    this.staticStrings.set(text, label);
+    this.globals.push(`${label} = private unnamed_addr constant [${bytes.length + 1} x i8] c"${escapeBytes(bytes)}\\00"`);
+    return label;
+  }
+
+  /** Strip a bundler-generated module prefix (`m1_`) from a display name. */
+  displayNameOf(name: string): string {
+    for (const prefix of this.sourceFile.modulePrefixes ?? []) {
+      if (name.startsWith(prefix) && name.length > prefix.length) return name.slice(prefix.length);
+    }
+    return name;
+  }
+
+  /** 1-based line and column of `node` in the module it came from. */
+  positionOf(node: Node): { line: number; column: number } {
+    const file = this.fileNameOf(node);
+    const text = this.sourceFile.moduleTexts?.get(file) ?? this.sourceFile.text;
+    let starts = this.lineStartsByFile.get(file);
+    if (!starts) {
+      starts = [0];
+      for (let index = 0; index < text.length; index++) {
+        if (text.charCodeAt(index) === 10) starts.push(index + 1);
+      }
+      this.lineStartsByFile.set(file, starts);
+    }
+    const offset = Math.max(0, Math.min(node.start, text.length));
+    let low = 0;
+    let high = starts.length - 1;
+    while (low < high) {
+      const middle = (low + high + 1) >> 1;
+      if (starts[middle]! <= offset) low = middle;
+      else high = middle - 1;
+    }
+    return { line: low + 1, column: offset - starts[low]! + 1 };
+  }
+
+  /** 1-based line of `node` in the module it came from (for stack frames). */
+  lineOf(node: Node): number {
+    return this.positionOf(node).line;
+  }
+
+  /** The source file a node belongs to. Bundling merges every module into one
+   * `SourceFile` while keeping module-local offsets, so the origin map is what
+   * keeps diagnostics pointing at the file the user actually wrote.
+   */
+  fileNameOf(node: Node): string {
+    return this.sourceFile.origins?.get(node) ?? this.sourceFile.fileName;
+  }
+
   unsupported(node: Node, what: string): void {
     const label = kindName(node.kind);
+    this.unsupportedCount++;
     this.diagnostics.error(
       DiagnosticCode.UnsupportedFeature,
       `xbintsc does not yet support this ${what} (${label})`,
       node,
-      this.sourceFile.fileName,
+      this.fileNameOf(node),
     );
   }
 
@@ -429,7 +540,7 @@ export class GeneratorContext {
       DiagnosticCode.UnsupportedFeature,
       `CommonJS \`require()\` is not supported; ${replacement}`,
       node,
-      this.sourceFile.fileName,
+      this.fileNameOf(node),
     );
   }
 }

package/src/codegen/generator/debug.ts

@@ -0,0 +1,132 @@
+/**
+ * DWARF/CodeView metadata for `xbintsc build --debug`.
+ *
+ * The generated IR declares a compile unit, one `!DISubprogram` per compiled
+ * function and one cached `!DILocation` per statement position. With `-g`,
+ * clang turns these into DWARF (Linux/macOS) or CodeView (Windows), so a native
+ * debugger maps instructions back to the TypeScript source.
+ *
+ * Metadata is only emitted when debug is enabled: the nodes are large, and the
+ * default IR must stay byte-identical for the self-hosting fixpoint.
+ */
+
+import type { Node } from "../../ast/nodes.js";
+import type { FunctionInfo } from "../../binder/binder.js";
+import { escapeBytes, utf8Bytes } from "./tables.js";
+import type { Generator } from "./generator.js";
+
+export interface DebugMethods {
+  /** Allocate a numbered metadata node (`!0`, `!1`, …). */
+  metadataId(this: Generator): string;
+  /** Allocate a metadata node and register its definition. */
+  addMetadata(this: Generator, definition: string): string;
+  /** `!DIFile` for a source path, normalising separators like `source_filename`. */
+  debugFileFor(this: Generator, fileName: string): string;
+  /** `!DISubprogram` for a compiled function (created on first use). */
+  debugSubprogramFor(this: Generator, fn: FunctionInfo): string | undefined;
+  /**
+   * Point subsequent instructions at `node`'s source position. Locations are
+   * cached per function/line/column so a statement emits one metadata node
+   * instead of one per instruction.
+   */
+  setDebugLocation(this: Generator, node: Node): void;
+  /** Module-level metadata declarations and definitions (`--debug`). */
+  debugMetadataLines(this: Generator): string[];
+}
+
+function escapeMetadata(text: string): string {
+  return escapeBytes(utf8Bytes(text));
+}
+
+/**
+ * Create the compile unit and module flags once. LLVM requires the `Debug Info
+ * Version` flag for any `!dbg` attachment, and clang only emits DWARF/CodeView
+ * for a module that declares a compile unit.
+ */
+function ensureDebugUnit(self: Generator): void {
+  if (self.debugUnit !== undefined) return;
+  const entryFile = self.debugFileFor(self.sourceFile.fileName);
+  const unit = self.addMetadata(
+    'distinct !DICompileUnit(language: DW_LANG_C_plus_plus, file: ' +
+      `${entryFile}, producer: "xbintsc", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug)`,
+  );
+  self.debugUnit = unit;
+  self.debugFlags.push(
+    self.addMetadata('!{i32 7, !"Dwarf Version", i32 4}'),
+    self.addMetadata('!{i32 2, !"Debug Info Version", i32 3}'),
+  );
+  const types = self.addMetadata("!{null}");
+  self.debugSubroutineType = self.addMetadata(`!DISubroutineType(types: ${types})`);
+}
+
+export const debugMethods: DebugMethods = {
+  metadataId() {
+    return `!${this.metadataCounter++}`;
+  },
+
+  addMetadata(definition) {
+    const id = this.metadataId();
+    this.metadata.push(`${id} = ${definition}`);
+    return id;
+  },
+
+  debugFileFor(fileName) {
+    const normalized = fileName.split("\\").join("/");
+    const existing = this.debugFiles.get(normalized);
+    if (existing) return existing;
+    const slash = normalized.lastIndexOf("/");
+    const directory = slash >= 0 ? normalized.slice(0, slash) : ".";
+    const name = slash >= 0 ? normalized.slice(slash + 1) : normalized;
+    const id = this.addMetadata(
+      `!DIFile(filename: "${escapeMetadata(name)}", directory: "${escapeMetadata(directory)}")`,
+    );
+    this.debugFiles.set(normalized, id);
+    return id;
+  },
+
+  debugSubprogramFor(fn) {
+    if (!this.debug) return undefined;
+    const existing = this.debugSubprograms.get(fn.id);
+    if (existing) return existing;
+    ensureDebugUnit(this);
+    const file = this.debugFileFor(this.fileNameOf(fn.node));
+    const position = this.positionOf(fn.node);
+    const displayName = fn.isModule
+      ? "module"
+      : fn.isConstructor && fn.classInfo
+        ? `new ${this.displayNameOf(fn.classInfo.name)}`
+        : this.displayNameOf(fn.name.length > 0 ? fn.name : "anonymous");
+    const subprogram = this.addMetadata(
+      'distinct !DISubprogram(name: ' +
+        `"${escapeMetadata(displayName)}", scope: ${this.debugUnit}, file: ${file}, ` +
+        `line: ${position.line}, type: ${this.debugSubroutineType}, scopeLine: ${position.line}, ` +
+        `spFlags: DISPFlagDefinition, unit: ${this.debugUnit})`,
+    );
+    this.debugSubprograms.set(fn.id, subprogram);
+    return subprogram;
+  },
+
+  setDebugLocation(node) {
+    if (!this.debug || this.current.debugSubprogram === undefined) return;
+    const position = this.positionOf(node);
+    const key = `${this.current.debugSubprogram}:${position.line}:${position.column}`;
+    let location = this.debugLocations.get(key);
+    if (!location) {
+      location = this.addMetadata(
+        `!DILocation(line: ${position.line}, column: ${position.column}, scope: ${this.current.debugSubprogram})`,
+      );
+      this.debugLocations.set(key, location);
+    }
+    this.current.debugLocation = location;
+  },
+
+  debugMetadataLines() {
+    if (!this.debug || this.debugUnit === undefined) return [];
+    return [
+      `!llvm.dbg.cu = !{${this.debugUnit}}`,
+      `!llvm.module.flags = !{${this.debugFlags.join(", ")}}`,
+      ...this.metadata,
+      "",
+    ];
+  },
+};

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

@@ -58,9 +58,7 @@ export const assignmentExpressionMethods: AssignmentExpressionMethods = {
         this.unsupported(node, `assignment operator '${operator}'`);
         return i64(XT_UNDEFINED);
       }
-      const result = this.reg();
-      this.emit(`  ${result} = call i64 @${runtime}(i64 ${current}, i64 ${right})`);
-      value = result;
+      value = this.emitBinaryOperation(current, right, binaryOperator, runtime);
     }
     this.emitAssignmentTarget(target, value);
     return value;
@@ -120,7 +118,7 @@ export const assignmentExpressionMethods: AssignmentExpressionMethods = {
               ? `Cannot assign to '${symbol.name}' because it is an import.`
               : `Cannot assign to '${symbol.name}' because it is a constant.`,
             identifier,
-            this.sourceFile.fileName,
+            this.fileNameOf(identifier),
           );
           return;
         }
@@ -187,9 +185,13 @@ export const assignmentExpressionMethods: AssignmentExpressionMethods = {
 
   /** `{ a, b } = value` / `for ({ a } of xs)`: assign each property of `value`. */
   emitObjectAssignmentTarget(pattern: ObjectLiteralExpression, value: string): void {
+    const excludedKeys: string[] = [];
     for (const property of pattern.properties) {
       if (property.kind === SyntaxKind.SpreadElement) {
-        this.unsupported(property, "object rest destructuring");
+        const rest = this.reg();
+        const keys = this.emitValueArguments(excludedKeys);
+        this.emit(`  ${rest} = call i64 @xt_object_rest(i64 ${value}, i32 ${keys.argc}, i64* ${keys.ptr})`);
+        this.emitAssignmentTarget((property as SpreadElement).expression, rest);
         continue;
       }
       if (property.kind === SyntaxKind.PropertyAssignment) {
@@ -200,6 +202,7 @@ export const assignmentExpressionMethods: AssignmentExpressionMethods = {
         } else {
           key = this.stringValue(propertyNameText(assignment.name));
         }
+        excludedKeys.push(key);
         let target: Expression = assignment.initializer;
         let fallback: Expression | undefined;
         if (isPlainAssignment(target)) {
@@ -215,6 +218,7 @@ export const assignmentExpressionMethods: AssignmentExpressionMethods = {
       }
       const shorthand = property as ShorthandPropertyAssignment;
       const key = this.stringValue(shorthand.name.text);
+      excludedKeys.push(key);
       let elementValue = this.reg();
       this.emit(`  ${elementValue} = call i64 @xt_get(i64 ${value}, i64 ${key})`);
       if (shorthand.initializer) elementValue = this.emitBindingDefault(elementValue, shorthand.initializer);