xbintsc 0.3.79 → 0.3.87

package/src/driver/toolchain.ts

@@ -6,6 +6,8 @@
  */
 
 import { spawnSync, type SpawnSyncOptions } from "node:child_process";
+import { existsSync } from "node:fs";
+import { join } from "node:path";
 
 export interface CommandResult {
   readonly status: number;
@@ -53,26 +55,176 @@ export class ToolchainError extends Error {
   }
 }
 
-/** Locate a clang-compatible C compiler, honouring `xbintsc_CLANG`. */
-export function findClang(runner: Runner = realRunner): string {
-  const candidates = [
-    process.env.xbintsc_CLANG,
-    "clang",
-    "clang-18",
-    "clang-17",
-    "clang-16",
-    "cc",
-  ].filter((candidate): candidate is string => Boolean(candidate));
-  for (const candidate of candidates) {
-    let status: number;
-    try {
-      status = runner.run(candidate, ["--version"]).status;
-    } catch {
-      continue;
+/**
+ * The oldest clang/LLVM the emitted IR is known to compile with. LLVM 16 made
+ * opaque pointers the only pointer representation, and the IR emitted by
+ * `src/codegen` relies on that; clang 15 and older reject it with
+ * "'@.str.0' defined with type '[6 x i8]*' but expected 'i8*'".
+ */
+export const MINIMUM_CLANG_MAJOR = 16;
+
+export interface ClangVersion {
+  readonly major: number;
+  readonly minor: number;
+  readonly patch: number;
+}
+
+/** Result of probing one candidate with `--version`. */
+export interface ClangProbe {
+  readonly command: string;
+  /** True when the command ran and exited 0. */
+  readonly responds: boolean;
+  readonly version?: ClangVersion;
+  /** First line of the version output, for diagnostics. */
+  readonly summary: string;
+}
+
+export interface ClangLocation {
+  readonly command: string;
+  readonly source: "env" | "system";
+  /** Absent when an explicit wrapper does not print a parseable version. */
+  readonly version?: ClangVersion;
+}
+
+/**
+ * Extract the LLVM version from a `--version` line. Accepts "clang version
+ * 19.1.5", "Apple clang version 15.0.0" and distribution prefixes such as
+ * "Ubuntu clang version 18.1.3"; returns `undefined` for anything else (notably
+ * gcc, which `cc` may resolve to).
+ */
+export function parseClangVersion(output: string): ClangVersion | undefined {
+  const match = /clang version (\d+)\.(\d+)\.(\d+)/i.exec(output);
+  if (!match) return undefined;
+  return { major: Number(match[1]), minor: Number(match[2]), patch: Number(match[3]) };
+}
+
+function firstLineOf(text: string): string {
+  const end = text.indexOf("\n");
+  return (end === -1 ? text : text.slice(0, end)).trim();
+}
+
+/** Run `<command> --version` and classify the result. Never throws. */
+export function probeClang(
+  runner: Runner,
+  command: string,
+  env?: Record<string, string>,
+): ClangProbe {
+  try {
+    const result = runner.run(command, ["--version"], env ? { env } : undefined);
+    const output = `${result.stdout}\n${result.stderr}`;
+    const version = parseClangVersion(output);
+    return {
+      command,
+      responds: result.status === 0,
+      ...(version ? { version } : {}),
+      summary: firstLineOf(result.stdout) || firstLineOf(result.stderr),
+    };
+  } catch {
+    return { command, responds: false, summary: "" };
+  }
+}
+
+/**
+ * Visual Studio ships its own LLVM build (`VC\Tools\Llvm\x64\bin\clang.exe`).
+ * It is a perfectly good driver but is not on `PATH` in a plain shell, so probe
+ * the well-known install locations too. Only candidates that exist are
+ * returned, and only on Windows.
+ */
+function visualStudioClangCandidates(): string[] {
+  if (process.platform !== "win32") return [];
+  const roots = [process.env.ProgramFiles, process.env["ProgramFiles(x86)"], process.env.ProgramW6432]
+    .filter((root): root is string => Boolean(root));
+  const arch = process.arch === "arm64" ? "ARM64" : "x64";
+  const candidates: string[] = [];
+  for (const root of roots) {
+    for (const year of ["2022", "2019"]) {
+      for (const edition of ["Community", "Professional", "Enterprise", "BuildTools"]) {
+        const llvm = join(root, "Microsoft Visual Studio", year, edition, "VC", "Tools", "Llvm");
+        candidates.push(join(llvm, arch, "bin", "clang.exe"));
+        candidates.push(join(llvm, "bin", "clang.exe"));
+      }
     }
-    if (status === 0) return candidate;
+    candidates.push(join(root, "LLVM", "bin", "clang.exe"));
   }
-  throw new ToolchainError("clang --version", 1, "No C compiler found. Set xbintsc_CLANG to a clang binary.");
+  return [...new Set(candidates)].filter((candidate) => existsSync(candidate));
+}
+
+/** Commands probed for a system compiler, in preference order. */
+export function systemClangCandidates(): string[] {
+  const candidates = ["clang"];
+  for (let major = 20; major >= MINIMUM_CLANG_MAJOR; major--) candidates.push(`clang-${major}`);
+  candidates.push("cc");
+  candidates.push(...visualStudioClangCandidates());
+  return [...new Set(candidates)];
+}
+
+function tooOldError(probe: ClangProbe): ToolchainError {
+  const version = probe.version!;
+  const found = `clang ${version.major}.${version.minor}.${version.patch}`;
+  return new ToolchainError(
+    "clang --version",
+    1,
+    `${probe.command} reports ${found}, but xbintsc requires clang ${MINIMUM_CLANG_MAJOR} or newer ` +
+      "(the emitted LLVM IR uses opaque pointers).\n" +
+      "Install a newer LLVM/clang (on Windows, the one bundled with Visual Studio works) or set " +
+      `xbintsc_CLANG to a clang ${MINIMUM_CLANG_MAJOR}+ binary.`,
+  );
+}
+
+function noCompilerError(tried: readonly ClangProbe[]): ToolchainError {
+  const responded = tried.filter((probe) => probe.responds);
+  const details = responded.map((probe) => {
+    const version = probe.version
+      ? `clang ${probe.version.major}.${probe.version.minor}.${probe.version.patch}`
+      : probe.summary || "unknown version";
+    return `  ${probe.command}: ${version}`;
+  });
+  const tooOld = responded.some((probe) => probe.version !== undefined && probe.version.major < MINIMUM_CLANG_MAJOR);
+  const reason = tooOld
+    ? `Only clang older than ${MINIMUM_CLANG_MAJOR} was found; xbintsc requires clang ${MINIMUM_CLANG_MAJOR}+ ` +
+      "(the emitted LLVM IR uses opaque pointers)."
+    : `No clang ${MINIMUM_CLANG_MAJOR}+ was found.`;
+  return new ToolchainError(
+    "clang --version",
+    1,
+    [reason, ...(details.length > 0 ? ["Tested:", ...details] : []), "Set xbintsc_CLANG to a clang binary."].join("\n"),
+  );
+}
+
+/**
+ * Resolve the compiler to use, version-checked.
+ *
+ * An explicit `xbintsc_CLANG` / `xbintsc_TOOLCHAIN` wins even when it is older
+ * than the minimum: the user asked for it, so the clear "too old" error is more
+ * helpful than silently using another compiler. A broken explicit path falls
+ * back to the system search. System candidates are probed in order and the
+ * first one reporting clang >= {@link MINIMUM_CLANG_MAJOR} wins, so a modern
+ * clang installed next to an old `/usr/bin/clang` is still found.
+ */
+export function locateClang(runner: Runner = realRunner): ClangLocation {
+  const explicit = process.env.xbintsc_CLANG ?? process.env.xbintsc_TOOLCHAIN;
+  const tried: ClangProbe[] = [];
+  if (explicit) {
+    const probe = probeClang(runner, explicit);
+    if (probe.responds) {
+      if (probe.version && probe.version.major < MINIMUM_CLANG_MAJOR) throw tooOldError(probe);
+      return { command: explicit, source: "env", ...(probe.version ? { version: probe.version } : {}) };
+    }
+    tried.push(probe);
+  }
+  for (const command of systemClangCandidates()) {
+    const probe = probeClang(runner, command);
+    tried.push(probe);
+    if (!probe.responds || !probe.version) continue;
+    if (probe.version.major < MINIMUM_CLANG_MAJOR) continue;
+    return { command, source: "system", version: probe.version };
+  }
+  throw noCompilerError(tried);
+}
+
+/** Locate a supported clang-compatible C compiler, or throw a clear error. */
+export function findClang(runner: Runner = realRunner): string {
+  return locateClang(runner).command;
 }
 
 export interface CompileIrOptions {
@@ -81,13 +233,23 @@ export interface CompileIrOptions {
   readonly objectPath: string;
   readonly optimize: string;
   readonly env?: Record<string, string>;
+  /** Emit debug info (`-g`) and keep frame pointers for crash backtraces. */
+  readonly debug?: boolean;
 }
 
+/**
+ * One function/data item per section so the linker can drop everything a
+ * program never references. This is what `--gc-sections` / `-dead_strip` need;
+ * the runtime is a set of translation units with many unused entry points.
+ */
+const SECTION_FLAGS = ["-ffunction-sections", "-fdata-sections"];
+
 /** Compile an LLVM IR file to a native object file. */
 export function compileIr(runner: Runner, options: CompileIrOptions): void {
+  const debugFlags = options.debug ? ["-g", "-fno-omit-frame-pointer"] : [];
   const result = runner.run(
     options.clang,
-    [`-O${options.optimize}`, "-c", options.irPath, "-o", options.objectPath],
+    [`-O${options.optimize}`, ...SECTION_FLAGS, ...debugFlags, "-c", options.irPath, "-o", options.objectPath],
     { env: options.env },
   );
   if (result.status !== 0) throw new ToolchainError(`${options.clang} ${options.irPath}`, result.status, result.stderr);
@@ -102,12 +264,39 @@ export interface LinkOptions {
   readonly env?: Record<string, string>;
 }
 
+/** Platform flag that drops unreferenced sections (paired with {@link SECTION_FLAGS}). */
+function deadStripFlag(): string[] {
+  if (process.platform === "win32") return []; // link.exe /OPT:REF is on by default
+  if (process.platform === "darwin") return ["-Wl,-dead_strip"];
+  return ["-Wl,--gc-sections"];
+}
+
 export function link(runner: Runner, options: LinkOptions): void {
-  const args = [`-O${options.optimize}`, ...options.objectPaths, "-o", options.outputPath, ...options.linkerFlags];
+  const args = [
+    `-O${options.optimize}`,
+    ...options.objectPaths,
+    "-o",
+    options.outputPath,
+    ...deadStripFlag(),
+    ...options.linkerFlags,
+  ];
   const result = runner.run(options.clang, args, { env: options.env });
   if (result.status !== 0) throw new ToolchainError(`${options.clang} link`, result.status, result.stderr);
 }
 
+/**
+ * Flags shared by every runtime/extension C compile. Exported so the object
+ * cache key can change when they do: the cache is keyed by source content, and
+ * a flag change is a different object.
+ */
+export const RUNTIME_CFLAGS = [
+  "-O2",
+  "-Wall",
+  "-Wextra",
+  "-D_CRT_SECURE_NO_WARNINGS",
+  ...SECTION_FLAGS,
+] as const;
+
 /** Compile a C source to an object file (used for the runtime and extensions). */
 export function compileC(
   runner: Runner,
@@ -119,7 +308,7 @@ export function compileC(
 ): void {
   const result = runner.run(
     clang,
-    ["-O2", "-Wall", "-Wextra", "-D_CRT_SECURE_NO_WARNINGS", "-c", sourcePath, "-o", objectPath, `-I${includeDir}`],
+    [...RUNTIME_CFLAGS, "-c", sourcePath, "-o", objectPath, `-I${includeDir}`],
     { env },
   );
   if (result.status !== 0) throw new ToolchainError(`${clang} ${sourcePath}`, result.status, result.stderr);

package/src/extensions/gui/index.ts

@@ -98,8 +98,16 @@ export const guiExtension: Extension = {
         "-luser32", "-lgdi32", "-lshell32",
         "-lole32", "-loleaut32", "-luuid", "-ladvapi32",
         "-lwinmm", "-limm32", "-lversion", "-lsetupapi",
-        /* The engine is C++; link the MSVC C++ runtime. */
-        "-lmsvcprt",
+        /* The engine is C++, but `msvcprt` (the DLL C++ runtime) must not be
+         * named here: `gui.lib` is built with `CMAKE_MSVC_RUNTIME_LIBRARY=
+         * MultiThreaded` and every engine object records `libcpmt` (the static
+         * C++ runtime) as a dependent library — see `scripts/build-gui.ts`.
+         * The two runtimes define the same symbols, so requesting the DLL one
+         * as well fails the link with `LNK2038: mismatch detected for
+         * 'RuntimeLibrary'` plus a wall of `LNK2005: already defined` errors
+         * (surfacing as `clang: linker command failed with exit code 1169`).
+         * clang links the static `libcpmt` by default, which is the CRT the
+         * archive and the xbintsc runtime objects were both built against. */
       ];
     }
     return ["-lX11", "-lwayland-client", "-lEGL", "-lGL", "-ldl", "-lpthread", "-lstdc++"];

package/src/parser/expressions.ts

@@ -299,7 +299,26 @@ export const expressionMethods: ExpressionMethods = {
   },
 
   parseNewExpression(this: Parser): NewExpression {
-    const start = this.parseExpected(TokenKind.NewKeyword).start;
+    const newToken = this.parseExpected(TokenKind.NewKeyword);
+    const start = newToken.start;
+    /* `new.target` is not part of the supported subset. Parsing it as a member
+     * access produced "Unexpected token '.'" pointing at the dot; report what
+     * is actually unsupported instead. */
+    if (this.at(TokenKind.Dot) && this.atAhead(1, TokenKind.Identifier) && this.lookAhead(1).text === "target") {
+      this.nextToken(); // .
+      const target = this.nextToken(); // target
+      this.error(DiagnosticCode.UnsupportedFeature, "xbintsc does not yet support new.target", {
+        ...newToken,
+        end: target.end,
+      });
+      const placeholder: Expression = {
+        kind: SyntaxKind.Identifier,
+        text: "undefined",
+        start: target.start,
+        end: target.end,
+      };
+      return { kind: SyntaxKind.NewExpression, expression: placeholder, typeArguments: [], arguments: [], start, end: target.end };
+    }
     const callee = this.parseMemberOnlyExpression();
     const typeArguments = this.at(TokenKind.LessThan) ? this.parseTypeArguments() : [];
     const args = this.at(TokenKind.OpenParen) ? this.parseArguments() : [];