@scriptc/compiler 0.4.2 → 0.4.4

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,6 +34,7 @@ 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 SplitRequireBinding } from "./cjs-inline-require.js";
 import { type ClassInfo, type ClassIteratorInfo, type GenericClassInfo, findStaticOn } from "./lower-classes.js";
 import { type MixinFnShape } from "./lower-mixins.js";
 import { type ParamShape, type FnSig } from "./call-signatures.js";
@@ -364,6 +366,9 @@ export declare class Lowerer {
     /** Identifiers by spelling, per file, for the generic bindings' use
      * ordering (runsAfterDeclaration). */
     readonly bindingIdentifiers: Map<ts.SourceFile, Map<string, ts.Identifier[]>>;
+    /** Per JavaScript file, the declarations of the bindings it assigns an
+     * own `toString` (jsAssignsOwnToString in lower-calls.ts). */
+    readonly ownToStringTargets: Map<ts.SourceFile, Set<import("../ts7/ast-node.js").AstNode>>;
     /** Per-symbol result of the never-reassigned file scan
      * (bindingNeverReassigned — object-literal generic-method receivers). */
     readonly neverReassignedCache: Map<ts.Symbol, boolean>;
@@ -473,6 +478,9 @@ export declare class Lowerer {
         owner: ts.FunctionLikeDeclaration;
         name: string;
     }[];
+    /** The function-local classes of the program with an `extends` clause, whether lowering collected
+     * them yet or not (new-target.ts); found on first use. */
+    functionLocalSubclasses: ts.ClassLikeDeclaration[] | undefined;
     /** Instance types (by checker type id) of the local classes generic
      * factory calls return, and the per-instance class each names. */
     readonly localClassInstanceTypes: Map<number, string>;
@@ -570,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>;
@@ -624,6 +640,10 @@ 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>;
     /** 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 +672,17 @@ export declare class Lowerer {
     runtimeOptionalRootOf(local: IrLocal): IrLocal;
     runtimeOptionalBindingType(node: ts.Node): IrType | null;
     runtimeOptionalBindingType(node: ts.Node, fallback: IrType): IrType;
+    /** A fresh TypeScript data literal (`{ message: "m" }`) passed to a
+     * checked-dynamic parameter of a callee implemented in JavaScript, whose
+     * contract lets it reshape the object: a call through an untyped value, an
+     * untyped parameter of a JavaScript function, or a package-declared
+     * parameter type (a non-library `.d.ts`) that makes one of the literal's
+     * properties optional (zod's `normalizeParams` deletes `params.message`).
+     * No typed alias of a fresh literal exists, so it is built as the plain
+     * object the callee receives instead of a view whose record layout refuses
+     * that delete. Standard-library and TypeScript callees, and literals with
+     * methods or accessors, keep their native storage. */
+    private reshapeableContextualLiteral;
     /** A TypeScript object literal handed to a JavaScript checked-value
      * parameter whose inferred type is open (`constructor({ factory, ...options
      * } = {})` — the rest element admits any property): the literal names a
@@ -726,6 +757,8 @@ export declare class Lowerer {
     /** Parameters read as `any` in the error-path copy of an error-first
      * callback. */
     readonly anySymbols: Set<ts.Symbol>;
+    /** 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). */
@@ -800,6 +833,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;
@@ -834,6 +870,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). */
@@ -928,10 +968,23 @@ 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>;
+    /** Every site the census found for a name in prototypeMethodAccesses (which
+     * keeps one): reads of the method and writes that may replace it. The
+     * key-order witness asks which replacements can return records. */
+    readonly methodAccessSites: Map<string, import("../ts7/ast-node.js").AstNode[]>;
+    /** Marks `name` as a method the program may read or replace at `site`. */
+    noteMethodAccess(name: string, site: ts.Node): void;
+    /** Records a site for `name` without changing its prototypeMethodAccesses entry. */
+    noteMethodSite(name: string, site: ts.Node): void;
     /** Whether the program reads `Error.prototype`, the checked-dynamic
-     * object an ES5 constructor function can inherit from: only then can a
-     * value that is not an Error instance be `instanceof Error`. */
+     * object an ES5 constructor function can inherit from, or has a class
+     * whose heritage is evaluated at run time (`extends (Base ?? Error)`):
+     * only then can a value that is not an Error instance be
+     * `instanceof Error`. */
     errorPrototypeValues: boolean;
+    /** The property names the program assigns on the global object
+     * (property-access.ts), collected on first use. */
+    globalThisWrittenNames: Set<string> | null;
     /** Well-known symbol methods (`sym:iterator`) the program may replace
      * through a symbol-keyed write: an instance or prototype property, or a
      * reflection call. */
@@ -1018,8 +1071,13 @@ 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[]>;
+    /** 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;
@@ -1139,6 +1197,12 @@ export declare class Lowerer {
     onEdge: ((name: string) => void) | null;
     deferredModuleInitializers: DeferredModuleInitializers | null;
     fnStack: FnCtx[];
+    /** Source ranges of record writes in sloppy-mode code, and of the
+     * absent-state writes of `delete r.f` (markSloppyRecordWrites). */
+    readonly sloppyRecordWrites: Set<string>;
+    readonly recordFieldDeletes: Set<string>;
+    /** typeKeys of the array types the program may freeze (IrModule.freezableArrays). */
+    readonly freezableArrays: Set<string>;
     readonly liftedFns: IrFunction[];
     /** The first lifted function of each name (liftedFnNamed), for the
      * liftedFns indexed so far. liftedFns only grows. */
@@ -1151,12 +1215,18 @@ export declare class Lowerer {
      * dispatch revision needs no weak-key identity or process-global state. */
     errorMethodDispatchRevision: string | null;
     errorPropertyDispatchRevision: string | null;
+    /** The program defines properties by reflection on an untyped or
+     * Error-shaped target, so an own accessor may replace an error's `name`
+     * or `message`: typed reads and writes of those slots check for one.
+     * Holds the first such call's location. */
+    errorAccessorReflection: SrcLoc | null;
     /** Structural source positions (structural-positions.ts) for names that
      * stay the same when unrelated code moves. */
     /** Files are named by their path relative to the entry's directory, so
-     * names do not depend on where the program sits, and default library
-     * files by their base name: two checkers install them in different
-     * directories. */
+     * names do not depend on where the program sits, default library files
+     * by their base name (two checkers install them in different
+     * directories), and the files scriptc ships by their name inside scriptc,
+     * so names do not depend on where scriptc is installed either. */
     readonly positions: StructuralPositions;
     /** The outermost node whose token span is exactly `loc`, or null. */
     nodeAtLoc(loc: SrcLoc): ts.Node | null;
@@ -1230,6 +1300,9 @@ export declare class Lowerer {
      * the class and constructed-class counts, it tells caches over the class
      * graph when the graph changed. */
     subclassLinks: number;
+    /** Function-local classes by the class node they extend, built on first
+     * use (localSubclassesOf in lower-classes.ts). */
+    localSubclassIndex: Map<ts.Node, ts.ClassLikeDeclaration[]> | null;
     /** Set while a subclass constructor's super() call notes its base
      * constructor edge: that edge does not instantiate the base exactly. */
     private superConstructorEdge;
@@ -1360,6 +1433,15 @@ export declare class Lowerer {
      * active and this is the emit/discovery lane — mirror the CALLER's
      * suppressStats guard, this method only gates remainder). */
     bumpFileStat(file: string, kind: "total" | "failed"): void;
+    /** The program holds the declaration-typed boundary's projection
+     * (decl-projection.ts): user-file record and array values crossing into
+     * dynamic slots (package parameters) box as live capsules, so a value
+     * that comes back through a boundary cast keeps its identity. */
+    private declBoundaryMemo;
+    get declBoundary(): boolean;
+    /** Tracked classes' bag initializers over a typed `this`
+     * (class-dynamic-dispatch.ts recordBagInitializers). */
+    readonly classBagInitializers: Map<string, IrExpr>;
     constructor(program: ts.Program, entry: ts.SourceFile, moduleOrder: ts.SourceFile[], mode?: LowererMode);
     /** A JavaScript file TypeScript type-checks (`// @ts-check`, or the
      * project's `checkJs`). Its JSDoc types are enforced like TypeScript
@@ -1576,6 +1658,12 @@ export declare class Lowerer {
      * every statement the body holds as attempted and failed, in addition to
      * the skipped-function tally. */
     private countSkippedBody;
+    /** Coverage remainder: the body diagnostics of a function whose
+     * signature blocked (blockedBodyDiagnostics). A function reachable emit
+     * reached (its signature's diagnostics flushed there) reports them with
+     * the reached diagnostics; any other reports them as unreached. */
+    readonly reachedBlockedBodyDiagnostics: ScrDiagnostic[];
+    private reportBlockedBody;
     /** Whether run() counts a signature-blocked declaration in
      * stats.functionsSkipped: whole-program passes and the coverage
      * remainder do; an externally-gated emit pass leaves the counting to the
@@ -1889,6 +1977,11 @@ export declare class Lowerer {
      * its referent. Apply the ordinary checked narrowing to absent arms from
      * runtime-optional reads; only present reference arms participate here. */
     lowerCollectionKey(node: ts.Expression, expected: IrType): IrExpr;
+    /** The right side of a write to a member of a typed view of the global
+     * object (`(globalThis as typeof globalThis & { k?: T }).k = value`, also
+     * through `??=` and `||=`) that is `value` itself or wraps only it in
+     * parentheses or `satisfies`; null when `value` is not in such a write. */
+    private globalViewSlot;
     /** Lower for a known destination, then apply ordinary value coercion.
      * Fresh arrays and records use the destination layout directly. */
     lowerExprExpecting(node: ts.Expression, expected: IrType | undefined): IrExpr;
@@ -1940,6 +2033,12 @@ export declare class Lowerer {
      * undefined, which the void slot drops. Units are pure literals, so
      * nothing evaluates; unit-typed non-literals keep the fences. */
     lowerReturnValue(node: ts.Expression): IrExpr | null;
+    /** An array literal or a `new Map(...)`, `new Set(...)` or `new
+     * Array(...)` of the builtins: a fresh collection, never a thenable, so
+     * an async return takes the declared result type as its construction
+     * layout the way a synchronous return does (`return []` in a function
+     * whose inferred result is `Promise<string[]>`). */
+    private returnsFreshCollection;
     /** A fresh JS object literal returned into a checked-native (dyn) result,
      * which lowers straight into that storage. */
     private returnsLiteralIntoDyn;
@@ -2084,7 +2183,7 @@ export declare class Lowerer {
      * an analysis already caught the poison) and the class is unmappable for
      * the query instead of the poison escaping the compiler. */
     collectLocalClassForType(decl: ts.ClassLikeDeclaration): boolean;
-    lowerClassExpression(expr: ts.ClassLikeDeclaration): IrExpr;
+    lowerClassExpression(expr: ts.ClassLikeDeclaration, binding?: IrLocal): IrExpr;
     findMethodOn(info: ClassInfo | null, name: string): {
         declarer: ClassInfo;
         sig: {