@scriptc/compiler 0.0.36 → 0.1.1

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

@@ -504,10 +504,69 @@ export declare class Lowerer {
     /** All storage slots widened for runtime absence, including slots whose
      * current control-flow branch has temporarily narrowed the value. */
     readonly runtimeOptionalStorageLocals: Set<IrLocal>;
+    /** Globals whose checker-bare type was widened because an indexed read can
+     * carry undefined at runtime. Identifier reads keep the union tag so
+     * typeof and later boundaries observe the real value. */
+    readonly runtimeOptionalGlobals: Set<IrGlobal>;
+    /** Bindings whose unchecked string arithmetic can produce either a number
+     * (NaN for an absent read) or a string. Preserve that result union at bare
+     * reads instead of applying the checker-bare string narrowing adapter. */
+    readonly runtimeOptionalArithmeticLocals: Set<IrLocal>;
+    readonly runtimeOptionalArithmeticGlobals: Set<IrGlobal>;
+    /** Binding symbols whose IR storage type was widened by the indexed-read
+     * prepass. This includes explicit annotations: unchecked TS annotations do
+     * not prove that an array property read produced a value. */
+    readonly runtimeOptionalBindingTypes: Map<ts.Symbol, IrType>;
+    /** Concise callback/lambda returns promoted by the HOF callback prepass;
+     * arrows have no declaration symbol to key in fnSigsBySymbol. */
+    readonly runtimeOptionalFunctionReturns: WeakMap<ts.Node, IrType>;
+    /** Arithmetic over an unchecked string read can answer either NaN or a
+     * string. Bindings and returns use this marker to retain that result union
+     * through checker-bare string annotations. */
+    readonly runtimeOptionalArithmeticTypes: WeakMap<ts.Node, IrType>;
+    /** Record fields promoted to an undefined-armed union by an indexed-read
+     * value. The key is the concrete emitted shape and field name. */
+    readonly runtimeOptionalFields: Set<string>;
+    /** Callback pattern parameters carry an optional source without making
+     * every name destructured from a present source optional. */
+    readonly runtimeOptionalPatternTypes: WeakMap<ts.Node, IrType>;
+    readonly runtimeOptionalReduceTypes: WeakMap<ts.CallExpression, IrType>;
     /** Capture entries and their origin share one mutable box. Normalize each
      * entry to the origin so writes and flow proofs stay synchronized. */
     readonly runtimeOptionalRoots: Map<IrLocal, IrLocal>;
     runtimeOptionalRootOf(local: IrLocal): IrLocal;
+    runtimeOptionalBindingType(node: ts.Node): IrType | null;
+    runtimeOptionalBindingType(node: ts.Node, fallback: IrType): IrType;
+    runtimeOptionalIdentifierValue(node: ts.Expression): {
+        value: IrExpr;
+        present: IrType;
+        unionId: string;
+    } | 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
+     * checked-narrow behavior. */
+    runtimeOptionalSourceValue(node: ts.Expression, value: IrExpr): IrExpr | null;
+    /** A strict property or method receiver over an array-derived optional
+     * value. Stabilize the receiver once, throw Node's member-read TypeError
+     * for a unit arm, and extract the expected present arm otherwise. */
+    runtimeOptionalPropertyReceiver(node: ts.Expression, value: IrExpr, expected: IrType, member: string): IrExpr | null;
+    runtimeOptionalFieldKey(shapeId: string, field: string): string;
+    isRuntimeOptionalField(shapeId: string, field: string): boolean;
+    isRuntimeOptionalGlobal(global: IrGlobal): boolean;
+    isRuntimeOptionalArithmeticGlobal(global: IrGlobal): boolean;
+    /** The union produced when an unchecked array read reaches a typed slot
+     * whose checker type is the corresponding bare arm. */
+    runtimeOptionalWidening(actual: IrType, expected: IrType): IrType | null;
+    runtimeOptionalType(t: IrType): IrType;
+    promoteRuntimeOptionalParameter(node: ts.Node, type: IrType): IrType;
+    promoteRuntimeOptionalFunctionReturn(node: ts.Node, type: IrType): IrType;
+    runtimeOptionalFunctionReturnType(node: ts.Node, fallback: IrType): IrType;
+    /** Promote one field of a record storage shape to the value's runtime
+     * type. Shapes are immutable by identity, so this interns a sibling shape
+     * and records the field as runtime-optional for property-read narrowing. */
+    runtimeOptionalRecordField(type: IrType, field: string, fieldType: IrType): IrType;
     /** Runs `fn` with the given aliased-typeof narrows applied (and restored
      * after) — the branch-scoping primitive. */
     narrowingAliases<T>(narrows: readonly {
@@ -592,6 +651,10 @@ export declare class Lowerer {
         };
     }>;
     readonly narrowHelpers: Map<string, string>;
+    /** Exact members of narrowHelpers produced by narrowedArmHelper. This
+     * lets property consumers recognize an earlier checked extraction by
+     * provenance instead of relying on its generated-name prefix. */
+    private readonly checkedNarrowHelpers;
     /** Interned `%iter.drain.<n>` helpers (classIteratorDrainCall): one per
      * receiver class — the eager drain of a class iterable's protocol into
      * a fresh element array, behind array/call spreads. */
@@ -1006,6 +1069,12 @@ export declare class Lowerer {
     wantBody(name: string): boolean;
     collectNpmImports(parts: FileParts[]): void;
     collectJsonImports(parts: FileParts[]): void;
+    /** Discover the unchecked-array values that cross static ABI/storage
+     * boundaries before any function body or module initializer is emitted.
+     * TypeScript's default indexed-access type is a useful source annotation,
+     * but it is not a runtime proof; promoting only the affected slots keeps
+     * the rest of the dense ABI unchanged. */
+    analyzeRuntimeOptionalArrayReads(parts: FileParts[]): void;
     run(): LowerResult;
     /** Final retention, pruning, and module assembly shared by ordinary emit
      * and the retained reachability worklist. */
@@ -1142,9 +1211,10 @@ export declare class Lowerer {
      * isArrayValueType so Array.isArray's predicate and its narrowing bridge
      * cannot disagree about fixed tuple arms. */
     arrayValueTags(unionId: string): number[];
-    /** isJsonSafeType with this Lowerer's registries — the shared fence for
-     * what JSON.stringify accepts and what a checked cast can validate. */
+    /** Checked JSON conversion excludes undefined array slots because JSON
+     * text cannot preserve that distinction. */
     jsonSafe(t: IrType): boolean;
+    jsonStringifySafe(t: IrType): boolean;
     /** True when a type is a BARE undefined-armed union — the one JSON-unsafe
      * shape whose rejections deserve their own wording: Node's stringify of
      * bare undefined is not a string at all and JSON text never matches the
@@ -1981,6 +2051,8 @@ export declare class Lowerer {
     caughtLocalOf(node: ts.Expression): IrLocal | null;
     caughtToString(node: ts.Expression): IrExpr | null;
     lowerInstanceOf(expr: ts.BinaryExpression, loc: SrcLoc): IrExpr;
+    private withRuntimeOptionalClassValue;
+    private withExpressionOverride;
     lowerCall(expr: ts.CallExpression): IrExpr;
     isTopLevelFnSymbol(ident: ts.Identifier): boolean;
     lowerNestedFunctionDecl(stmt: ts.FunctionDeclaration): IrStmt;