@scriptc/compiler 0.4.3 → 0.4.5

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

@@ -15,6 +15,7 @@ import { type ContractAnnotations } from "../contract-types.js";
 import type { WidthLift } from "./width-lift.js";
 import { type FnCtx } from "./function-context.js";
 import type { FrontendServices } from "../services.js";
+import type { FsPathPlan } from "./builtins/fs-paths.js";
 import { type ProtocolDispatch } from "./class-protocol-dispatch.js";
 import { type DynamicFunction } from "../../ir/tiers.js";
 import { type TierMode, type TierReport } from "../tier-analysis.js";
@@ -33,7 +34,8 @@ import { ShapeRegistry, type TypeMapperCtx, UnionRegistry } from "../type-mapper
 import { type CompoundOp, type StdlibFnEntry, type BuiltinModuleFn } from "./surfaces.js";
 import { type BuiltinClassRef } from "./builtins/class-values.js";
 import { type FileParts } from "./lower-modules.js";
-import { type ClassInfo, type ClassIteratorInfo, type GenericClassInfo, findStaticOn } from "./lower-classes.js";
+import { type SplitRequireBinding } from "./cjs-inline-require.js";
+import { type ClassInfo, type ClassIteratorInfo, type ClassIteratorOptions, type GenericClassInfo, findStaticOn } from "./lower-classes.js";
 import { type MixinFnShape } from "./lower-mixins.js";
 import { type ParamShape, type FnSig } from "./call-signatures.js";
 import { type GenericFnInfo, type GenericInstance } from "./generic-functions.js";
@@ -576,6 +578,14 @@ export declare class Lowerer {
     /** Per CommonJS file using top-level `this`: the global holding the
      * object that stands for its original exports (lowerCjsTopLevelThis). */
     readonly cjsExportsThis: Map<ts.SourceFile, IrGlobal>;
+    /** `var m; m = require("./x")` alias bindings (cjs-inline-require.ts).
+     * Null entries cache declarations that keep ordinary storage. */
+    readonly cjsSplitRequireBindings: Map<ts.VariableDeclaration, SplitRequireBinding | null>;
+    /** Per-module whole-export symbol (cjs-inline-require.ts). Null means the
+     * module's exports are a table. */
+    readonly cjsWholeExportSymbols: Map<ts.SourceFile, ts.Symbol | null>;
+    /** Per-module live member-export classification (cjs-inline-require.ts). */
+    readonly cjsLiveMemberExports: Map<ts.SourceFile, boolean>;
     /** Inline program-module require calls whose %init the enclosing member
      * read or member call is already sequencing (cjs-inline-require.ts). */
     readonly inlineRequireInitDone: Set<ts.CallExpression>;
@@ -630,6 +640,13 @@ export declare class Lowerer {
     readonly runtimeOptionalFields: Set<string>;
     /** Bindings initialized by a Date's `toJSON()` (analyzeDateJsonResults). */
     readonly dateJsonBindings: Set<ts.Symbol>;
+    /** isTimeValueDateDeclaration's answers, and the locals that hold a
+     * Date's time value instead of a Date object (date-values.ts). */
+    readonly timeValueDateDecisions: Map<import("../ts7/ast-node.js").AstNode, boolean>;
+    readonly timeValueDateLocals: Set<IrLocal>;
+    /** Declarations of those locals that a setter call writes
+     * (date-values.ts). */
+    readonly timeValueDateWrites: Set<ts.VariableDeclaration>;
     /** Record bindings whose flow class reaches storage outside the class:
      * they keep the declared layout, so an initializer from unchecked reads
      * converts once instead of the binding adopting the widened variant. */
@@ -638,6 +655,9 @@ export declare class Lowerer {
      * every name destructured from a present source optional. */
     readonly runtimeOptionalPatternTypes: Map<import("../ts7/ast-node.js").AstNode, IrType>;
     readonly runtimeOptionalReduceTypes: Map<ts.CallExpression, IrType>;
+    /** Each function declaration's `arguments.length` count slot, or null
+     * (argument-counts.ts argumentCountSlot). */
+    readonly argumentCountSlots: Map<ts.FunctionDeclaration, string | null>;
     /** Non-null assertions whose value is forwarded into a slot promoted to
      * hold undefined. `x!` has no runtime effect, so these keep the stored
      * undefined state instead of trapping before any dereference. */
@@ -743,6 +763,11 @@ export declare class Lowerer {
     /** Parameters read as `any` in the error-path copy of an error-first
      * callback. */
     readonly anySymbols: Set<ts.Symbol>;
+    /** The collection types that uses prove for untyped JavaScript bindings,
+     * by every identifier naming one (js-collection-types.ts). */
+    inferredCollectionTypes: Map<ts.Node, ts.Type> | undefined;
+    /** overload-choice's answers per call, binding and function. */
+    readonly dynamicOverloadAnswers: Map<import("../ts7/ast-node.js").AstNode, boolean>;
     /** Error parameters of an error-first callback with a known value in
      * the copy being lowered: true while it holds an Error, false while it
      * holds null (staticCondition folds conditions on them). */
@@ -817,6 +842,9 @@ export declare class Lowerer {
     /** util.inspect's per-type traversal helpers (%util.insp.N), interned
      * by typeKey — the assertHelpers pattern with its own namespace. */
     readonly inspectHelpers: Map<string, string>;
+    /** Indexed-union safe-read helpers mapped to their numeric twins, for the
+     * fusion of an immediate ToNumber (tryLowerNumericIndexRead). */
+    readonly indexedUnionNumericTwins: Map<string, string>;
     private readonly unionLiteralOwners;
     private readonly strippedUndefinedArms;
     private readonly addedUndefinedArms;
@@ -851,6 +879,10 @@ export declare class Lowerer {
      * checks resolve through this map (stdlibGlobalNameOf), declarations
      * emit nothing. */
     readonly stdlibGlobalAliases: Map<ts.Symbol, string>;
+    /** The stdlibGlobalAliases bound through a cast of the global object
+     * (`(globalThis as { Buffer?: B }).Buffer`). Their static type is the
+     * cast's, so their value reads are refused (identifiers.ts). */
+    readonly castGlobalAliases: Set<ts.Symbol>;
     /** CJS export-table ACCESSORS (`module.exports = { get path() {...} }`),
      * lifted lazily as module-level functions and interned per accessor
      * declaration: member reads call the getter (lower-exprs). */
@@ -893,6 +925,9 @@ export declare class Lowerer {
     readonly builtinCallableValueFns: Map<string, string>;
     /** Each builtin function-value adapter's Node name, for boxed values. */
     readonly builtinCallableValueNames: Map<string, string>;
+    /** Builtin function values whose `length` differs from their adapter's
+     * parameter count (BuiltinModuleFn.valueLength), by adapter name. */
+    readonly builtinCallableValueLengths: Map<string, number>;
     /** Optional-chain lowering state. While a chain body lowers, the guarded
      * receiver NODE reads as a chainRecv (typed by the narrowed arm) instead
      * of re-lowering, its checker type reads non-nullish (typeOf), and the
@@ -1048,8 +1083,22 @@ export declare class Lowerer {
         localId: string;
         type: IrType;
     } | null>;
-    /** The staged arguments that follow each such URL path, in order. */
-    readonly stagedAfterPath: Map<ts.ExpressionBase, ts.ExpressionBase[]>;
+    /** Closure arguments an implicit-any call already lowered to learn their
+     * type (storedImplicitArgumentType), by node: the argument's own lowering
+     * in the same function and with the same type bindings takes that value
+     * once instead of lowering the closure again. */
+    readonly speculatedClosures: Map<ts.ExpressionBase, {
+        ctx: FnCtx;
+        bindings: Map<ts.Symbol, IrType> | null;
+        value: IrExpr;
+    }>;
+    /** What each fs path argument of a URL-path call lowers to (the plans
+     * of builtins/fs-paths.ts). */
+    readonly fsPathPlans: Map<ts.ExpressionBase, FsPathPlan>;
+    /** The existsSync/fs.promises calls whose converted URL paths are being
+     * lowered into the call itself (lowerFallibleFsUrlCall). A call may be
+     * lowered more than once, and each lowering converts again. */
+    readonly fallibleFsCalls: Set<ts.CallExpression>;
     readonly moduleNsParamOverrides: Map<ts.ParameterDeclaration, {
         kind: "moduleNs";
         moduleId: string;
@@ -1175,6 +1224,9 @@ export declare class Lowerer {
     readonly recordFieldDeletes: Set<string>;
     /** typeKeys of the array types the program may freeze (IrModule.freezableArrays). */
     readonly freezableArrays: Set<string>;
+    /** Whether the program freezes, seals or prevents extensions of untyped
+     * values other than fresh literals (noteUntypedIntegrity). */
+    untypedIntegrity: boolean;
     readonly liftedFns: IrFunction[];
     /** The first lifted function of each name (liftedFnNamed), for the
      * liftedFns indexed so far. liftedFns only grows. */
@@ -1425,7 +1477,8 @@ export declare class Lowerer {
     /** Declared class fields may store a DYN value only when its static type
      * is `unknown` or `object` (also with `null` or `undefined`, or an array
      * of those), names checked protocol identity, is an owned runtime
-     * handle (a Worker or MessagePort, a fetch Headers/Request/Response, or
+     * handle (a Worker or MessagePort, a fetch Headers/Request/Response or
+     * AbortController/AbortSignal, or
      * a node:crypto ECDH, DiffieHellman or DiffieHellmanGroup), or is a
      * WeakMap/WeakSet (native weak collections live in checked-dynamic
      * storage, as locals of those types do); `any` fields stay refused. */
@@ -1442,6 +1495,16 @@ export declare class Lowerer {
      * modules use their normalized absolute source name; supported builtins
      * use the lowering tables' canonical bare name. */
     moduleNamespaceIdOfType(type: ts.Type): string | null;
+    /** For each CommonJS module read through a JavaScript namespace import:
+     * the property names of Node's namespace object
+     * (cjsNamespaceExportNames), and the exports the module assigns inside
+     * functions, which the namespace does not see
+     * (cjsExportsAssignedInFunctions). */
+    private readonly cjsNamespaces;
+    cjsNamespaceOf(dep: ts.SourceFile): {
+        names: ReadonlySet<string>;
+        assignedLater: ReadonlySet<string> | "all";
+    };
     sourceFileOfModuleNamespace(type: IrType): ts.SourceFile | null;
     builtinErrorInfoOf(symbol: ts.Symbol | null | undefined): ClassInfo | null;
     builtinEmitterInfoOf(symbol: ts.Symbol | null | undefined): ClassInfo | null;
@@ -1703,7 +1766,7 @@ export declare class Lowerer {
      * the instantiation context is appended so the user knows which concrete
      * types made the (source-anchored) construct fail. */
     pushDiag(diag: ScrDiagnostic): void;
-    unsupported(code: keyof typeof UNSUPPORTED & `SC${number}`, node: ts.Node, featureOverride?: string, hintOverride?: string): never;
+    unsupported(code: keyof typeof UNSUPPORTED & `SC${number}`, node: ts.Node, featureOverride?: string, hintOverride?: string, reason?: string): never;
     externalHostFence(specifier: string, node: ts.Node, valueUse?: boolean): never;
     anyOpFence(feature: string, node: ts.Node): never;
     /** True when this expression's CHECKER type is `any`-flavored — the
@@ -1715,7 +1778,7 @@ export declare class Lowerer {
      * nothing lowers. Poisons the statement like every other rejection.
      * `sym`, when given, picks the wording: surface declared only by the
      * adopted @types/node is blamed at @types/node. */
-    noLowering(surface: string, node: ts.Node, hint?: string, sym?: ts.Symbol | null): never;
+    noLowering(surface: string, node: ts.Node, hint?: string, sym?: ts.Symbol | null, reason?: string): never;
     stdlibMemberFence(access: ts.PropertyAccessExpression): void;
     fenceStaticResponseMember(access: ts.PropertyAccessExpression | ts.ElementAccessExpression, use: "read" | "call"): IrExpr | null;
     fenceUnsupportedFetchConstructorMember(access: ts.PropertyAccessExpression | ts.ElementAccessExpression): IrExpr | null;
@@ -1922,7 +1985,7 @@ export declare class Lowerer {
         kind: "record";
     }, toId: string, loc: SrcLoc): string | null;
     unionRetagHelper(fromId: string, toId: string, loc: SrcLoc, trappable?: ReadonlySet<number>): string | null;
-    narrowedArmHelper(fromId: string, target: IrType, loc: SrcLoc): string | null;
+    narrowedArmHelper(fromId: string, target: IrType, loc: SrcLoc, message?: string): string | null;
     checkedNarrowCall(helper: string, value: IrExpr, type: IrType, loc: SrcLoc): IrExpr;
     deferredReadHelper(fromId: string, target: IrType, loc: SrcLoc): string | null;
     /** THE coercion path for values flowing into a typed slot: union arms
@@ -2253,11 +2316,13 @@ export declare class Lowerer {
     lowerStaticFieldInits(info: ClassInfo): IrStmt[];
     /** Method-like members with their collected method-map names. Body
      * lowering omits abstract declarations; ABI analysis must include them
-     * because an abstract-typed call selects the same virtual slot. */
-    classMethodMembers(info: ClassInfo, includeAbstract?: boolean): Generator<{
+     * because an abstract-typed call selects the same virtual slot. An array,
+     * not a generator: a generator's yielded values are dynamic values, which
+     * would make every syntax node one. */
+    classMethodMembers(info: ClassInfo, includeAbstract?: boolean): {
         mName: string;
         member: ts.MethodDeclaration | ts.AccessorDeclaration;
-    }>;
+    }[];
     lowerClassCtor(info: ClassInfo): IrFunction;
     lowerClassMethodMember(info: ClassInfo, fnLike: ts.MethodDeclaration | ts.AccessorDeclaration): IrFunction | null;
     throwingSetterFn(info: ClassInfo, prop: string): IrFunction;
@@ -2375,6 +2440,9 @@ export declare class Lowerer {
     requireTruthyUnion(unionId: string, node: ts.Expression): void;
     eqComparableUnion(unionId: string): boolean;
     lowerExpr(expr: ts.Expression): IrExpr;
+    /** The value storedImplicitArgumentType lowered for `expr` in the active
+     * function and type bindings (speculatedClosures), or null. */
+    speculatedClosure(expr: ts.Expression): IrExpr | null;
     /** The saved value of a staged fs argument (stagedArguments, keyed
      * without type-only wrappers), or null for every other expression. */
     private stagedArgument;
@@ -2460,9 +2528,11 @@ export declare class Lowerer {
     } | null;
     foldedStringKeyOf(expr: ts.Expression): string | null;
     accessorCall(className: string, member: string, obj: IrExpr, extraArgs: IrExpr[], ret: IrType, loc: SrcLoc): IrExpr;
-    classIteratorOf(t: IrType): ClassIteratorInfo | null;
+    classIteratorOf(t: IrType, options?: ClassIteratorOptions): ClassIteratorInfo | null;
+    classIteratorReturnCall(cit: ClassIteratorInfo, it: IrExpr, loc: SrcLoc): IrExpr;
     classIteratorOpenCall(cit: ClassIteratorInfo, recv: IrExpr, loc: SrcLoc): IrExpr;
-    classIteratorNextCall(cit: ClassIteratorInfo, itRef: IrExpr, loc: SrcLoc): IrExpr;
+    classIteratorNextRead(cit: ClassIteratorInfo, itRef: IrExpr, loc: SrcLoc): IrExpr | null;
+    classIteratorNextCall(cit: ClassIteratorInfo, itRef: IrExpr, next: IrExpr | null, loc: SrcLoc): IrExpr;
     classIteratorDrainCall(src: IrExpr, loc: SrcLoc, elemT?: IrType): IrExpr | null;
     classIteratorRestDrainCall(cit: ClassIteratorInfo, itVal: IrExpr, loc: SrcLoc): IrExpr;
     fieldGetExpr(target: FieldTarget, loc: SrcLoc, blame: ts.Node): IrExpr;