@scriptc/compiler 0.0.33 → 0.0.35

package/dist/frontend/lowering/lowerer.d.ts

@@ -232,13 +232,13 @@ export interface LowerOptions {
 }
 /** The Lowerer's pass configuration (see lowerToIr). */
 export interface LowererMode {
-    /** Names of bodies the discovery pass reached; null lowers everything. */
+    /** Names of bodies a prior reachability pass reached; null lowers everything. */
     reachable?: ReadonlySet<string> | null;
     /** Coverage remainder: lower ONLY bodies outside `reachable`, skip the
      * always-reachable init bodies and module building, and report deferred
      * collection diagnostics nothing flushed. */
     remainder?: boolean;
-    /** Symbols whose deferred diagnostics the emit pass already flushed —
+    /** Symbols whose deferred diagnostics reachable emit already flushed —
      * the remainder must not report them a second time. */
     alreadyFlushed?: ReadonlySet<ts.Symbol>;
     /** The build's target platform (LowerOptions.targetPlatform — lowerToIr
@@ -261,24 +261,22 @@ export interface LowererMode {
     /** LowerOptions.externalTypeSpecifiersByFile, shared by every pass. */
     externalTypeSpecifiersByFile?: ReadonlyMap<string, readonly string[]>;
 }
-/** Build lowering runs in two passes over the same ts.Program:
+/** Build lowering runs as a reachability worklist over the ts.Program:
  *
- * 1. DISCOVERY — a worklist computes the set of reachable bodies. Seeds are
+ * 1. REACHABLE EMIT — a worklist computes the set of reachable bodies.
+ *    Seeds are
  *    the per-file init bodies (module top-level statements always run, in
  *    import order); lowering a body yields IR whose call/closure/new/
- *    virtualCall nodes are the edges that enqueue further bodies. The
- *    pass's IR, diagnostics, and stats are discarded — it exists only to
- *    answer "which bodies does the entry reach?".
- * 2. EMIT — a fresh Lowerer lowers in the HISTORICAL order (per file:
- *    function declarations, then class members; then file inits, %main,
- *    generic instances, lifted lambdas), skipping bodies the discovery
- *    pass did not mark. Keeping the emit order (and lambda/instance
- *    numbering) identical to the pre-reachability compiler means a fully
- *    reachable program emits byte-identical C.
+ *    virtualCall nodes are the edges that enqueue further bodies. The pass
+ *    retains that IR. Once the graph closes, those functions are assembled in
+ *    deterministic declaration order beside the already-lowered init,
+ *    generic-instance, and lifted bodies. Checker-backed IR construction
+ *    therefore happens once instead of once for discovery and again for
+ *    emission.
  *
- * `coverage: true` adds a third pass — the REMAINDER — that lowers only
- * the bodies discovery did NOT mark (plus deferred collection diagnostics
- * nothing flushed), reported separately: whole-program analysis without
+ * `coverage: true` adds a second pass — the REMAINDER — that lowers only
+ * the bodies reachable emit did NOT mark (plus deferred collection
+ * diagnostics nothing flushed), reported separately: whole-program analysis without
  * letting unreached code fail builds. */
 export declare function lowerToIr(program: ts.Program, entry: ts.SourceFile, moduleOrder: ts.SourceFile[], options?: LowerOptions): LowerResult;
 /** The island-handle type a `import(...)` initializer gives a binding
@@ -429,6 +427,26 @@ export declare class Lowerer {
         info: GenericFnInfo;
         inst: GenericInstance;
     }[];
+    /** Historical emit rank of the retained declaration/init body currently
+     * lowering, and the earliest such owner that demanded each generic
+     * instance. Reachability can encounter a later caller first; the minimum
+     * rank recovers the old emitter's source-order monomorphization queue. */
+    private genericDemandOwner;
+    private readonly genericDemandRoots;
+    private readonly genericFunctionDemandOwner;
+    private readonly genericClassDemandOwner;
+    private readonly genericDemandPriority;
+    private readonly genericClassDemandPriority;
+    private withGenericDemandOwner;
+    noteGenericInstanceDemand(inst: GenericInstance): void;
+    noteGenericClassInstanceDemand(info: ClassInfo): void;
+    /** The old emitter lowered all reachable declarations in source order,
+     * then every init, before draining generic instances FIFO. Reorder the
+     * retained queue from those recorded demands before any generic body
+     * lowers, so immediate support decisions see the same shape metadata too. */
+    private restoreGenericInstanceOrder;
+    private restoreGenericClassInstanceOrder;
+    private settleGenericDemandPriorities;
     /** Non-null while an instance body lowers: type-parameter symbol →
      * concrete IR type, consulted inside mapType's recursion. */
     typeParamBindings: Map<ts.Symbol, IrType> | null;
@@ -482,6 +500,16 @@ export declare class Lowerer {
     /** Synthetic array-HOF loop functions (map/filter/forEach desugar),
      * interned per method + element/callback-result type: key → fn name. */
     readonly arrHofHelpers: Map<string, string>;
+    /** Derived shape metadata that depends on another shape's declaration
+     * order. These settle before helper bodies rebuild from that metadata. */
+    readonly shapeOrderMetadataFinalizers: (() => void)[];
+    /** Settled generic class-rest metadata requires the historical emit
+     * fallback so its fence can poison the original statement atomically. */
+    requiresHistoricalOrderRelower: boolean;
+    /** Helpers that snapshot shape declaration order into their bodies.
+     * Reachability lowers inits before the declarations they discover, so
+     * these rebuild after the worklist restores historical shape metadata. */
+    readonly shapeOrderHelperFinalizers: (() => void)[];
     /** Emit-override specializations (`%C.emit:<event>` — lower-emitter.ts's
      * emit-overrides block): interned names, the drive-loop queue, and the
      * currently-lowering specialization's context (the super-forward
@@ -726,7 +754,7 @@ export declare class Lowerer {
      * through `this`, so the same ctx serves generic bodies too). */
     readonly typeCtx: TypeMapperCtx;
     readonly stats: LowerStats;
-    /** Discovery-pass edge sink (null in the emit pass): every resolution of
+    /** Reachability edge sink: every resolution of
      * a reference to a lowerable body reports its name here — recorded even
      * when the enclosing statement later poisons. */
     onEdge: ((name: string) => void) | null;
@@ -767,9 +795,12 @@ export declare class Lowerer {
     readonly varGlobalEntryInits: Map<ts.SourceFile, IrGlobal[]>;
     get ctx(): FnCtx;
     get scopes(): Map<ts.Symbol, IrLocal>[];
-    /** Names of bodies the discovery pass reached; null lowers everything
-     * (the discovery pass itself). */
+    /** Names of bodies a prior reachability pass reached; null lowers everything. */
     readonly reachable: ReadonlySet<string> | null;
+    /** Reachability computed by this same Lowerer when retained worklist IR
+     * is assembled directly. The configured reachable set remains null so
+     * demand-driven instance lowering keeps its existing gates. */
+    reachableForArtifacts: ReadonlySet<string> | null;
     /** Coverage remainder mode: the reachability gate inverts (see wantBody)
      * and no module is built. */
     readonly remainder: boolean;
@@ -848,7 +879,7 @@ export declare class Lowerer {
      * namespace path (nsPathPrefix), so `namespace A { export class C }`
      * and a top-level `class C` never collide. Class EXPRESSIONS name by
      * SOURCE POSITION (`%cx<start>.<name>`): deterministic across the
-     * discovery and emit passes (no counter can drift between them),
+     * builds (no counter can drift between invocations),
      * program-unique through the file qualifier, and collision-free with
      * user identifiers ('%'). */
     readonly classNamer: (decl: ts.ClassLikeDeclaration) => string;
@@ -939,13 +970,16 @@ export declare class Lowerer {
      * their external dependencies by name). Null for everything else
      * (builtins load nothing; the rest kept its preflight fence). */
     requireInitStmt(spec: string, node: ts.Node): IrStmt | null;
-    /** True when this body should lower: everything with no reachable set
-     * (discovery), the marked bodies in the emit pass, and exactly the
+    /** True when this body should lower: everything with no reachable set,
+     * the marked bodies in an externally-gated pass, and exactly the
      * UNMARKED bodies in the coverage remainder. */
     wantBody(name: string): boolean;
     collectNpmImports(parts: FileParts[]): void;
     collectJsonImports(parts: FileParts[]): void;
     run(): LowerResult;
+    /** Final retention, pruning, and module assembly shared by ordinary emit
+     * and the retained reachability worklist. */
+    finishModule(functions: IrFunction[]): LowerResult;
     /** The unregistered-class type sweep (run()'s last step before the
      * module assembles): every `{kind:"object"}` TYPE naming a class with
      * no registered ClassInfo is rewritten IN PLACE to the f64 dummy.
@@ -962,12 +996,13 @@ export declare class Lowerer {
     typeNamesUnregisteredClass(t: IrType, seen?: Set<string>): boolean;
     /** Whether run() counts a signature-blocked declaration in
      * stats.functionsSkipped: whole-program passes and the coverage
-     * remainder do; the reachability emit pass leaves the counting to the
+     * remainder do; an externally-gated emit pass leaves the counting to the
      * remainder (the declaration was never reached). */
     countsSkips(): boolean;
-    /** The discovery pass: computes the set of body names the program's entry
-     * reaches. Seeds are the per-file init bodies (top-level statements always
-     * run); edges fire from RESOLUTION sites while a body lowers (noteEdge /
+    /** Reachable emit: computes the set of body names the program's entry
+     * reaches and retains each body IR as it lowers. Seeds are the per-file
+     * init bodies (top-level statements always run); edges fire from
+     * RESOLUTION sites while a body lowers (noteEdge /
      * noteVirtualEdge) — direct calls, closure creation (a taken closure may
      * be called indirectly), `new`, super calls, accessor invocations, and
      * virtual dispatch. Recording at resolution time (not off the produced
@@ -977,9 +1012,12 @@ export declare class Lowerer {
      * demand-driven) and lifted lambdas lower inline with their enclosing
      * body; both fire edges through the same hooks and are not units
      * themselves. */
-    discover(extraRoots?: readonly string[]): Set<string>;
-    /** Discovery hook (see discover): fires when lowering resolves a
-     * reference to a lowerable body. Inert in the emit pass. */
+    emitReachable(extraRoots?: readonly string[]): {
+        reachable: Set<string>;
+        result: LowerResult;
+    };
+    /** Reachability hook (see emitReachable): fires when lowering resolves a
+     * reference to a lowerable body. */
     noteEdge(name: string): void;
     /** Discovery hook for virtual dispatch: a virtualCall on `info`'s static
      * class reaches the nearest declaration at/above it plus every override
@@ -1639,6 +1677,12 @@ export declare class Lowerer {
     lowerGenericFnValue(ref: ts.Expression, info: GenericFnInfo): IrExpr;
     inferTypeParamBindings(expr: ts.CallExpression, info: GenericFnInfo, rsig: ts.Signature, tsBindings?: Map<ts.Symbol, ts.Type>): Map<ts.Symbol, IrType>;
     lowerGenericInstance(info: GenericFnInfo, inst: GenericInstance): IrFunction;
+    /** Checker work class SHAPE collection performs inside otherwise
+     * deferred JavaScript bodies. Constructor assignments declare fields,
+     * so collection asks for each `this.x` symbol and RHS type even when the
+     * constructor is unreachable. Keep that mandatory work batched without
+     * sweeping unrelated dead method bodies. */
+    private prefetchClassCollection;
     collectClassShape(decl: ts.ClassDeclaration): void;
     collectClassShapeInner(decl: ts.ClassLikeDeclaration, jsNameOverride?: string, inst?: {
         family: ClassInfo;