@scriptc/compiler 0.2.0 → 0.2.2

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

@@ -4,9 +4,11 @@ export type { WidthLift } from "./width-lift.js";
 import { type FnCtx } from "./function-context.js";
 export { newFnCtx, type FnCtx } from "./function-context.js";
 import type { FrontendServices } from "../services.js";
+import { DeferredModuleInitializers } from "./deferred-module-initializers.js";
 import type { ClassSymbolKey } from "./symbol-fields.js";
 import type { HttpClientFnBinding } from "./lower-server.js";
 import * as ts from "../ts7/adapter.js";
+import { type UnionLiteral } from "../union-discriminants.js";
 import type { ScrDiagnostic } from "../../diagnostics/diagnostic.js";
 import { UNSUPPORTED } from "../../diagnostics/diagnostic.js";
 import type { IrClassDef, IrExpr, IrFfiImport, IrFunction, IrGlobal, IrLocal, IrModule, IrParam, IrRecordShape, IrStmt, IrType, IrUnionDef, SrcLoc } from "../../ir/ir.js";
@@ -290,7 +292,7 @@ export declare function dynUndefinedExpr(loc: SrcLoc): IrExpr;
  * symbol-to-string TypeError). kind 0 Error / 1 TypeError / 2 RangeError;
  * an empty code means no code slot. `type` is the replaced expression's
  * own (never materialized — the global.undefRead pattern). */
-export declare function nodeThrowExpr(kind: 0 | 1 | 2, code: string, message: string, type: IrType, loc: SrcLoc): IrExpr;
+export declare function nodeThrowExpr(kind: 0 | 1 | 2 | 5, code: string, message: string, type: IrType, loc: SrcLoc): IrExpr;
 /** The post-validation fence STRING a validation-ladder Chk libCall
  * throws after its Node-order checks pass: the same SC2020 text the
  * per-statement runtime fence would have thrown (message + "[code at
@@ -323,15 +325,13 @@ export declare function ladderFenceExpr(lowerer: Lowerer, surface: string, node:
  *
  * Null for void (no value exists to represent). */
 export declare function dynFallbackType(lowerer: Lowerer, node: ts.Node, t: ts.Type): IrType | null;
-/** The best-effort JS `Function.prototype.name` of an expression flowing
- * into a dyn slot (the boxed function kind's inspect/error name):
- * identifier and property reads answer the referenced NAME (a
- * REFERENCE-SITE approximation of JS's creation-site naming — an aliased
- * binding reports the alias; SEMANTICS.md), named function expressions
+/** The JS `Function.prototype.name` of an expression flowing into a dyn
+ * slot. Immutable identifier aliases retain their creation-site name; property
+ * reads answer the referenced name. Named function expressions
  * their own name, anonymous function/arrow expressions their
  * NamedEvaluation home (a variable initializer or property assignment).
  * Null when nothing names the value (the box stays anonymous). */
-export declare function jsFuncNameOf(node: ts.Node): string | null;
+export declare function jsFuncNameOf(node: ts.Node, lowerer?: Lowerer): string | null;
 export declare class Lowerer {
     readonly program: ts.Program;
     readonly entry: ts.SourceFile;
@@ -360,6 +360,9 @@ export declare class Lowerer {
     /** Per-symbol result of the never-reassigned file scan
      * (bindingNeverReassigned — object-literal generic-method receivers). */
     readonly neverReassignedCache: Map<ts.Symbol, boolean>;
+    /** Syntactic writes indexed once per JS scope. Symbol and RHS type
+     * checks remain contextual to each binding probe. */
+    readonly jsBindingWritesByOwner: Map<import("../ts7/ast-node.js").AstNode, Map<string, ts.BinaryExpression[]>>;
     /** TRAP bindings: declarations whose initializer provably throws before
      * producing a value (its chain roots at an ambient-undefined name —
      * ambientUndefVarRootOf). Module init unwinds at the declaration, so no
@@ -507,8 +510,8 @@ export declare class Lowerer {
     } | null;
     /** Recover the original optional union when a checked single-arm helper
      * was installed before a strict property consumer could name its member.
-     * Recovery is limited to array element reads and storage roots marked by
-     * the optional-read analysis, so ordinary assertions keep their generic
+     * Recovery covers member reads and storage roots marked by the
+     * optional-read analysis, so ordinary assertions keep their generic
      * checked-narrow behavior. */
     runtimeOptionalSourceValue(node: ts.Expression, value: IrExpr): IrExpr | null;
     /** A strict property or method receiver over an array-derived optional
@@ -588,6 +591,17 @@ export declare class Lowerer {
     /** Union re-tag helpers (%union.retag.N), interned per (from, to)
      * unionId pair — see unionRetagHelper. */
     readonly retagHelpers: Map<string, string>;
+    /** Copy-only routes depend on the two union contracts and discriminator
+     * layouts, without recursive width assumptions or evolving class members. */
+    private readonly copyRetagHelpers;
+    private readonly unionLiteralOwners;
+    private readonly strippedUndefinedArms;
+    private readonly addedUndefinedArms;
+    private readonly stdlibSymbols;
+    /** Method adapter names are owned by class-method-values. Looking them
+     * up must not scan and retain every unrelated lifted function. */
+    readonly classMethodValueHelpers: Set<string>;
+    readonly classMethodValueSelections: Map<string, import("./class-method-values.js").ClassMethodValueSelection>;
     /** Callee names of every interned coercion helper whose CALL mints a
      * FRESH closure per evaluation (%fn.width.*, %fn.adapt.*,
      * %fnval.spawnres.*). Registered at the mint site — NOT recovered by
@@ -689,12 +703,21 @@ export declare class Lowerer {
     /** Keyed by program-wide qualified class name (what IR object types carry). */
     readonly classes: Map<string, ClassInfo>;
     readonly classBySymbol: Map<ts.Symbol, ClassInfo>;
+    /** Named method slots observed before class collection need a callable
+     * ABI and shared prototype descriptors instead of call-site specialization. */
+    readonly prototypeMethodAccesses: Map<string, import("../ts7/ast-node.js").AstNode>;
     /** Inferred JS methods participating in an override chain keep a vtable
      * ABI instead of call-site specialization. Filled before class collection. */
     readonly virtualJsMethods: Set<ts.MethodDeclaration>;
+    /** Descendant writes must widen the original JS field before collecting
+     * any class layout; base and derived instances share its storage ABI. */
+    readonly inheritedJsFieldWrites: Map<ts.ClassDeclaration | ts.ClassExpression, Map<string, ts.ExpressionBase[]>>;
     /** Largest fixed argument list below a JS method, discovered before any
      * base vtable signature is collected. Unused checked slots carry undefined. */
     readonly virtualJsMethodArity: Map<ts.MethodDeclaration, number>;
+    readonly checkedVirtualJsMethods: Set<ts.MethodDeclaration>;
+    readonly checkedVirtualJsAccessors: Set<ts.GetAccessorDeclaration | ts.SetAccessorDeclaration>;
+    readonly checkedVirtualJsValueReturns: Set<ts.MethodDeclaration>;
     /** The class whose members are lowering — `super` binds lexically to it
      * (arrows inside methods lower within this window, so they see it too). */
     currentClass: ClassInfo | null;
@@ -836,12 +859,16 @@ export declare class Lowerer {
      * a reference to a lowerable body reports its name here — recorded even
      * when the enclosing statement later poisons. */
     onEdge: ((name: string) => void) | null;
+    deferredModuleInitializers: DeferredModuleInitializers | null;
     fnStack: FnCtx[];
     readonly liftedFns: IrFunction[];
     /** One Error-method helper belongs to this lowering session. Its cached
      * dispatch revision needs no weak-key identity or process-global state. */
     errorMethodDispatchRevision: string | null;
+    errorPropertyDispatchRevision: string | null;
     lambdaCounter: number;
+    readonly preparedClassFactories: Map<ts.ArrowFunction | ts.FunctionExpression, IrExpr>;
+    readonly preparingClassFactories: Set<ts.ArrowFunction | ts.FunctionExpression>;
     /** Statement lists currently mid-lowering, innermost last: the forward-
      * capture machinery needs to know which later statements of an OPEN list
      * a symbol's declaration sits in, which scope frame list-level declarations
@@ -868,6 +895,12 @@ export declare class Lowerer {
      * is assembled directly. The configured reachable set remains null so
      * demand-driven instance lowering keeps its existing gates. */
     reachableForArtifacts: ReadonlySet<string> | null;
+    /** Constructors retained by the active worklist. A boxed base receiver
+     * can contain any retained descendant, but importing its declaration
+     * alone does not make every descendant constructible. */
+    private constructedClasses;
+    private readonly virtualEdges;
+    classCanBeConstructed(info: ClassInfo): boolean;
     /** Coverage remainder mode: the reachability gate inverts (see wantBody)
      * and no module is built. */
     readonly remainder: boolean;
@@ -1278,6 +1311,11 @@ export declare class Lowerer {
      * this is THE tag for that (union, arm) pair program-wide — every wrap,
      * narrow, and tag test agrees by construction. */
     armTag(unionId: string, arm: IrType): number;
+    /** Literal ownership depends only on the union contract and record layouts.
+     * Recheck it when recursive placeholders close, not for every literal. */
+    literalUnionArm(unionId: string, values: readonly UnionLiteral[]): (IrType & {
+        kind: "record";
+    }) | null;
     /** Implicit union construction. Wherever a value flows into a typed slot
      * (initializer, assignment, call argument, return, field write, record
      * literal field, ternary arm) whose expected type is a union and the
@@ -1831,6 +1869,11 @@ export declare class Lowerer {
      * BEFORE that statement (JS's order for the supported whole-initializer
      * positions). */
     readonly pendingClassExprInits: IrStmt[];
+    readonly computedClassBases: Map<string, {
+        value: IrExpr;
+        classInfo: ClassInfo;
+    }>;
+    readonly computedCallableBases: Map<ts.ClassLikeDeclaration, IrExpr>;
     /** Discovery hook: registers a just-collected expression class's member
      * bodies as worklist units (the units map is otherwise built before
      * lowering starts). Null in the emit pass. */
@@ -2219,7 +2262,7 @@ export declare class Lowerer {
     lowerDcChannelProperty(access: ts.PropertyAccessExpression): IrExpr | null;
     lowerDcTracingChannelMethodCall(call: ts.CallExpression, access: ts.PropertyAccessExpression): IrExpr | null;
     lowerDcTracingChannelProperty(access: ts.PropertyAccessExpression): IrExpr | null;
-    strdecHelper(op: "write" | "end", shapeId: string, loc: SrcLoc): string;
+    strdecHelper(op: "write" | "end" | "endChunk" | "endString" | "writeString", shapeId: string, loc: SrcLoc): string;
     lowerProcessProperty(expr: ts.PropertyAccessExpression): IrExpr | null;
     lowerFsConstantsProperty(expr: ts.PropertyAccessExpression): IrExpr | null;
     lowerBuiltinConstantsProperty(expr: ts.PropertyAccessExpression): IrExpr | null;