xbintsc 0.5.6 → 0.5.21

package/src/codegen/generator/numeric.ts

@@ -12,9 +12,41 @@
  * mask and the operation is `bitcast` → `fadd`/`fcmp` → `bitcast`.
  */
 
+import {
+  BinaryOperator,
+  PrefixUnaryOperator,
+  SyntaxKind,
+  type BinaryExpression,
+  type Expression,
+  type PrefixUnaryExpression,
+} from "../../ast/nodes.js";
 import { i64, XT_FALSE, XT_NUMBER_MASK, XT_TRUE } from "../values.js";
 import type { Generator } from "./generator.js";
 
+/** Operators whose runtime result is always `XT_TRUE` / `XT_FALSE`. */
+const BOOLEAN_BINARY: ReadonlySet<string> = new Set([
+  BinaryOperator.LessThan,
+  BinaryOperator.LessThanEquals,
+  BinaryOperator.GreaterThan,
+  BinaryOperator.GreaterThanEquals,
+  BinaryOperator.EqualsEquals,
+  BinaryOperator.ExclamationEquals,
+  BinaryOperator.EqualsEqualsEquals,
+  BinaryOperator.ExclamationEqualsEquals,
+  BinaryOperator.In,
+  BinaryOperator.InstanceOf,
+]);
+
+/** True when the expression's value is a boolean tag, not an arbitrary value. */
+function isBooleanValue(node: Expression): boolean {
+  if (node.kind === SyntaxKind.TrueKeyword || node.kind === SyntaxKind.FalseKeyword) return true;
+  if (node.kind === SyntaxKind.BinaryExpression) {
+    return BOOLEAN_BINARY.has((node as BinaryExpression).operator as string);
+  }
+  return node.kind === SyntaxKind.PrefixUnaryExpression &&
+    (node as PrefixUnaryExpression).operator === PrefixUnaryOperator.Exclamation;
+}
+
 export interface NumericMethods {
   /**
    * Emit `left <operator> right`, using an inline double fast path when both
@@ -27,11 +59,31 @@ export interface NumericMethods {
     operator: string,
     runtime: string,
     allowFastPath?: boolean,
+    leftKnownNumber?: boolean,
+    rightKnownNumber?: boolean,
+  ): string;
+  emitNumericBinary(
+    this: Generator,
+    left: string,
+    right: string,
+    instruction: string,
+    runtime: string,
+    leftKnownNumber?: boolean,
+    rightKnownNumber?: boolean,
+  ): string;
+  emitNumericComparison(
+    this: Generator,
+    left: string,
+    right: string,
+    predicate: string,
+    runtime: string,
+    leftKnownNumber?: boolean,
+    rightKnownNumber?: boolean,
   ): string;
-  emitNumericBinary(this: Generator, left: string, right: string, instruction: string, runtime: string): string;
-  emitNumericComparison(this: Generator, left: string, right: string, predicate: string, runtime: string): string;
   /** Emit an i1 SSA value that is true when `value` is an unboxed double. */
   isNumberValue(this: Generator, value: string): string;
+  /** Emit an i1 branch condition, folding boolean producers to a tag compare. */
+  emitTruthiness(this: Generator, value: string, expression?: Expression): string;
 }
 
 /** Canonical quiet NaN; the runtime uses the same pattern in `xt_from_double`. */
@@ -57,12 +109,16 @@ const NUMERIC_COMPARISON: Record<string, string | undefined> = {
 };
 
 export const numericMethods: NumericMethods = {
-  emitBinaryOperation(left, right, operator, runtime, allowFastPath = true) {
+  emitBinaryOperation(left, right, operator, runtime, allowFastPath = true, leftKnownNumber = false, rightKnownNumber = false) {
     if (allowFastPath) {
       const instruction = NUMERIC_ARITHMETIC[operator];
-      if (instruction) return this.emitNumericBinary(left, right, instruction, runtime);
+      if (instruction) {
+        return this.emitNumericBinary(left, right, instruction, runtime, leftKnownNumber, rightKnownNumber);
+      }
       const predicate = NUMERIC_COMPARISON[operator];
-      if (predicate) return this.emitNumericComparison(left, right, predicate, runtime);
+      if (predicate) {
+        return this.emitNumericComparison(left, right, predicate, runtime, leftKnownNumber, rightKnownNumber);
+      }
     }
     const result = this.reg();
     this.emit(`  ${result} = call i64 @${runtime}(i64 ${left}, i64 ${right})`);
@@ -78,10 +134,10 @@ export const numericMethods: NumericMethods = {
     return result;
   },
 
-  emitNumericBinary(left, right, instruction, runtime) {
+  emitNumericBinary(left, right, instruction, runtime, leftKnownNumber = false, rightKnownNumber = false) {
     const result = this.alloca();
-    const leftIsNumber = this.isNumberValue(left);
-    const rightIsNumber = this.isNumberValue(right);
+    const leftIsNumber = leftKnownNumber ? "true" : this.isNumberValue(left);
+    const rightIsNumber = rightKnownNumber ? "true" : this.isNumberValue(right);
     const bothNumbers = this.reg();
     this.emit(`  ${bothNumbers} = and i1 ${leftIsNumber}, ${rightIsNumber}`);
     const fast = this.label("num.fast");
@@ -119,10 +175,10 @@ export const numericMethods: NumericMethods = {
     return value;
   },
 
-  emitNumericComparison(left, right, predicate, runtime) {
+  emitNumericComparison(left, right, predicate, runtime, leftKnownNumber = false, rightKnownNumber = false) {
     const result = this.alloca();
-    const leftIsNumber = this.isNumberValue(left);
-    const rightIsNumber = this.isNumberValue(right);
+    const leftIsNumber = leftKnownNumber ? "true" : this.isNumberValue(left);
+    const rightIsNumber = rightKnownNumber ? "true" : this.isNumberValue(right);
     const bothNumbers = this.reg();
     this.emit(`  ${bothNumbers} = and i1 ${leftIsNumber}, ${rightIsNumber}`);
     const fast = this.label("cmp.fast");
@@ -155,4 +211,22 @@ export const numericMethods: NumericMethods = {
     this.emit(`  ${merged} = load i64, i64* ${result}`);
     return merged;
   },
+
+  /**
+   * A comparison, `in`/`instanceof` or `!` already evaluates to a boolean tag,
+   * so its truthiness is a tag compare instead of an `xt_truthy` call. This is
+   * the hot condition in `for (let i = 0; i < n; i++)` loops.
+   */
+  emitTruthiness(value, expression) {
+    if (expression && isBooleanValue(expression)) {
+      const result = this.reg();
+      this.emit(`  ${result} = icmp eq i64 ${value}, ${i64(XT_TRUE)}`);
+      return result;
+    }
+    const truthy = this.reg();
+    this.emit(`  ${truthy} = call i32 @xt_truthy(i64 ${value})`);
+    const result = this.reg();
+    this.emit(`  ${result} = icmp ne i32 ${truthy}, 0`);
+    return result;
+  },
 };

package/src/codegen/generator/state.ts

@@ -105,6 +105,9 @@ export const RUNTIME_DECLARATIONS: readonly string[] = [
   "declare i64 @xt_function_set_metadata(i64, i64, i32)",
   "declare i64 @xt_function_set_generator(i64)",
   "declare i64 @xt_function_set_async(i64)",
+  "declare i64 @xt_function_set_async_generator(i64)",
+  "declare i64 @xt_async_iter_open(i64)",
+  "declare i64 @xt_async_iter_next(i64)",
   "declare i64 @xt_closure_call(i64, i32, i64*)",
   "declare i64 @xt_closure_env(i64, i32)",
   "declare i64 @xt_call_with_this(i64, i64, i32, i64*)",
@@ -180,8 +183,17 @@ export const RUNTIME_DECLARATIONS: readonly string[] = [
   "declare i64 @xt_process_get(i64)",
   "declare i64 @xt_map_ctor(i32, i64*)",
   "declare i64 @xt_set_ctor(i32, i64*)",
+  "declare i64 @xt_weak_map_ctor(i32, i64*)",
+  "declare i64 @xt_weak_set_ctor(i32, i64*)",
+  "declare i64 @xt_weak_ref_ctor(i32, i64*)",
+  "declare i64 @xt_text_encoder_ctor(i32, i64*)",
+  "declare i64 @xt_text_decoder_ctor(i32, i64*)",
   "declare i64 @xt_date_ctor(i32, i64*)",
   "declare i64 @xt_regexp_ctor(i32, i64*)",
+  "declare i64 @xt_url_search_params_ctor(i32, i64*)",
+  "declare i64 @xt_array_buffer_ctor(i32, i64*)",
+  "declare i64 @xt_array_buffer_static(i64, i32, i64*)",
+  "declare i64 @xt_data_view_ctor(i32, i64*)",
   "declare i64 @xt_error_ctor(i32, i64*)",
   "declare i64 @xt_type_error_ctor(i32, i64*)",
   "declare i64 @xt_range_error_ctor(i32, i64*)",
@@ -264,6 +276,12 @@ export const RUNTIME_DECLARATIONS: readonly string[] = [
   "declare i64 @xt_clear_timeout(i32, i64*)",
   "declare i64 @xt_set_interval(i32, i64*)",
   "declare i64 @xt_clear_interval(i32, i64*)",
+  "declare i64 @xt_set_immediate(i32, i64*)",
+  "declare i64 @xt_clear_immediate(i32, i64*)",
+  "declare i64 @xt_queue_microtask(i32, i64*)",
+  "declare i64 @xt_performance_get(i64)",
+  "declare i64 @xt_performance_call(i64, i32, i64*)",
+  "declare i64 @xt_structured_clone(i32, i64*)",
   "declare i64 @xt_fetch(i32, i64*)",
   "declare i64 @xt_number_ctor(i32, i64*)",
   "declare i64 @xt_bigint_ctor(i32, i64*)",
@@ -300,6 +318,10 @@ export const RUNTIME_DECLARATIONS: readonly string[] = [
   "declare i64 @xt_builtin_value_clearTimeout(i64, i64, i32, i64*)",
   "declare i64 @xt_builtin_value_setInterval(i64, i64, i32, i64*)",
   "declare i64 @xt_builtin_value_clearInterval(i64, i64, i32, i64*)",
+  "declare i64 @xt_builtin_value_setImmediate(i64, i64, i32, i64*)",
+  "declare i64 @xt_builtin_value_clearImmediate(i64, i64, i32, i64*)",
+  "declare i64 @xt_builtin_value_queueMicrotask(i64, i64, i32, i64*)",
+  "declare i64 @xt_builtin_value_structuredClone(i64, i64, i32, i64*)",
   "declare i64 @xt_builtin_value_fetch(i64, i64, i32, i64*)",
   "declare i64 @xt_builtin_value_number(i64, i64, i32, i64*)",
   "declare i64 @xt_builtin_value_string(i64, i64, i32, i64*)",
@@ -310,6 +332,7 @@ export const RUNTIME_DECLARATIONS: readonly string[] = [
   "declare i64 @xt_symbol_static(i64, i32, i64*)",
   "declare i64 @xt_symbol_get(i64)",
   "declare i64 @xt_get(i64, i64)",
+  "declare i64 @xt_get_ic(i64, i64, i64*)",
   "declare i64 @xt_set(i64, i64, i64)",
   "declare i64 @xt_box_new(i64)",
   "declare i64 @xt_box_get(i64)",

package/src/codegen/generator/statements/control-flow.ts

@@ -71,10 +71,7 @@ export const controlFlowStatementMethods: ControlFlowStatementMethods = {
     const elseLabel = statement.elseStatement ? this.label("if.else") : undefined;
     const endLabel = this.label("if.end");
     const condition = this.emitExpression(statement.condition);
-    const truthy = this.reg();
-    this.emit(`  ${truthy} = call i32 @xt_truthy(i64 ${condition})`);
-    const nonzero = this.reg();
-    this.emit(`  ${nonzero} = icmp ne i32 ${truthy}, 0`);
+    const nonzero = this.emitTruthiness(condition, statement.condition);
     this.terminate(`br i1 ${nonzero}, label %${thenLabel}, label %${elseLabel ?? endLabel}`);
 
     this.startBlock(thenLabel);

package/src/codegen/generator/statements/loops.ts

@@ -12,7 +12,7 @@ import {
   type VariableDeclarationList,
   type WhileStatement,
 } from "../../../ast/nodes.js";
-import { numberLiteral } from "../../values.js";
+import { i64, numberLiteral, XT_TRUE } from "../../values.js";
 import type { Generator } from "../generator.js";
 import type { LoopLabels } from "../state.js";
 
@@ -48,10 +48,7 @@ export const loopStatementMethods: LoopStatementMethods = {
     this.terminate(`br label %${condLabel}`);
     this.startBlock(condLabel);
     const condition = this.emitExpression(statement.condition);
-    const truthy = this.reg();
-    this.emit(`  ${truthy} = call i32 @xt_truthy(i64 ${condition})`);
-    const nonzero = this.reg();
-    this.emit(`  ${nonzero} = icmp ne i32 ${truthy}, 0`);
+    const nonzero = this.emitTruthiness(condition, statement.condition);
     this.terminate(`br i1 ${nonzero}, label %${bodyLabel}, label %${endLabel}`);
     this.startBlock(bodyLabel);
     this.current.loops.push({ breakLabel: endLabel, continueLabel: condLabel, tryDepth: this.current.tryFrames.length, labels: this.takePendingLabels() });
@@ -74,10 +71,7 @@ export const loopStatementMethods: LoopStatementMethods = {
 
     this.startBlock(condLabel);
     const condition = this.emitExpression(statement.condition);
-    const truthy = this.reg();
-    this.emit(`  ${truthy} = call i32 @xt_truthy(i64 ${condition})`);
-    const nonzero = this.reg();
-    this.emit(`  ${nonzero} = icmp ne i32 ${truthy}, 0`);
+    const nonzero = this.emitTruthiness(condition, statement.condition);
     this.terminate(`br i1 ${nonzero}, label %${bodyLabel}, label %${endLabel}`);
     this.startBlock(endLabel);
   },
@@ -103,10 +97,7 @@ export const loopStatementMethods: LoopStatementMethods = {
     this.startBlock(condLabel);
     if (statement.condition) {
       const condition = this.emitExpression(statement.condition);
-      const truthy = this.reg();
-      this.emit(`  ${truthy} = call i32 @xt_truthy(i64 ${condition})`);
-      const nonzero = this.reg();
-      this.emit(`  ${nonzero} = icmp ne i32 ${truthy}, 0`);
+      const nonzero = this.emitTruthiness(condition, statement.condition);
       this.terminate(`br i1 ${nonzero}, label %${bodyLabel}, label %${endLabel}`);
     } else {
       this.terminate(`br label %${bodyLabel}`);
@@ -128,6 +119,50 @@ export const loopStatementMethods: LoopStatementMethods = {
   emitForOf(statement: ForOfStatement | ForInStatement): void {
     const source = this.emitExpression(statement.expression);
     const isForIn = statement.kind === SyntaxKind.ForInStatement;
+    /* `for await (const x of xs)`: resolve the async iteration protocol once,
+     * await one step per iteration, then bind its `value`. Running the await
+     * inside the surrounding async coroutine is what makes the loop suspend
+     * between elements instead of blocking the event loop. */
+    if (!isForIn && (statement as ForOfStatement).awaitModifier) {
+      const iterable = this.runtimeCall("xt_async_iter_open", [source]);
+      const condLabel = this.label("forawait.cond");
+      const bodyLabel = this.label("forawait.body");
+      const updateLabel = this.label("forawait.update");
+      const endLabel = this.label("forawait.end");
+      this.terminate(`br label %${condLabel}`);
+
+      this.startBlock(condLabel);
+      const next = this.runtimeCall("xt_async_iter_next", [iterable]);
+      const step = this.runtimeCall("xt_await", [next]);
+      const doneKey = this.stringValue("done");
+      const done = this.runtimeCall("xt_get", [step, doneKey]);
+      /* `xt_truthy` returns i32, so it cannot go through `runtimeCall`
+       * (which types every result as i64). */
+      const truthy = this.reg();
+      this.emit(`  ${truthy} = call i32 @xt_truthy(i64 ${done})`);
+      const nonzero = this.reg();
+      this.emit(`  ${nonzero} = icmp ne i32 ${truthy}, 0`);
+      this.terminate(`br i1 ${nonzero}, label %${endLabel}, label %${bodyLabel}`);
+
+      this.startBlock(bodyLabel);
+      const valueKey = this.stringValue("value");
+      const element = this.runtimeCall("xt_get", [step, valueKey]);
+      this.bindLoopVariable(statement.initializer, element);
+      this.current.loops.push({
+        breakLabel: endLabel,
+        continueLabel: updateLabel,
+        tryDepth: this.current.tryFrames.length,
+        labels: this.takePendingLabels(),
+      });
+      this.emitStatement(statement.statement);
+      this.current.loops.pop();
+      if (!this.current.terminated) this.terminate(`br label %${updateLabel}`);
+
+      this.startBlock(updateLabel);
+      this.terminate(`br label %${condLabel}`);
+      this.startBlock(endLabel);
+      return;
+    }
     // `for...in` iterates the enumerable keys (indices become strings);
     // `for...of` resolves the iteration protocol once, then walks it.
     const iterable = isForIn
@@ -148,10 +183,9 @@ export const loopStatementMethods: LoopStatementMethods = {
     /* `xt_iter_has` covers generators too, which cannot be sized up front. */
     const hasValue = this.reg();
     this.emit(`  ${hasValue} = call i64 @xt_iter_has(i64 ${iterable}, i64 ${index})`);
-    const truthy = this.reg();
-    this.emit(`  ${truthy} = call i32 @xt_truthy(i64 ${hasValue})`);
+    /* `xt_iter_has` always returns a boolean tag, so skip `xt_truthy`. */
     const nonzero = this.reg();
-    this.emit(`  ${nonzero} = icmp ne i32 ${truthy}, 0`);
+    this.emit(`  ${nonzero} = icmp eq i64 ${hasValue}, ${i64(XT_TRUE)}`);
     this.terminate(`br i1 ${nonzero}, label %${bodyLabel}, label %${endLabel}`);
 
     this.startBlock(bodyLabel);

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 : "",
+  ]);
+}