xbintsc 0.3.79 → 0.3.87

package/scripts/bench.ts

@@ -0,0 +1,172 @@
+#!/usr/bin/env node
+/**
+ * Build and time a small, fixed benchmark suite.
+ *
+ * The numbers are wall-clock times on the current machine, so they are only
+ * useful for comparing revisions of the compiler (or the same revision against
+ * Node): run `npm run bench` before and after a change to the runtime or
+ * codegen. Each program is compiled with the normal driver (cache bypassed) and
+ * executed several times; the table reports the fastest run to reduce noise.
+ *
+ * Usage:
+ *   npm run bench                 # every benchmark, 3 runs, with Node for scale
+ *   npm run bench -- --runs 5     # more runs (minimum is reported)
+ *   npm run bench -- --filter prop
+ *   npm run bench -- --no-node    # skip the Node comparison
+ */
+
+import { spawnSync } from "node:child_process";
+import { mkdirSync, statSync, writeFileSync } from "node:fs";
+import { dirname, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { build } from "../src/driver/index.js";
+
+const root = resolve(dirname(fileURLToPath(import.meta.url)), "..");
+const outDir = join(root, "build", "bench");
+const cacheDir = join(root, "build", "bench-cache");
+
+interface Benchmark {
+  readonly name: string;
+  /** Plain JavaScript so the same source can run under Node. */
+  readonly source: string;
+}
+
+const BENCHMARKS: readonly Benchmark[] = [
+  {
+    name: "numeric",
+    source: `
+let total = 0;
+for (let i = 0; i < 50000000; i++) total = total + i;
+console.log(total);
+`,
+  },
+  {
+    name: "property",
+    source: `
+const object = { x: 0 };
+for (let i = 0; i < 5000000; i++) object.x = object.x + 1;
+console.log(object.x);
+`,
+  },
+  {
+    name: "array",
+    source: `
+const values = [];
+for (let i = 0; i < 3000000; i++) values[i] = i;
+let total = 0;
+for (let i = 0; i < 3000000; i++) total = total + values[i];
+console.log(total);
+`,
+  },
+  {
+    name: "string-concat",
+    source: `
+let text = "";
+for (let i = 0; i < 100000; i++) text = text + "a";
+console.log(text.length);
+`,
+  },
+];
+
+interface Options {
+  readonly runs: number;
+  readonly filter?: string;
+  readonly node: boolean;
+}
+
+function parseOptions(argv: readonly string[]): Options {
+  let runs = 3;
+  let filter: string | undefined;
+  let node = true;
+  for (let index = 0; index < argv.length; index++) {
+    const arg = argv[index]!;
+    if (arg === "--no-node") node = false;
+    else if (arg === "--runs") runs = Math.max(1, Number(argv[++index]) || 1);
+    else if (arg.startsWith("--runs=")) runs = Math.max(1, Number(arg.slice("--runs=".length)) || 1);
+    else if (arg === "--filter") filter = argv[++index];
+    else if (arg.startsWith("--filter=")) filter = arg.slice("--filter=".length);
+    else if (arg === "--help" || arg === "-h") {
+      process.stdout.write(
+        "usage: npm run bench [-- --runs N] [--filter <substr>] [--no-node]\n",
+      );
+      process.exit(0);
+    }
+  }
+  return { runs, filter, node };
+}
+
+function minTimeMs(runs: number, execute: () => void): number {
+  let best = Number.POSITIVE_INFINITY;
+  for (let run = 0; run < runs; run++) {
+    const start = process.hrtime.bigint();
+    execute();
+    const elapsed = Number(process.hrtime.bigint() - start) / 1e6;
+    if (elapsed < best) best = elapsed;
+  }
+  return best;
+}
+
+function formatMs(value: number | undefined): string {
+  return value === undefined ? "-" : `${value.toFixed(1)} ms`;
+}
+
+function main(): number {
+  const options = parseOptions(process.argv.slice(2));
+  mkdirSync(outDir, { recursive: true });
+  mkdirSync(cacheDir, { recursive: true });
+  const benchmarks = BENCHMARKS.filter(
+    (benchmark) => options.filter === undefined || benchmark.name.includes(options.filter),
+  );
+  if (benchmarks.length === 0) {
+    process.stderr.write(`xbintsc: no benchmark matches '${options.filter}'\n`);
+    return 1;
+  }
+
+  const rows: { name: string; ours?: number; node?: number; bytes?: number }[] = [];
+  for (const benchmark of benchmarks) {
+    const entry = join(outDir, `${benchmark.name}.ts`);
+    writeFileSync(entry, benchmark.source);
+    const result = build(entry, {
+      emit: "exe",
+      outDir: join(outDir, "bin"),
+      cacheDir,
+      force: true,
+    });
+    const errors = result.diagnostics.filter((diagnostic) => diagnostic.category === "error");
+    if (errors.length > 0) {
+      for (const error of errors) process.stderr.write(`xbintsc: ${error.message}\n`);
+      return 1;
+    }
+    const bytes = statSync(result.outputPath).size;
+    const ours = minTimeMs(options.runs, () => {
+      const executed = spawnSync(result.outputPath, [], { stdio: "ignore" });
+      if (executed.status !== 0) throw new Error(`${benchmark.name} exited with ${executed.status}`);
+    });
+
+    let nodeTime: number | undefined;
+    if (options.node) {
+      const script = join(outDir, `${benchmark.name}.mjs`);
+      writeFileSync(script, benchmark.source);
+      nodeTime = minTimeMs(options.runs, () => {
+        const executed = spawnSync(process.execPath, [script], { stdio: "ignore" });
+        if (executed.status !== 0) throw new Error(`${benchmark.name} (node) exited with ${executed.status}`);
+      });
+    }
+    rows.push({ name: benchmark.name, ours, node: nodeTime, bytes });
+  }
+
+  const header = ["benchmark", "xbintsc", "node", "size"];
+  process.stdout.write(
+    `${header[0]!.padEnd(16)}${header[1]!.padStart(12)}${header[2]!.padStart(12)}${header[3]!.padStart(12)}\n`,
+  );
+  for (const row of rows) {
+    const size = row.bytes === undefined ? "-" : `${Math.round(row.bytes / 1024)} KB`;
+    process.stdout.write(
+      `${row.name.padEnd(16)}${formatMs(row.ours).padStart(12)}${formatMs(row.node).padStart(12)}${size.padStart(12)}\n`,
+    );
+  }
+  process.stdout.write(`\nfastest of ${options.runs} run(s) on ${process.platform}-${process.arch}\n`);
+  return 0;
+}
+
+process.exit(main());

package/scripts/build-runtime.ts

@@ -21,6 +21,7 @@ import { fileURLToPath } from "node:url";
 import { RUNTIME_SOURCES } from "../src/driver/compiler.js";
 import { platformSlug } from "../src/driver/paths.js";
 import { resolveToolchain } from "../src/driver/toolchain-provider.js";
+import { RUNTIME_CFLAGS } from "../src/driver/toolchain.js";
 import { nodeExtension } from "../src/extensions/node/index.js";
 
 const root = resolve(dirname(fileURLToPath(import.meta.url)), "..");
@@ -72,7 +73,7 @@ function compile(sources: readonly string[], extension: string): string[] {
     const object = join(objDir, `${extension}_${index}_${basename(source, ".c")}.o`);
     const result = spawnSync(
       clang,
-      ["-O2", "-Wall", "-Wextra", "-D_CRT_SECURE_NO_WARNINGS", "-c", source, "-o", object, `-I${runtimeDir}`],
+      [...RUNTIME_CFLAGS, "-c", source, "-o", object, `-I${runtimeDir}`],
       { stdio: "inherit", env: childEnv },
     );
     if (result.status !== 0) {

package/scripts/check-version.ts

@@ -0,0 +1,53 @@
+#!/usr/bin/env node
+/**
+ * Verify that `COMPILER_VERSION` (reported by `xbintsc version` / `doctor` and
+ * embedded in the incremental cache key) matches the version in `package.json`
+ * (which names the release archives).
+ *
+ * Release automation runs this before tagging. A mismatch means an upgraded
+ * compiler can reuse binaries produced by the previous one while presenting the
+ * wrong version to bug reports.
+ */
+
+import { readFileSync } from "node:fs";
+import { dirname, join, resolve } from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+
+/** Read the version literal from the compiler source. */
+export function compilerVersionOf(root: string): string {
+  const text = readFileSync(join(root, "src", "driver", "compiler.ts"), "utf8");
+  const match = /export const COMPILER_VERSION = "([^"]+)"/.exec(text);
+  if (!match) throw new Error("COMPILER_VERSION is not declared in src/driver/compiler.ts");
+  return match[1]!;
+}
+
+/** Read the published version from package.json. */
+export function packageVersionOf(root: string): string {
+  const parsed = JSON.parse(readFileSync(join(root, "package.json"), "utf8")) as { version?: string };
+  if (!parsed.version) throw new Error("package.json has no version field");
+  return parsed.version;
+}
+
+/** Returns a human-readable mismatch message, or `undefined` when in sync. */
+export function checkCompilerVersion(root: string): string | undefined {
+  const packageVersion = packageVersionOf(root);
+  const compilerVersion = compilerVersionOf(root);
+  if (packageVersion === compilerVersion) return undefined;
+  return (
+    `COMPILER_VERSION is "${compilerVersion}" but package.json is "${packageVersion}".\n` +
+    'Update COMPILER_VERSION in src/driver/compiler.ts (it keys the incremental cache), or fix package.json.'
+  );
+}
+
+const invokedDirectly =
+  process.argv[1] !== undefined && import.meta.url === pathToFileURL(process.argv[1]).href;
+
+if (invokedDirectly) {
+  const root = resolve(dirname(fileURLToPath(import.meta.url)), "..");
+  const mismatch = checkCompilerVersion(root);
+  if (mismatch) {
+    process.stderr.write(`xbintsc: version mismatch\n${mismatch}\n`);
+    process.exit(1);
+  }
+  process.stdout.write(`xbintsc: version ${compilerVersionOf(root)} matches package.json\n`);
+}

package/src/ast/common.ts

@@ -207,4 +207,27 @@ export interface SourceFileNode extends Node {
   readonly statements: Statement[];
   readonly fileName: string;
   readonly text: string;
+  /**
+   * For a bundled program: the original module each node was parsed from.
+   *
+   * The bundler merges every module into one `SourceFile`, but the nodes keep
+   * their module-local `start`/`end` offsets. Diagnostics must therefore report
+   * the module a node came from, not the entry file, or a cross-module error
+   * shows the wrong file and a nonsensical excerpt. Absent for a single-file
+   * compile, where `fileName` is the only source.
+   */
+  readonly origins?: Map<object, string>;
+  /**
+   * For a bundled program: the original text of every module, keyed like
+   * {@link origins}. A node's `start` is relative to its module's text, so
+   * computing a frame's line number needs that text rather than the merged
+   * concatenation in `text`.
+   */
+  readonly moduleTexts?: Map<string, string>;
+  /**
+   * Bundler-generated symbol prefixes (`m0_`, `m1_`, …). Display names (stack
+   * frames, symbol suffixes) strip them so a bundled `fail()` still shows as
+   * `fail`, not `m1_fail`.
+   */
+  readonly modulePrefixes?: readonly string[];
 }

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})`);