xbintsc 0.3.13 → 0.3.15

package/scripts/build-runtime.ts

@@ -29,16 +29,15 @@ const outDir = join(runtimeDir, "lib", platformSlug());
 const objDir = join(root, "build", "runtime-obj");
 
 if (process.platform === "win32") {
-  // The Windows release ships no prebuilt archives yet: the current MSVC CI
-  // cannot produce MinGW-compatible objects, so the driver compiles the C
-  // sources on demand. Revisit once the bundled MinGW-w64 ABI lands.
-  // See doc/self-contained-roadmap.md.
-  console.log("xbintsc: skipped runtime archives on Windows until the MinGW-w64 toolchain lands");
+  // The driver links with the MSVC ABI on Windows, where the prebuilt archives
+  // are unnecessary: `build` compiles the runtime C sources on demand with the
+  // user's clang. (Producing MSVC-compatible COFF `.lib` archives is possible
+  // but not worth the extra step.)
+  console.log("xbintsc: skipping runtime archives on Windows; the driver compiles the C sources on demand");
   process.exit(0);
 }
 
-// Use the same toolchain the driver will: a bundled clang when present, with its
-// `LD_LIBRARY_PATH` (the legacy `libtinfo.so.5` on Linux) threaded through.
+// Use the same toolchain the driver will.
 const toolchain = resolveToolchain();
 const clang = toolchain.clang;
 const childEnv = Object.assign({}, process.env, toolchain.env);
@@ -54,7 +53,7 @@ function findArchiver(clangPath: string): string {
   const exe = process.platform === "win32" ? ".exe" : "";
   const candidates = [
     process.env.xbintsc_AR,
-    // A bundled toolchain ships `llvm-ar` next to clang.
+    // A clang install usually ships `llvm-ar` next to the driver.
     dir === "." ? undefined : join(dir, `llvm-ar${exe}`),
     "llvm-ar",
     "ar",

package/scripts/coverage-runtime.ts

@@ -160,9 +160,9 @@ function runs(command: string): boolean {
 
 /**
  * Locate the LLVM tool `name` (`llvm-profdata`/`llvm-cov`) that matches the
- * clang the driver resolved. The bundled toolchains ship the tools next to
- * clang and cover the versioned system installs, so search there first: mixing
- * versions makes `llvm-profdata` reject the profile format.
+ * clang the driver resolved. Prefer the tool next to clang, then the
+ * version-suffixed system installs: mixing versions makes `llvm-profdata`
+ * reject the profile format.
  */
 function findTool(clang: string, name: string): string | undefined {
   const exe = process.platform === "win32" ? ".exe" : "";
@@ -282,7 +282,7 @@ function main(): void {
       profdataTool ? undefined : "llvm-profdata",
       covTool ? undefined : "llvm-cov",
     ].filter(Boolean).join(", ");
-    skip(`${missing} not found for ${clang}; install LLVM or use the bundled toolchain`, options.strict);
+    skip(`${missing} not found for ${clang}; install the LLVM tools (llvm-profdata, llvm-cov)`, options.strict);
   }
 
   if (!options.reportOnly) runTests(options);

package/scripts/package-release.ts

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 /**
- * Assemble a self-contained release archive for the current platform:
+ * Assemble a release archive for the current platform:
  *
  *   dist/release/xbintsc-<version>-<os>-<arch>.tar.gz        (or .tar.zst)
  *   dist/release/xbintsc-<version>-<os>-<arch>.tar.gz.sha256
@@ -10,23 +10,24 @@
  *
  * The unpacked staging tree is built under `build/release-stage/`, never under
  * `dist/release/`, so an upload glob over `dist/release/*` cannot accidentally
- * ship the (multi-GB) tree alongside the archive.
+ * ship the (large) tree alongside the archive.
+ *
+ * xbintsc does not bundle a compiler: the archive holds only the self-hosted
+ * binary and the C runtime sources plus prebuilt archives. Users provide the
+ * toolchain themselves (see `doc/requirements.md`).
  *
  * Layout inside the archive:
  *
  *   xbintsc-<os>-<arch>/
  *     bin/xbintsc[.exe]     the self-hosted compiler
  *     runtime/              C runtime sources + prebuilt runtime/lib/<slug>
- *     vendor/<slug>/        the bundled clang+lld toolchain (Linux/Windows)
  *     README.md
  *
- * The compiler locates `runtime/` and `vendor/` relative to its own executable
- * (see `findRuntimeDir`/`findVendorDir`), so this tree runs with no system
- * toolchain installed.
+ * The compiler locates `runtime/` relative to its own executable (see
+ * `findRuntimeDir`), so this tree runs without any bundled toolchain.
  *
  * Inputs:
  *   - the self-hosted binary staged at `dist/xbintsc[.exe]` (CI copies it there)
- *   - `vendor/<slug>/`, fetched by `scripts/fetch-toolchain.ts`
  *   - `runtime/lib/<slug>/`, built by `scripts/build-runtime.ts`
  */
 
@@ -37,9 +38,7 @@ import {
   chmodSync,
   existsSync,
   mkdirSync,
-  readdirSync,
   readFileSync,
-  realpathSync,
   rmSync,
   statSync,
   writeFileSync,
@@ -49,14 +48,12 @@ import { basename, dirname, join, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 import {
   findRuntimeDir,
-  platformSlug,
   releaseArchiveBase,
   releaseArchiveExtension,
   releaseArchiveFileName,
 } from "../src/driver/paths.js";
 
 const root = resolve(dirname(fileURLToPath(import.meta.url)), "..");
-const slug = platformSlug();
 const base = releaseArchiveBase();
 const version = (
   JSON.parse(readFileSync(join(root, "package.json"), "utf8")) as { version: string }
@@ -77,55 +74,6 @@ function firstExisting(candidates: readonly string[]): string | undefined {
   return undefined;
 }
 
-/**
- * Copy only the parts of the fetched toolchain that xbintsc actually runs.
- *
- * The official LLVM release unpacks to ~7 GB: every MLIR/Flang/lldb tool, the
- * static archives and the full C++ headers. The compiler only shells out to the
- * clang driver, the lld linker and llvm-ar, and clang additionally needs its own
- * resource directory (`lib/clang/<version>`, the builtin headers and
- * compiler-rt). Copying just those keeps the archive ~100x smaller.
- */
-function stageToolchain(vendor: string, dest: string): void {
-  const exe = process.platform === "win32" ? ".exe" : "";
-  mkdirSync(join(dest, "bin"), { recursive: true });
-
-  const real = (...candidates: readonly string[]): string | undefined => {
-    const found = firstExisting(candidates.map((candidate) => join(vendor, candidate)));
-    return found ? realpathSync(found) : undefined;
-  };
-  const copyAs = (source: string | undefined, name: string): void => {
-    if (!source) return;
-    const target = join(dest, "bin", name);
-    copyFileSync(source, target);
-    if (process.platform !== "win32") chmodSync(target, 0o755);
-  };
-
-  // In the official release `clang`/`ld.lld` are symlinks into the bin/ dir;
-  // copy the resolved targets under the names the toolchain provider (and
-  // clang's `-fuse-ld=lld`) expect next to `bin/clang`.
-  copyAs(real(`bin/clang${exe}`, `bin/clang-18${exe}`), `clang${exe}`);
-  copyAs(real(`bin/ld.lld${exe}`, `bin/lld${exe}`), `ld.lld${exe}`);
-  copyAs(real(`bin/llvm-ar${exe}`, "bin/llvm-ar"), `llvm-ar${exe}`);
-
-  // clang's resource directory: builtin headers + compiler-rt archives.
-  const resourceDir = join(vendor, "lib", "clang");
-  if (existsSync(resourceDir)) {
-    cpSync(resourceDir, join(dest, "lib", "clang"), { recursive: true });
-  }
-
-  // Shared libraries the fetch placed next to the toolchain (on Linux that is
-  // the legacy `libtinfo.so.5` the official build still links).
-  const libDir = join(vendor, "lib");
-  if (existsSync(libDir)) {
-    for (const entry of readdirSync(libDir, { withFileTypes: true })) {
-      if (/^(.*\.so(\.\d+)*|.*\.dylib|.*\.dll)$/.test(entry.name)) {
-        cpSync(join(libDir, entry.name), join(dest, "lib", entry.name), { recursive: true });
-      }
-    }
-  }
-}
-
 const distDir = join(root, "dist");
 const binary = firstExisting([
   join(distDir, `xbintsc${exeSuffix}`),
@@ -138,7 +86,7 @@ if (!binary) {
 
 // Archives go to `dist/release/`; the unpacked staging tree goes to
 // `build/release-stage/` so the upload glob over `dist/release/*` cannot pick up
-// the raw tree (which would ship the toolchain twice, and uncompressed).
+// the raw tree.
 const releaseRoot = join(distDir, "release");
 const stageRoot = join(root, "build", "release-stage");
 const stage = join(stageRoot, base);
@@ -156,33 +104,13 @@ console.log(`xbintsc: packaged binary ${basename(binary)} (${statSync(binary).si
 cpSync(findRuntimeDir(), join(stage, "runtime"), { recursive: true });
 console.log("xbintsc: packaged runtime/");
 
-// 3. The bundled toolchain, when one was fetched for this platform.
-const vendor = join(root, "vendor", slug);
-if (existsSync(join(vendor, "bin"))) {
-  if (process.platform === "win32") {
-    // llvm-mingw spreads its MinGW-w64 CRT/import libraries across the tree, so
-    // bundling it whole is the safe default there for now.
-    cpSync(vendor, join(stage, "vendor", slug), { recursive: true });
-  } else {
-    stageToolchain(vendor, join(stage, "vendor", slug));
-  }
-  console.log(`xbintsc: packaged vendor/${slug}/`);
-} else if (process.platform === "linux" || process.platform === "win32") {
-  console.warn(
-    `xbintsc: warning: no vendor/${slug}/ found; the release will rely on a system toolchain. ` +
-      "Run `npm run fetch-toolchain` first for a self-contained archive.",
-  );
-} else {
-  console.log(`xbintsc: no bundled toolchain for ${slug}; relying on the system SDK (macOS)`);
-}
-
-// 4. Human-facing notes.
+// 3. Human-facing notes.
 for (const name of ["README.md", "LICENSE"]) {
   const source = join(root, name);
   if (existsSync(source)) copyFileSync(source, join(stage, name));
 }
 
-// 5. Archive it. Prefer zstd when available, otherwise gzip.
+// 4. Archive it. Prefer zstd when available, otherwise gzip.
 const hasZstd = !spawnSync("zstd", ["--version"], { stdio: "ignore" }).error;
 const extension = releaseArchiveExtension(hasZstd);
 const archive = join(releaseRoot, `${archiveBase}${extension}`);
@@ -192,7 +120,7 @@ const tar = spawnSync("tar", tarArgs, { stdio: "inherit" });
 if (tar.error) fail(`failed to run tar: ${tar.error.message}`);
 if (tar.status !== 0) fail(`tar exited with ${tar.status}`);
 
-// 6. Checksum, so users can verify the download.
+// 5. Checksum, so users can verify the download.
 const digest = createHash("sha256").update(readFileSync(archive)).digest("hex");
 writeFileSync(`${archive}.sha256`, `${digest}  ${basename(archive)}\n`);
 

package/src/cli/main.ts

@@ -172,7 +172,10 @@ function doctor(io: CliIo): number {
     io.stdout(`toolchain  : ${toolchain.clang} (${toolchain.source})\n`);
     io.stdout(`compiler   : ${firstLine(version) || "unknown"}\n`);
   } catch {
-    io.stdout("toolchain  : not found (install the Xcode Command Line Tools or set xbintsc_CLANG)\n");
+    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");
   }
 
   try {

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

@@ -106,6 +106,21 @@ export const accessCallMethods: AccessCallMethods = {
         }
       }
     }
+    // Modules with no namespace dispatcher (`fs`, ...) can still expose value
+    // getters (`fs.constants`, `fs.promises`). Lower `fs.constants` the same
+    // way a named `import { constants } from "fs"` is lowered.
+    if (node.expression.kind === SyntaxKind.Identifier) {
+      const moduleExports = this.moduleExportsOfSymbol(
+        this.binding.symbolOfIdentifier.get(node.expression as Identifier),
+      );
+      const exported = moduleExports?.[node.name.text];
+      if (exported?.valueSymbol) {
+        this.extraDeclarations.add(`declare i64 @${exported.valueSymbol}(i32, i64*)`);
+        const result = this.reg();
+        this.emit(`  ${result} = call i64 @${exported.valueSymbol}(i32 0, i64* null)`);
+        return result;
+      }
+    }
     const object = this.emitExpression(node.expression);
     return this.emitPropertyGet(object, node.name.text);
   },

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

@@ -91,8 +91,14 @@ export const invocationCallMethods: InvocationCallMethods = {
       return result;
     }
     if (callee.kind === SyntaxKind.Identifier) {
-      if ((callee as Identifier).text === "super") return this.emitSuperConstructor(node);
-      const symbol = this.binding.symbolOfIdentifier.get(callee as Identifier);
+      const identifier = callee as Identifier;
+      if (identifier.text === "super") return this.emitSuperConstructor(node);
+      const symbol = this.binding.symbolOfIdentifier.get(identifier);
+      // `require("x")` is CommonJS; the ESM form is the only supported import.
+      if (!symbol && identifier.text === "require") {
+        this.reportRequireUse(node);
+        return i64(XT_UNDEFINED);
+      }
       if (symbol && symbol.kind === SymbolKind.Import) {
         const exported = this.importExports.get(symbol.id);
         if (exported) return this.emitModuleExport(node, exported);

package/src/codegen/generator/context.ts

@@ -162,8 +162,8 @@ export class GeneratorContext {
     if (!symbols.some((symbol) => this.usedAsValue(symbol))) return;
     this.diagnostics.error(
       DiagnosticCode.ModuleNotFound,
-      `module '${specifier}' is not supported: xbintsc can only import built-in platform modules and ` +
-        "relative '.ts' files; third-party npm packages (node_modules) are not implemented yet",
+      `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,
     );
@@ -414,6 +414,34 @@ export class GeneratorContext {
       this.sourceFile.fileName,
     );
   }
+
+  /**
+   * Report a CommonJS `require(...)` use. xbintsc has no CommonJS module
+   * runtime, so point the user at the ESM `import` form (with the requested
+   * module in the hint when it is a string literal).
+   */
+  reportRequireUse(node: Node): void {
+    const specifier = requireSpecifier(node);
+    const replacement = specifier
+      ? `use an ESM import instead, e.g. \`import value from ${JSON.stringify(specifier)}\``
+      : "use an ESM `import` statement instead";
+    this.diagnostics.error(
+      DiagnosticCode.UnsupportedFeature,
+      `CommonJS \`require()\` is not supported; ${replacement}`,
+      node,
+      this.sourceFile.fileName,
+    );
+  }
+}
+
+/** The string literal passed to `require("...")`, when there is one. */
+function requireSpecifier(node: Node): string | undefined {
+  if (node.kind !== SyntaxKind.CallExpression) return undefined;
+  const first = (node as { arguments?: readonly Node[] }).arguments?.[0];
+  if (first && first.kind === SyntaxKind.StringLiteral) {
+    return (first as unknown as { value: string }).value;
+  }
+  return undefined;
 }
 
 /** A bare module specifier (`fs`, `node:fs`, `@scope/pkg`), not a file path. */

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

@@ -235,6 +235,11 @@ export const primaryExpressionMethods: PrimaryExpressionMethods = {
           const nameValue = this.stringValue(identifier.text);
           return this.runtimeCall("xt_error_constructor", [nameValue]);
         }
+        // A bare `require` reference is CommonJS; steer the user to `import`.
+        if (identifier.text === "require") {
+          this.reportRequireUse(identifier);
+          return i64(XT_UNDEFINED);
+        }
         this.diagnostics.error(
           DiagnosticCode.CannotFindName,
           `Cannot find name '${identifier.text}'`,

package/src/codegen/generator/tables.ts

@@ -12,12 +12,11 @@ import {
 /**
  * True when a `try` frame must be saved with `_setjmpex` rather than `_setjmp`.
  *
- * 64-bit Windows on ARM has no `_setjmp`: both the UCRT and MinGW-w64 declare
- * `setjmp` as `_setjmpex(buf, sponentry)` there, so the linker expects
- * `_setjmpex` (with the caller's stack pointer at entry, `llvm.sponentry`,
- * instead of its frame pointer). clang lowers a C `setjmp` on this target to
- * exactly that pair. Checked at code-generation time because xbintsc builds for
- * its own host.
+ * 64-bit Windows on ARM has no `_setjmp`: the UCRT declares `setjmp` as
+ * `_setjmpex(buf, sponentry)` there, so the linker expects `_setjmpex` (with the
+ * caller's stack pointer at entry, `llvm.sponentry`, instead of its frame
+ * pointer). clang lowers a C `setjmp` on this target to exactly that pair.
+ * Checked at code-generation time because xbintsc builds for its own host.
  */
 export function requiresSetjmpex(platform: string, arch: string): boolean {
   return platform === "win32" && arch === "arm64";

package/src/driver/compiler.ts

@@ -77,6 +77,19 @@ export function compileString(source: string, fileName = "input.ts", extensions?
   return { ir, diagnostics: diagnostics.diagnostics };
 }
 
+/**
+ * Every module specifier the registry can resolve at code generation time (the
+ * registered platform modules plus the hints for known-but-disabled
+ * extensions). Bare imports outside this set are looked up in `node_modules`
+ * and bundled as source.
+ */
+function externalModuleSpecifiers(registry: ExtensionRegistry): Set<string> {
+  return new Set([
+    ...Object.keys(registry.modules()),
+    ...Object.keys(registry.moduleHints()),
+  ]);
+}
+
 /**
  * Compile a file to LLVM IR, bundling every reachable relative module first so
  * that imports from other TypeScript sources resolve exactly like `build`.
@@ -88,6 +101,7 @@ export function compileEntry(entryPath: string, extensions?: ExtensionRegistry):
   const diagnostics = new DiagnosticBag();
   const parser = new Parser(file, diagnostics);
   let sourceFile = parser.parseSourceFile();
+  const registry = extensions ?? createDefaultRegistry();
   const isModule = sourceFile.statements.some(
     (statement) =>
       statement.kind === SyntaxKind.ImportDeclaration ||
@@ -95,10 +109,9 @@ export function compileEntry(entryPath: string, extensions?: ExtensionRegistry):
       statement.kind === SyntaxKind.ExportAssignment,
   );
   if (isModule) {
-    const bundled = bundleModules(absoluteEntry, diagnostics);
+    const bundled = bundleModules(absoluteEntry, diagnostics, externalModuleSpecifiers(registry));
     if (bundled) sourceFile = bundled.sourceFile;
   }
-  const registry = extensions ?? createDefaultRegistry();
   const { ir } = generate(sourceFile, diagnostics, {
     builtins: registry.builtins(),
     modules: registry.modules(),
@@ -172,7 +185,7 @@ export function build(entryPath: string, options: BuildOptions = {}): BuildResul
   );
   let cacheText = sourceText;
   if (isModule) {
-    const bundled = bundleModules(absoluteEntry, diagnostics);
+    const bundled = bundleModules(absoluteEntry, diagnostics, externalModuleSpecifiers(registry));
     if (bundled) {
       sourceFile = bundled.sourceFile;
       cacheText = bundled.text;

package/src/driver/index.ts

@@ -1,14 +1,6 @@
 export { build, compileString, COMPILER_VERSION, type BuildOptions, type BuildResult, type EmitKind } from "./compiler.js";
 export { BuildCache, hashParts, hashString } from "./cache.js";
-export { findRuntimeDir, findPackageRoot, findVendorDir, vendorRootDir, platformSlug, releaseArchiveBase, releaseArchiveFileName, releaseArchiveExtension } from "./paths.js";
-export {
-  toolchainDownload,
-  toolchainSupportLibraries,
-  LLVM_VERSION,
-  LLVM_MINGW_VERSION,
-  type ToolchainDownload,
-  type SupportLibrary,
-} from "./toolchain-download.js";
+export { findRuntimeDir, platformSlug, releaseArchiveBase, releaseArchiveFileName, releaseArchiveExtension } from "./paths.js";
 export { findRuntimeLibrary, runtimeLibDir } from "./runtime-lib.js";
 export {
   findClang,