@scriptc/compiler 0.4.2 → 0.4.3

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

@@ -364,6 +364,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 +476,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>;
@@ -652,6 +658,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
@@ -928,10 +945,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. */
@@ -1139,6 +1169,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 +1187,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 +1272,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 +1405,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 +1630,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 +1949,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 +2005,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 +2155,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: {