@scriptc/compiler 0.4.4 → 0.4.5

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

@@ -35,7 +35,7 @@ import { type CompoundOp, type StdlibFnEntry, type BuiltinModuleFn } from "./sur
 import { type BuiltinClassRef } from "./builtins/class-values.js";
 import { type FileParts } from "./lower-modules.js";
 import { type SplitRequireBinding } from "./cjs-inline-require.js";
-import { type ClassInfo, type ClassIteratorInfo, type GenericClassInfo, findStaticOn } from "./lower-classes.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";
@@ -644,6 +644,9 @@ export declare class Lowerer {
      * 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. */
@@ -652,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. */
@@ -757,6 +763,9 @@ 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
@@ -916,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
@@ -1071,6 +1083,15 @@ export declare class Lowerer {
         localId: string;
         type: IrType;
     } | null>;
+    /** 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>;
@@ -1203,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. */
@@ -1453,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. */
@@ -1470,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;
@@ -1731,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
@@ -1743,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;
@@ -1950,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
@@ -2281,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;
@@ -2403,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;
@@ -2488,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;