xbintsc 0.5.6 → 0.5.20

package/src/codegen/generator/tables.ts

@@ -37,6 +37,9 @@ export const BUILTIN_INSTANCEOF: Readonly<Record<string, number>> = {
   Date: 5,
   RegExp: 6,
   Promise: 7,
+  WeakMap: 8,
+  WeakSet: 9,
+  WeakRef: 10,
   Uint8Array: 16,
   Int8Array: 17,
   Uint8ClampedArray: 18,
@@ -153,6 +156,10 @@ export const GLOBAL_FUNCTIONS: Record<string, string> = {
   clearTimeout: "xt_clear_timeout",
   setInterval: "xt_set_interval",
   clearInterval: "xt_clear_interval",
+  setImmediate: "xt_set_immediate",
+  clearImmediate: "xt_clear_immediate",
+  queueMicrotask: "xt_queue_microtask",
+  structuredClone: "xt_structured_clone",
   fetch: "xt_fetch",
   Number: "xt_number_ctor",
   String: "xt_string_ctor",
@@ -177,6 +184,10 @@ export const BUILTIN_FUNCTION_VALUES: Record<string, string> = {
   clearTimeout: "xt_builtin_value_clearTimeout",
   setInterval: "xt_builtin_value_setInterval",
   clearInterval: "xt_builtin_value_clearInterval",
+  setImmediate: "xt_builtin_value_setImmediate",
+  clearImmediate: "xt_builtin_value_clearImmediate",
+  queueMicrotask: "xt_builtin_value_queueMicrotask",
+  structuredClone: "xt_builtin_value_structuredClone",
   fetch: "xt_builtin_value_fetch",
   Number: "xt_builtin_value_number",
   String: "xt_builtin_value_string",
@@ -233,9 +244,11 @@ export const NAMESPACE_STATICS: Record<string, string> = {
   Symbol: "xt_symbol_static",
   Date: "xt_date_static",
   Promise: "xt_promise_static",
+  ArrayBuffer: "xt_array_buffer_static",
   path: "xt_path_static",
   os: "xt_os_static",
   process: "xt_process_call",
+  performance: "xt_performance_call",
   Buffer: "xt_buffer_static",
   stream: "xt_stream_static",
   Readable: "xt_stream_static",
@@ -275,6 +288,7 @@ export const NAMESPACE_PROPERTIES: Record<string, string> = {
   process: "xt_process_get",
   "import.meta": "xt_import_meta",
   Symbol: "xt_symbol_get",
+  performance: "xt_performance_get",
 };
 
 /** Global constructors called as `new X(...)` (all have signature `(i32, i64*)`). */
@@ -282,6 +296,9 @@ export const CTOR_FUNCTIONS: Record<string, string> = {
   Array: "xt_array_ctor",
   Map: "xt_map_ctor",
   Set: "xt_set_ctor",
+  WeakMap: "xt_weak_map_ctor",
+  WeakSet: "xt_weak_set_ctor",
+  WeakRef: "xt_weak_ref_ctor",
   Date: "xt_date_ctor",
   RegExp: "xt_regexp_ctor",
   Promise: "xt_promise_ctor",
@@ -294,6 +311,11 @@ export const CTOR_FUNCTIONS: Record<string, string> = {
   Socket: "xt_net_socket_ctor",
   Server: "xt_net_server_ctor",
   EventEmitter: "xt_event_emitter_ctor",
+  URLSearchParams: "xt_url_search_params_ctor",
+  TextEncoder: "xt_text_encoder_ctor",
+  TextDecoder: "xt_text_decoder_ctor",
+  ArrayBuffer: "xt_array_buffer_ctor",
+  DataView: "xt_data_view_ctor",
   ...ERROR_CONSTRUCTORS,
   ...TYPED_ARRAY_CTORS,
 };
@@ -310,6 +332,9 @@ export const FIRST_CLASS_CONSTRUCTORS = new Set<string>([
   "Function",
   "Map",
   "Set",
+  "WeakMap",
+  "WeakSet",
+  "WeakRef",
   "Date",
   "RegExp",
   "Promise",
@@ -391,7 +416,7 @@ export const KIND_NAMES = new Map<number, string>([
   [SyntaxKind.DeleteExpression, "delete expression"],
   [SyntaxKind.AwaitExpression, "await expression"],
   [SyntaxKind.YieldExpression, "yield expression"],
-  [SyntaxKind.SwitchStatement, "switch statement"],
+  [SyntaxKind.ModuleDeclaration, "namespace declaration"],
 ]);
 
 /**

package/src/diagnostics/diagnostic.ts

@@ -20,6 +20,7 @@ export enum DiagnosticCode {
   InvalidAssignmentTarget = 2005,
   DuplicateDefault = 2006,
   InvalidTypeSyntax = 2007,
+  NestingTooDeep = 2008,
 
   // Binder 3xxx
   DuplicateIdentifier = 3001,
@@ -42,6 +43,7 @@ export enum DiagnosticCode {
   IOError = 6002,
   ToolchainError = 6003,
   IncrementalCacheError = 6004,
+  CircularDependency = 6005,
 }
 
 export interface Diagnostic {
@@ -119,9 +121,27 @@ export function formatDiagnostic(d: Diagnostic, source?: SourceFile): string {
     const lineText = source.text.split("\n")[line - 1] ?? "";
     const end = d.end ?? d.start;
     const endCol = source.positionAt(end).column;
-    const caretPad = " ".repeat(Math.max(0, column - 1));
-    const caret = "^".repeat(Math.max(1, endCol - column));
-    excerpt = `\n${lineText}\n${caretPad}${caret}`;
+
+    /* Long lines (a minified bundle, a generated one-liner, deeply nested
+     * source) would otherwise print tens of thousands of characters and make
+     * the actual message impossible to find. Keep a window around the caret. */
+    const maxExcerpt = 160;
+    const caretIndex = Math.max(0, column - 1);
+    let windowStart = 0;
+    let windowEnd = lineText.length;
+    if (lineText.length > maxExcerpt) {
+      windowStart = Math.max(0, caretIndex - Math.floor(maxExcerpt / 2));
+      windowEnd = Math.min(lineText.length, windowStart + maxExcerpt);
+      if (windowEnd === lineText.length) windowStart = Math.max(0, windowEnd - maxExcerpt);
+    }
+    const prefix = windowStart > 0 ? "\u2026" : "";
+    const suffix = windowEnd < lineText.length ? "\u2026" : "";
+    const visible = lineText.slice(windowStart, windowEnd);
+    const visibleCaret = caretIndex - windowStart;
+    const caretWidth = Math.max(1, Math.min(endCol - column, visible.length - visibleCaret));
+    const caretPad = " ".repeat(prefix.length + Math.max(0, visibleCaret));
+    const caret = "^".repeat(caretWidth);
+    excerpt = `\n${prefix}${visible}${suffix}\n${caretPad}${caret}`;
   }
   return `${location} - ${severity} TS${d.code}: ${d.message}${excerpt}`;
 }

package/src/driver/app-artifacts.ts

@@ -0,0 +1,77 @@
+/**
+ * Platform artifacts that turn a linked program into a desktop application:
+ * the Windows-subystem entry shim, the embedded icon object and the Windows PE
+ * icon resource.
+ *
+ * They are collected separately from the link call so icon/GUI/package work
+ * has a home of its own instead of growing `build`.
+ */
+
+import type { ExtensionRegistry } from "../extensions/registry.js";
+import { ensureIconObject, EMPTY_ICON, IconError, type IconInfo } from "./icon.js";
+import { ensureWindowsEntryObject } from "./win-entry.js";
+import { ensureWindowsIconResource, resolveResourceCompiler } from "./win-icon.js";
+import type { AppConfig } from "./config.js";
+import type { Runner } from "./toolchain.js";
+
+export interface AppArtifactRequest {
+  readonly runner: Runner;
+  readonly clang: string;
+  readonly cacheDir: string;
+  readonly registry: ExtensionRegistry;
+  readonly app: AppConfig;
+  readonly icon: IconInfo | undefined;
+  readonly env: Record<string, string>;
+  readonly verbose: boolean | undefined;
+}
+
+export interface AppArtifacts {
+  /** Windows-subsystem entry shim, when the program is a GUI app. */
+  readonly entryObject?: string;
+  readonly iconObjects: readonly string[];
+  /** Extra linker flags implied by the subsystem (empty on other platforms). */
+  readonly linkerFlags: readonly string[];
+  /** Set when the icon could not be embedded; the caller reports it. */
+  readonly iconError?: string;
+}
+
+/**
+ * Build the objects (and flags) that accompany the program object.
+ *
+ * On Windows a GUI program links as a **Windows-subsystem** executable, so
+ * launching it does not flash a console window. That subsystem's C runtime
+ * wants `WinMain`, so a tiny shim object bridges it to the runtime's `main`.
+ * `app.console: true` keeps the console subsystem instead (useful while
+ * debugging, because stdout and stderr only exist there). Other platforms have
+ * no equivalent.
+ */
+export function ensureAppArtifacts(request: AppArtifactRequest): AppArtifacts {
+  const { runner, clang, cacheDir, registry, app, icon, env, verbose } = request;
+  const windowsSubsystem = process.platform === "win32" && registry.has("gui") && app.console !== true;
+  const linkerFlags = windowsSubsystem ? ["-Wl,/SUBSYSTEM:WINDOWS"] : [];
+  const entryObject = windowsSubsystem
+    ? ensureWindowsEntryObject(runner, clang, cacheDir, env)
+    : undefined;
+
+  const iconObjects: string[] = [];
+  // The GUI extension references the icon symbols unconditionally, so a GUI
+  // program gets an (empty) icon object even with no icon configured.
+  if (icon !== undefined || registry.has("gui")) {
+    try {
+      iconObjects.push(ensureIconObject(runner, clang, cacheDir, icon ?? EMPTY_ICON, env));
+      if (icon && process.platform === "win32") {
+        const resourceCompiler = resolveResourceCompiler(runner, clang);
+        if (resourceCompiler) {
+          iconObjects.push(ensureWindowsIconResource(runner, cacheDir, icon, resourceCompiler, env));
+        } else if (verbose) {
+          process.stderr.write("xbintsc: no llvm-rc found; skipping the embedded .exe icon\n");
+        }
+      }
+    } catch (error) {
+      if (error instanceof IconError) return { entryObject, iconObjects, linkerFlags, iconError: error.message };
+      throw error;
+    }
+  }
+
+  return { entryObject, iconObjects, linkerFlags };
+}

package/src/driver/build-key.ts

@@ -0,0 +1,55 @@
+/**
+ * The incremental-cache key.
+ *
+ * Everything that can change the produced binary belongs here: compiler
+ * version, source text, emit kind, optimization/LTO/PGO mode, platform,
+ * extension and runtime fingerprints, and the embedded application metadata.
+ * A feature that adds such an input edits this module (and the call site),
+ * not the build orchestration.
+ */
+
+import type { ExtensionRegistry } from "../extensions/registry.js";
+import { hashParts } from "./cache.js";
+import type { AppConfig } from "./config.js";
+import { compilerFingerprint, registryFingerprint, runtimeFingerprint } from "./fingerprint.js";
+import { COMPILER_VERSION } from "./version.js";
+import type { IconInfo } from "./icon.js";
+import type { PgoMode } from "./toolchain.js";
+
+export interface CacheKeyInput {
+  /** The text the build compiled: the entry source, or the bundled module text. */
+  readonly sourceText: string;
+  readonly emit: string;
+  readonly optimize: string;
+  readonly registry: ExtensionRegistry;
+  readonly runtimeDir: string;
+  readonly icon?: IconInfo;
+  readonly app: AppConfig;
+  readonly debug: boolean;
+  readonly lto: boolean;
+  readonly pgo?: PgoMode;
+  readonly pgoDir: string;
+}
+
+/** Hash every input that can change the produced binary. */
+export function buildCacheKey(input: CacheKeyInput): string {
+  const { app, icon, pgo } = input;
+  return hashParts([
+    COMPILER_VERSION,
+    compilerFingerprint(),
+    input.sourceText,
+    input.emit,
+    input.optimize,
+    process.platform,
+    registryFingerprint(input.registry),
+    runtimeFingerprint(input.runtimeDir),
+    icon ? hashParts(["icon", icon.format, Buffer.from(icon.bytes).toString("base64")]) : "",
+    app.name ?? "",
+    String(app.bundle ?? false),
+    app.bundleId ?? "",
+    String(input.debug),
+    String(input.lto),
+    pgo ?? "",
+    pgo ? input.pgoDir : "",
+  ]);
+}

package/src/driver/bundler/graph.ts

@@ -4,8 +4,8 @@
  */
 
 import { existsSync, readFileSync } from "node:fs";
-import { dirname, extname } from "node:path";
-import { SyntaxKind, type ExportDeclaration, type ImportDeclaration, type Statement } from "../../ast/nodes.js";
+import { dirname, extname, relative } from "node:path";
+import { SyntaxKind, type ExportDeclaration, type ImportDeclaration, type NamedExports, type Statement } from "../../ast/nodes.js";
 import { bind } from "../../binder/binder.js";
 import { DiagnosticBag, DiagnosticCode } from "../../diagnostics/diagnostic.js";
 import { SourceFile } from "../../diagnostics/source.js";
@@ -16,12 +16,47 @@ import { classifyDependency } from "./resolve.js";
 import { collectRequireSites, isNodeModulesPath, usesCommonJS } from "./commonjs.js";
 import type { ModuleRecord } from "./types.js";
 
+/**
+ * True when an import has no runtime binding, so it is not a module edge:
+ * `import type { T } from "..."` or `import { type T } from "..."`. A
+ * side-effect-only import (`import "..."`) and an empty clause
+ * (`import {} from "..."`) both evaluate the module and *are* edges. Types are
+ * erased, so a type-only import must not pull the target into the bundle —
+ * and, in particular, must not turn the mutual `import type` references
+ * between source files into a circular-import error.
+ */
+function isTypeOnlyImport(declaration: ImportDeclaration): boolean {
+  const clause = declaration.importClause;
+  if (!clause) return false;
+  if (clause.isTypeOnly) return true;
+  if (clause.name) return false;
+  const bindings = clause.namedBindings;
+  if (!bindings) return true;
+  if (bindings.kind === SyntaxKind.NamespaceImport) return false;
+  // `import {} from "..."` is an empty clause but still evaluates the module.
+  return bindings.elements.length > 0 && bindings.elements.every((element) => element.isTypeOnly);
+}
+
+/** True when an export declaration only re-exports types. */
+function isTypeOnlyExport(declaration: ExportDeclaration): boolean {
+  if (declaration.isTypeOnly) return true;
+  const clause = declaration.exportClause;
+  if (!clause || clause.kind !== SyntaxKind.NamedExports) return false;
+  const elements = (clause as NamedExports).elements;
+  // `export {} from "..."` is a side-effect re-export, not a type-only one.
+  return elements.length > 0 && elements.every((element) => element.isTypeOnly);
+}
+
 function moduleSpecifierOf(statement: Statement): string | undefined {
   if (statement.kind === SyntaxKind.ImportDeclaration) {
-    return (statement as ImportDeclaration).moduleSpecifier.value;
+    const declaration = statement as ImportDeclaration;
+    if (isTypeOnlyImport(declaration)) return undefined;
+    return declaration.moduleSpecifier.value;
   }
   if (statement.kind === SyntaxKind.ExportDeclaration) {
-    const specifier = (statement as ExportDeclaration).moduleSpecifier;
+    const declaration = statement as ExportDeclaration;
+    if (isTypeOnlyExport(declaration)) return undefined;
+    const specifier = declaration.moduleSpecifier;
     if (specifier) return specifier.value;
   }
   return undefined;
@@ -36,15 +71,30 @@ export function loadGraph(
 ): ModuleRecord[] | undefined {
   const records = new Map<string, ModuleRecord>();
   const order: ModuleRecord[] = [];
-  const visiting = new Set<string>();
+  /* Modules on the current depth-first path, for cycle reporting. A module is
+   * added to `records` only after its dependencies finish, so a back edge is
+   * still "visiting" when it is reached. */
+  const stack: string[] = [];
   let counter = 0;
   let failed = false;
 
-  const load = (path: string): ModuleRecord | undefined => {
+  const load = (
+    path: string,
+    origin?: { readonly file: string; readonly statement: Statement },
+  ): ModuleRecord | undefined => {
     const existing = records.get(path);
     if (existing) return existing;
-    if (visiting.has(path)) {
-      diagnostics.error(DiagnosticCode.CodegenError, `Circular import detected involving '${path}'`);
+    if (stack.includes(path)) {
+      const start = stack.indexOf(path);
+      const cycle = [...stack.slice(start), path]
+        .map((entry) => relative(dirname(entryPath), entry))
+        .join(" -> ");
+      diagnostics.error(
+        DiagnosticCode.CircularDependency,
+        `Circular import detected: ${cycle}`,
+        origin?.statement,
+        origin?.file,
+      );
       failed = true;
       return undefined;
     }
@@ -53,7 +103,7 @@ export function loadGraph(
       failed = true;
       return undefined;
     }
-    visiting.add(path);
+    stack.push(path);
     const raw = sourceTextBytes(readFileSync(path, "utf8"));
     /* An extension may rewrite an imported asset (e.g. `.html`) into a TS
      * module before it is parsed. The core only sees the transformed text. */
@@ -68,7 +118,7 @@ export function loadGraph(
           error instanceof Error ? error.message : String(error),
         );
         failed = true;
-        visiting.delete(path);
+        stack.pop();
         return undefined;
       }
     }
@@ -90,7 +140,6 @@ export function loadGraph(
     // `require` / `module` / `exports` are only honoured inside `node_modules`,
     // so user code keeps its ESM-only diagnostic.
     record.commonjs = isNodeModulesPath(path) && usesCommonJS(bindResult);
-    records.set(path, record);
 
     for (const statement of sourceFile.statements) {
       const specifier = moduleSpecifierOf(statement);
@@ -107,7 +156,7 @@ export function loadGraph(
         failed = true;
         continue;
       }
-      load(dependency.path);
+      load(dependency.path, { file: path, statement });
     }
 
     // A CommonJS module's `require("...")` calls are dynamic import edges: the
@@ -118,7 +167,8 @@ export function loadGraph(
         if (dependency.kind === "file") load(dependency.path);
       }
     }
-    visiting.delete(path);
+    stack.pop();
+    records.set(path, record);
     order.push(record);
     return record;
   };

package/src/driver/bundler/merge.ts

@@ -77,8 +77,10 @@ export function bundleModules(
     for (const statement of record.sourceFile.statements) {
       if (statement.kind === SyntaxKind.ExportDeclaration) {
         const declaration = statement as ExportDeclaration;
+        if (declaration.isTypeOnly) continue;
         if (declaration.exportClause && declaration.exportClause.kind === SyntaxKind.NamedExports) {
           for (const specifier of declaration.exportClause.elements) {
+            if (specifier.isTypeOnly) continue;
             const localName = specifier.propertyName?.text ?? specifier.name.text;
             const exportedName = specifier.name.text;
             if (declaration.moduleSpecifier) {
@@ -144,7 +146,7 @@ export function bundleModules(
       const declaration = statement as ImportDeclaration;
       const dependency = dependencyOf(record, declaration.moduleSpecifier.value);
       const clause = declaration.importClause;
-      if (!clause || !dependency) continue;
+      if (!clause || clause.isTypeOnly || !dependency) continue;
       if (clause.name) {
         const target = dependency.exports.get("default") ?? dependency.exports.get("default");
         const local = scope.symbols.get(clause.name.text);
@@ -153,6 +155,7 @@ export function bundleModules(
       const bindings = clause.namedBindings;
       if (bindings && bindings.kind === SyntaxKind.NamedImports) {
         for (const specifier of bindings.elements) {
+          if (specifier.isTypeOnly) continue;
           const importedName = specifier.propertyName?.text ?? specifier.name.text;
           const target = dependency.exports.get(importedName);
           const local = scope.symbols.get(specifier.name.text);