@scriptc/compiler 0.2.6 → 0.2.7

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

@@ -1,3 +1,4 @@
+import { type CycleInitFlag } from "./cycle-initialization.js";
 import type { FieldLift } from "./coercions/structural-plans.js";
 import { CoercionState } from "./coercions/state.js";
 import { RuntimeOptionalLocals } from "./runtime-optional-locals.js";
@@ -537,6 +538,8 @@ export declare class Lowerer {
     /** True while re-lowering a base function's 2nd+ instance: the same source
      * statements were already counted for the first instance. */
     suppressStats: boolean;
+    /** Comparisons interned by operand representations and equality semantics. */
+    readonly equalityHelpers: Map<string, string>;
     /** Synthetic array-HOF loop functions (map/filter/forEach desugar),
      * interned per method + element/callback-result type: key → fn name. */
     readonly arrHofHelpers: Map<string, string>;
@@ -633,6 +636,10 @@ export declare class Lowerer {
      * node carrying the ?. token is marked handled so the receiver-typed
      * lowerings stop declining it (chainBlocked). */
     readonly chainRecvByNode: Map<import("../ts7/ast-node.js").AstNode, IrExpr>;
+    /** Lowered void calls whose checked type is `never` (they throw or exit).
+     * TypeScript lets such a call stand where any value is expected;
+     * coerceToExpected turns them into diverging sequences. */
+    readonly neverValued: Set<IrExpr>;
     readonly chainNarrowedType: Map<import("../ts7/ast-node.js").AstNode, ts.Type>;
     readonly chainHandled: Set<import("../ts7/ast-node.js").AstNode>;
     /** for-of-over-matchAll bindings whose `.index` reads the companion-index
@@ -676,6 +683,8 @@ export declare class Lowerer {
     /** 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>;
+    /** Field names whose complete source census stores only lexical arrows. */
+    readonly receiverFreeCallbackFields: Set<string>;
     /** 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>;
@@ -860,6 +869,10 @@ export declare class Lowerer {
      * function called above the declaration statement reads that, never a
      * NULL slot. Filled by collectGlobals. */
     readonly varGlobalEntryInits: Map<ts.SourceFile, IrGlobal[]>;
+    /** Import-cycle bindings with an initialization flag, by global id, and
+     * the top-level statements declaring them (cycle-initialization.ts). */
+    readonly cycleInitFlags: Map<string, CycleInitFlag>;
+    readonly cycleInitDeclarations: Map<ts.StatementBase, CycleInitFlag[]>;
     get ctx(): FnCtx;
     get scopes(): Map<ts.Symbol, IrLocal>[];
     /** Names of bodies a prior reachability pass reached; null lowers everything. */
@@ -1291,6 +1304,8 @@ export declare class Lowerer {
     literalUnionArm(unionId: string, values: readonly UnionLiteral[]): (IrType & {
         kind: "record";
     }) | null;
+    /** Widen only the result view; identical parameter ABIs preserve closure identity. */
+    coerceCovariantFunction(expr: IrExpr, expected: IrType): IrExpr | 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
@@ -1472,6 +1487,23 @@ export declare class Lowerer {
     paramShapes(params: readonly ts.ParameterDeclaration[]): ParamShape[];
     completeArgs(argNodes: readonly ts.Expression[], shapes: readonly ParamShape[], loc: SrcLoc, blame: ts.Node): IrExpr[];
     wrappedUndefined(type: IrType, loc: SrcLoc): IrExpr | null;
+    /** The value an OMITTED or deleted property leaves in a record field
+     * slot of `type`: the ABSENT state for undefined-armed unions (the slot
+     * reads as undefined but the property does not exist), the dyn
+     * undefined for 'unknown' slots, and null when the slot cannot be
+     * missing. Only legal as a direct field-slot write (IR fieldAbsent). */
+    absentFieldValue(type: IrType, loc: SrcLoc): IrExpr | null;
+    /** A field copy that keeps absence: `value` (the converted read of
+     * `field` from record `obj`, which must be repeatable) when the source
+     * property exists, else the target slot's ABSENT state. Fields that are
+     * always present, and targets that cannot be absent, copy `value`
+     * as-is. Only legal as a direct field-slot write. */
+    presenceKeepingCopy(obj: IrExpr, shapeId: string, field: string, value: IrExpr, loc: SrcLoc): IrExpr;
+    /** Own-property presence of declared field `field` on record `obj`
+     * (borrowed — callers pass a repeatable receiver): a runtime test for
+     * undefined-armed union fields, which can be absent, and `true` for
+     * every other declared field. */
+    recordFieldPresent(obj: IrExpr, shapeId: string, field: string, loc: SrcLoc): IrExpr;
     /** The entry value of a binding JS initializes to `undefined` (an
      * initializer-less declaration, a hoisted `var` before its statement):
      * undefined-armed unions hold the interned undefined arm, and 'any'
@@ -1645,6 +1677,11 @@ export declare class Lowerer {
     lowerDefaultExport(stmt: ts.ExportAssignment): IrStmt | null;
     buildMain(): IrFunction;
     declareLocal(nameNode: ts.Node, name: string, type: IrType, mutable: boolean): IrLocal;
+    /** A never-returning call in a value position of type `expected`: the
+     * call runs for its effects (it throws or exits), and the expression ends
+     * in an unreachable trap instead of producing a value. The result reads an
+     * uninitialized hidden local that control never reaches. */
+    divergentValue(call: IrExpr, expected: IrType): IrExpr;
     /** A function-scope local bound to NO ts.Symbol — the hidden ABI slot of a
      * defaulted parameter (the parameter's symbol binds to the separately-
      * declared body local; nothing in the source can name this one). */