@scriptc/compiler 0.0.35 → 0.0.36

package/dist/frontend/lowering/lower-stmts.d.ts

@@ -1,6 +1,6 @@
 import * as ts from "../ts7/adapter.js";
 import type { Lowerer } from "./lowerer.js";
-import { IrExpr, IrLocal, IrStmt, IrType, SrcLoc } from "../../ir/nodes.js";
+import { IrExpr, IrStmt, IrType, SrcLoc } from "../../ir/ir.js";
 /** --provenance-sources: true when `decl` is a declarator of a
  * pureAnnotatedDeadConst statement in a FETCHED SOURCE module whose
  * declared type has no static mapping — the declaration ELIDES: no
@@ -17,12 +17,12 @@ import { IrExpr, IrLocal, IrStmt, IrType, SrcLoc } from "../../ir/nodes.js";
  * collectGlobals and lowerVarDecl gate on this, BEFORE the mixin/alias
  * probes that would otherwise claim (and diagnose) the call-initializer
  * shape. */
-export declare function provenanceElidedConstDecl(L: Lowerer, decl: ts.VariableDeclaration): boolean;
+export declare function provenanceElidedConstDecl(lowerer: Lowerer, decl: ts.VariableDeclaration): boolean;
 /** Lowers statements, one poison catch per statement so one unsupported
    * construct doesn't hide the rest of the file's diagnostics. A single
    * source statement may expand to several IR statements (multi-declaration
    * `let a = 1, b = a + 1;`) but is counted once. */
-export declare function lowerStmts(L: Lowerer, stmts: readonly ts.Statement[]): IrStmt[];
+export declare function lowerStmts(lowerer: Lowerer, stmts: readonly ts.Statement[]): IrStmt[];
 /** The hoisted-handler shape: a function declared BEFORE a const it
    * captures, in the same (or an enclosing) statement list —
    *
@@ -41,18 +41,18 @@ export declare function lowerStmts(L: Lowerer, stmts: readonly ts.Statement[]):
    * test the box and throw Node's exact catchable ReferenceError while it
    * is empty. CONST ONLY: `let` would need the same trap on writes, a
    * surface nothing yet needs. */
-export declare function predeclareForwardCapture(L: Lowerer, symbol: ts.Symbol): boolean;
+export declare function predeclareForwardCapture(lowerer: Lowerer, symbol: ts.Symbol): boolean;
 /** The FUNCTION-DECLARATION twin of predeclareForwardCapture: JS hoists a
    * nested `function f() {}` to scope entry — the binding is LIVE from the
    * first statement, so a reference lexically above the declaration in the
    * SAME function lowers the declaration eagerly at the reference (varDecl
    * pushed before the current statement's IR, registered in the list's
    * scope frame) and the statement loop skips the source statement when it
-   * arrives (L.hoistedFnDecls). Same-function only: the declaration's own
+   * arrives (lowerer.hoistedFnDecls). Same-function only: the declaration's own
    * lowering runs under the ctx that owns its statement list, and a
    * cross-function early capture would need lowering under a DIFFERENT
    * ctx than the one currently open — that shape keeps the honest fence. */
-export declare function predeclareForwardFnDecl(L: Lowerer, symbol: ts.Symbol): boolean;
+export declare function predeclareForwardFnDecl(lowerer: Lowerer, symbol: ts.Symbol): boolean;
 /** True when `decl` (a variable declaration or a pattern name inside one)
    * was declared with `var` — no const/let/using flag anywhere on its
    * binding chain. */
@@ -64,32 +64,10 @@ export declare function isVarDeclared(decl: ts.Node): boolean;
    * iteration), and it persists after the loop. Returns the write target
    * (a module global for top-level loops, the hoisted function slot
    * otherwise); null when the binding isn't a `var` identifier. */
-export declare function forOfVarTarget(L: Lowerer, decl: ts.VariableDeclaration): {
+export declare function forOfVarTarget(lowerer: Lowerer, decl: ts.VariableDeclaration): {
     id: string;
     type: IrType;
 } | null;
-/** `var` declarations hoist to their FUNCTION: the binding exists across
-   * the whole enclosing function body regardless of block position, and
-   * every same-name `var` in that function is the SAME binding (tsc merges
-   * the declarations into one symbol, so symbol-keyed resolution gets the
-   * merge for free). This mints the one function-scoped slot on first
-   * encounter: an IrLocal registered in the function's ROOT scope frame
-   * (never popped by block exits) whose `varDecl` is PUSHED into the
-   * function-root statement list at the current position — everything
-   * already lowered never referenced the symbol (resolution would have
-   * found it), so the position is observationally function entry. Types
-   * with an undefined arm initialize to the interned undefined (JS's
-   * hoisted value — reads before the first assignment are `undefined`, and
-   * tsc's flow analysis rejects such reads for every OTHER type); the rest
-   * start empty, their pre-assignment reads impossible by that analysis.
-   * A `var` merging with a PARAMETER of the same name (one symbol in JS
-   * and in tsc's binder) resolves to the parameter's slot — `var x = 2`
-   * simply overwrites the argument, exactly Node. The source declaration
-   * lowers to a plain `assign` (see lowerVarDecl), so a declaration inside
-   * a loop re-ASSIGNS the one binding per pass and never resets it — the
-   * classic capture semantics fall out: closures made in a loop share the
-   * single boxed binding, where `let` gets a fresh box per iteration. */
-export declare function hoistVarBinding(L: Lowerer, symbol: ts.Symbol, nameNode: ts.Identifier): IrLocal;
 /** The forward twin of hoistVarBinding, entered from resolution failure: a
    * reference to a `var` whose declaration statement has not lowered yet —
    * a read/write lexically above the declaration in the same function
@@ -103,22 +81,22 @@ export declare function hoistVarBinding(L: Lowerer, symbol: ts.Symbol, nameNode:
    * a slot of a narrower type has no bit pattern for the `undefined` Node
    * would yield if the capture ran early, and guessing "it won't" is the
    * silent-wrong-output sin. */
-export declare function predeclareForwardVar(L: Lowerer, symbol: ts.Symbol): boolean;
+export declare function predeclareForwardVar(lowerer: Lowerer, symbol: ts.Symbol): boolean;
 /** Records the symbols a poisoned DECLARATION statement would have bound
    * (identifier and pattern names alike, for-initializers included) so
    * later references report the SC2004 cascade. Registered bindings win:
    * lowerVarDecl's salvage path declares the local when it can, and
    * resolution checks locals/globals before the fallthroughs consult
    * blockedBindings. */
-export declare function noteBlockedBindings(L: Lowerer, stmt: ts.Statement): void;
+export declare function noteBlockedBindings(lowerer: Lowerer, stmt: ts.Statement): void;
 /** True when a reference/assignment fell through resolution because the
    * binding's DECLARATION never compiled: a poisoned declaration statement
    * (blockedBindings) or a deferred-diagnostic declaration (a blocked
    * signature/class/global — deferred now, flushed earlier this pass, or
    * flushed by the emit pass). */
-export declare function isBlockedBinding(L: Lowerer, symbol: ts.Symbol | null): boolean;
+export declare function isBlockedBinding(lowerer: Lowerer, symbol: ts.Symbol | null): boolean;
 /** Lowers a statement in a fresh lexical scope (if/while/for bodies). */
-export declare function lowerScopedBlock(L: Lowerer, stmt: ts.Statement): IrStmt[];
+export declare function lowerScopedBlock(lowerer: Lowerer, stmt: ts.Statement): IrStmt[];
 /** The finally fences. `return` crossing OUT of a try/catch body guarded
    * by a finally is SUPPORTED now (the backend's pending-return path runs
    * every crossed finally inner-to-outer before the function returns, the
@@ -133,30 +111,15 @@ export declare function lowerScopedBlock(L: Lowerer, stmt: ts.Statement): IrStmt
    * jump walks outward past every construct (labeled targets can be
    * arbitrarily far out) until the entry carrying its label, applying the
    * same finally fences to everything crossed on the way. */
-export declare function rejectJumpCrossingFinally(L: Lowerer, kw: "break" | "continue" | "return", stmt: ts.Statement, label?: string): void;
-/** `lbl: stmt` — labeled statements. A label chain collapses to one name
-   * list (`a: b: while ...` — both names target the same loop, JS-exact).
-   * Loops and switches take the labels DIRECTLY (a labeled continue needs
-   * the loop's own continue point — the condition/update — and a labeled
-   * switch-break its end): pendingLabels hands them to the construct's own
-   * lowering, which consumes them before lowering anything nested (so an
-   * inner loop can never steal them). Every other labeled statement wraps
-   * in a labeled BLOCK — `break lbl` exits it (the only jump tsc allows to
-   * target a non-loop label), and a label nothing jumps to is just the
-   * statement itself. Loop shapes whose lowering is a label-free desugar
-   * (container/matchAll/stdin for-ofs, union switches) DROP the labels
-   * after consuming them: an unused label costs nothing, and a labeled
-   * jump naming one fences by name at the jump site instead of compiling
-   * against the wrong target. */
-export declare function lowerLabeled(L: Lowerer, stmt: ts.LabeledStatement): IrStmt | IrStmt[] | null;
-export declare function lowerStmt(L: Lowerer, stmt: ts.Statement): IrStmt | IrStmt[] | null;
+export declare function rejectJumpCrossingFinally(lowerer: Lowerer, kw: "break" | "continue" | "return", stmt: ts.Statement, label?: string): void;
+export declare function lowerStmt(lowerer: Lowerer, stmt: ts.Statement): IrStmt | IrStmt[] | null;
 /** A variable statement may carry several declarators (`let a = 1,
    * b = a + 1;`): each lowers to its own varDecl IN ORDER, so later
    * initializers see earlier bindings (JS-exact). `var` declarators ride
    * the same path — their "declaration" is an assignment into the
    * function-scoped hoisted slot (hoistVarBinding), so the mutability flag
    * passed down covers let AND var. */
-export declare function lowerVarStatement(L: Lowerer, stmt: ts.VariableStatement): IrStmt[];
+export declare function lowerVarStatement(lowerer: Lowerer, stmt: ts.VariableStatement): IrStmt[];
 /** The numeric indexed source of a built-in value-iterator expression:
    * `numbers.values()` or the equivalent
    * `numbers[Symbol.iterator]()`, where numbers is number[] or one of the
@@ -164,11 +127,11 @@ export declare function lowerVarStatement(L: Lowerer, stmt: ts.VariableStatement
    * a syntax + provenance test rather than a mapping for the iterator
    * object: it has observable mutable protocol state, represented by
    * hidden locals only while a stored binding stays in one function. */
-export declare function numericIteratorSourceOf(L: Lowerer, expr: ts.Expression | undefined): ts.Expression | null;
+export declare function numericIteratorSourceOf(lowerer: Lowerer, expr: ts.Expression | undefined): ts.Expression | null;
 /** Whether a checker type belongs to node:util.parseArgs's dyn-backed
  * declaration family. Module ancestry disambiguates short private helper
  * names such as `Token` from names in other standard-library modules. */
-export declare function isParseArgsDynCheckerType(L: Lowerer, type: ts.Type): boolean;
+export declare function isParseArgsDynCheckerType(lowerer: Lowerer, type: ts.Type): boolean;
 /** Destructuring declarations, desugared as sugar over indexed/field
    * reads: the initializer evaluates ONCE into a hidden temp, then each
    * bound name declares (or assigns its pre-registered module global) from
@@ -179,36 +142,15 @@ export declare function isParseArgsDynCheckerType(L: Lowerer, type: ts.Type): bo
    * where JS binds undefined). Defaults, rest elements, and computed keys
    * are fenced — each would need machinery beyond a read (an undefined
    * test, surplus packing, dynamic lookup). */
-export declare function lowerDestructuringDecl(L: Lowerer, decl: ts.VariableDeclaration, isLet: boolean): IrStmt[];
+export declare function lowerDestructuringDecl(lowerer: Lowerer, decl: ts.VariableDeclaration, isLet: boolean): IrStmt[];
 /** One pattern level: emits a declaration (or global assignment) per
    * bound name, recursing through hidden temps for nested patterns. */
-export declare function lowerBindingPattern(L: Lowerer, pattern: ts.ArrayBindingPattern | ts.ObjectBindingPattern, srcRef: () => IrExpr, srcType: IrType, isLet: boolean, out: IrStmt[], dynSpell?: string, allowDynObject?: boolean): void;
-/** The STATIC property name of a destructuring key: identifiers spell
-   * themselves, string/numeric-literal keys and COMPUTED keys fold through
-   * foldedStringKeyOf — pure single-name expressions only (`{ [k]: v }`
-   * where k's checker type spells one property name; tsc late-bound the
-   * source's field under exactly that name, and pure keys make skipping
-   * the evaluation exact). Null for runtime-valued keys — the callers
-   * fence, or route island sources to the engine pattern. */
-export declare function patternKeyNameOf(L: Lowerer, prop: ts.PropertyName): string | null;
+export declare function lowerBindingPattern(lowerer: Lowerer, pattern: ts.ArrayBindingPattern | ts.ObjectBindingPattern, srcRef: () => IrExpr, srcType: IrType, isLet: boolean, out: IrStmt[], dynSpell?: string, allowDynObject?: boolean): void;
 /** The fences the island's element-wise object path shares: no rest
    * (surplus packing over a handle) and no defaults (an engine undefined
    * test) — the static positions now take both through their own
    * machinery above. */
-export declare function checkBindingElement(L: Lowerer, el: ts.BindingElement, allowDefault?: boolean): void;
-/** A declaration pattern rebuilt as ENGINE source with every bound name
-   * renamed __0..__n (pattern order): holes, nesting, rest, and
-   * transportable defaults all survive verbatim, so the engine runs the
-   * REAL pattern — the iterator protocol on array patterns,
-   * RequireObjectCoercible on object patterns, JS's own default rule.
-   * Null when any element has no engine form (computed keys — a compiled
-   * expression the pattern text cannot carry — or untransportable
-   * defaults). */
-export declare function enginePatternSpec(L: Lowerer, pattern: ts.ArrayBindingPattern | ts.ObjectBindingPattern): {
-    text: string;
-    binds: ts.Identifier[];
-    extras: ts.Expression[];
-} | null;
+export declare function checkBindingElement(lowerer: Lowerer, el: ts.BindingElement, allowDefault?: boolean): void;
 /** Declaration-position destructuring over an ISLAND source: the ENGINE
    * runs the real pattern — a synthesized strict-mode
    * `new Function("v", ...)` exactly like the assignment chain's
@@ -220,8 +162,8 @@ export declare function enginePatternSpec(L: Lowerer, pattern: ts.ArrayBindingPa
    * both run — destructuring undefined throws Node's TypeError at Node's
    * exit), rest, and transportable defaults all ride. False when the
    * pattern has no engine form (the caller fences). */
-export declare function lowerJsvalBindingPattern(L: Lowerer, pattern: ts.ArrayBindingPattern | ts.ObjectBindingPattern, srcRef: () => IrExpr, isLet: boolean, out: IrStmt[]): boolean;
-export declare function bindPatternTarget(L: Lowerer, name: ts.BindingName, value: IrExpr, isLet: boolean, out: IrStmt[], allowDynObject?: boolean): void;
+export declare function lowerJsvalBindingPattern(lowerer: Lowerer, pattern: ts.ArrayBindingPattern | ts.ObjectBindingPattern, srcRef: () => IrExpr, isLet: boolean, out: IrStmt[]): boolean;
+export declare function bindPatternTarget(lowerer: Lowerer, name: ts.BindingName, value: IrExpr, isLet: boolean, out: IrStmt[], allowDynObject?: boolean): void;
 /** For-loop initializers. let/const stay restricted to ONE declarator (JS
    * per-iteration binding copies for several captured loop variables are
    * not modeled yet); `var` initializers take any number — a `var` is ONE
@@ -229,35 +171,13 @@ export declare function bindPatternTarget(L: Lowerer, name: ts.BindingName, valu
    * `for (var i = 0, n = xs.length; ...)` is just two hoisted-slot
    * assignments (wrapped in a block when several). Statement position goes
    * through lowerVarStatement. */
-export declare function lowerVarDeclList(L: Lowerer, list: ts.VariableDeclarationList): IrStmt | null;
-export declare function lowerVarDecl(L: Lowerer, decl: ts.VariableDeclaration, isLet: boolean): IrStmt | null;
+export declare function lowerVarDeclList(lowerer: Lowerer, list: ts.VariableDeclarationList): IrStmt | null;
+export declare function lowerVarDecl(lowerer: Lowerer, decl: ts.VariableDeclaration, isLet: boolean): IrStmt | null;
 /** JS-exact switch (see docs/ir.md): one shared lexical scope for all case
    * bodies, lazy source-order test evaluation, fall-through. tsc has already
    * checked case-test comparability (TS2678) — the kind check below is the
    * backstop for cases tsc lets through (e.g. `unknown as` casts). */
-export declare function lowerSwitch(L: Lowerer, stmt: ts.SwitchStatement): IrStmt;
-/** Switch on a UNION-typed discriminant (`switch (m.type)` over
-   * `string | undefined`): desugared to an if/else-if chain of per-union
-   * strict-equality tests (unionEq — the case value wraps into the union,
-   * exactly `disc === test`), because the backend switch compares plain
-   * primitives only. The desugar is JS-exact for the shape it accepts and
-   * fences everything it cannot reproduce:
-   * - the discriminant rides every test, so it must be a plain
-   *   side-effect-free read (bind it to a const first otherwise);
-   * - tests evaluate lazily in source order (the chain's short-circuit IS
-   *   the switch's test order — grouped empty cases `case a: case b:` OR
-   *   their tests, still in order);
-   * - each non-final clause must EXIT (a trailing unconditional break —
-   *   dropped, it's the chain's own exit — or a return/throw/continue):
-   *   real fall-through between bodies has no if/else shape;
-   * - any OTHER unlabeled break binding to this switch (a conditional
-   *   early break) is fenced — desugared, it would bind to an enclosing
-   *   loop instead;
-   * - `default` may sit anywhere in source (JS tests every case first;
-   *   the chain's final else reproduces that as long as its body exits or
-   *   is last).
-   * Case bodies share ONE lexical scope, exactly like the real switch. */
-export declare function lowerUnionSwitch(L: Lowerer, stmt: ts.SwitchStatement, disc: IrExpr): IrStmt;
+export declare function lowerSwitch(lowerer: Lowerer, stmt: ts.SwitchStatement): IrStmt;
 /** try/catch/finally. Supported subset:
    * - `catch { }` (bindingless) discards the thrown value on entry.
    * - `catch (e)` binds it as a CAUGHT local — a snapshot of the exception
@@ -279,13 +199,13 @@ export declare function lowerUnionSwitch(L: Lowerer, stmt: ts.SwitchStatement, d
    *   restriction on jumps.
    * Each block is its own lexical scope (the binding lives in a scope
    * WRAPPING the catch block, like the spec's catch environment). */
-export declare function lowerTry(L: Lowerer, stmt: ts.TryStatement): IrStmt;
+export declare function lowerTry(lowerer: Lowerer, stmt: ts.TryStatement): IrStmt;
 /** Expression-position statements: assignments, calls. Shared with
    * for-loop init/update. Parens unwrap first — `(x = v);` is the plain
    * assignment, and `({ a, b } = e);` (destructuring ASSIGNMENT, which JS
    * requires parenthesized in statement position) lands in the
    * object-literal-target branch below. */
-export declare function lowerExprStatement(L: Lowerer, expr: ts.Expression): IrStmt;
+export declare function lowerExprStatement(lowerer: Lowerer, expr: ts.Expression): IrStmt;
 /** `({ a, b: x } = e);`, `[a, b = 0, ...rest] = xs;` — destructuring
    * assignment to EXISTING writable bindings, statement position, from a
    * PRE-LOWERED source: for-of expression heads hand the per-iteration
@@ -294,7 +214,7 @@ export declare function lowerExprStatement(L: Lowerer, expr: ts.Expression): IrS
    * text). Plain assignment statements ride
    * lowerDestructuringAssignParts, which keeps the RHS expression for
    * that spelling. */
-export declare function lowerDestructuringAssign(L: Lowerer, target: ts.ObjectLiteralExpression | ts.ArrayLiteralExpression, init: IrExpr, blame: ts.Node, loc: SrcLoc): IrStmt;
+export declare function lowerDestructuringAssign(lowerer: Lowerer, target: ts.ObjectLiteralExpression | ts.ArrayLiteralExpression, init: IrExpr, blame: ts.Node, loc: SrcLoc): IrStmt;
 /** Destructuring ASSIGNMENT (existing bindings — the declaration twin is
    * lowerDestructuringDecl): the RHS evaluates ONCE into a hidden temp,
    * each target assigns in source order, and the parts' VALUE is the
@@ -317,7 +237,7 @@ export declare function lowerDestructuringAssign(L: Lowerer, target: ts.ObjectLi
    * past-the-end undefined demands) and rest packing the tail fresh
    * (array slices, tuple tails). Nesting, computed keys, and member
    * targets keep fences. */
-export declare function lowerDestructuringAssignParts(L: Lowerer, target: ts.ObjectLiteralExpression | ts.ArrayLiteralExpression, rhs: ts.Expression, loc: SrcLoc): {
+export declare function lowerDestructuringAssignParts(lowerer: Lowerer, target: ts.ObjectLiteralExpression | ts.ArrayLiteralExpression, rhs: ts.Expression, loc: SrcLoc): {
     stmts: IrStmt[];
     value: IrExpr;
 };
@@ -326,44 +246,5 @@ export declare function lowerDestructuringAssignParts(L: Lowerer, target: ts.Obj
    * specific diagnostics; other iterables fail on their types. The loop
    * variable is a fresh const binding per iteration (its own scope, like a
    * loop body). */
-export declare function lowerForOf(L: Lowerer, stmt: ts.ForOfStatement): IrStmt;
-/** A DIRECT `s.matchAll(re)` call: a stdlib matchAll property call on a
-   * string-typed receiver with one regex-typed argument (parens stripped).
-   * The shape the companion-index machinery serves. */
-export declare function directMatchAllCallOf(L: Lowerer, e: ts.Expression): ts.CallExpression | null;
-/** for-in loops. The key set is Node's own-enumerable-keys walk, lowered
-   * per receiver kind:
-   * - RECORDS (fixed shapes): iteration over exactly the keys Object.keys
-   *   answers — the shared interned keys helper (recordKeysArrayCall):
-   *   declaration order, fields holding the undefined arm of their union
-   *   skipped at runtime (SEMANTICS.md 37's rules verbatim). The key list
-   *   snapshots at loop entry, which IS Node's for-in contract for keys
-   *   ADDED during the walk (never visited); fixed shapes cannot lose keys
-   *   mid-loop (no delete), so the snapshot is exact.
-   * - INDEX-SIGNATURE shapes: the same Object.keys hybrid/pure walk
-   *   (declared fields first, then the overflow in JS own-key order —
-   *   objectIterOverIndexShape's "keys" arm, same intern key). Adds during
-   *   the loop are correctly NOT visited (the snapshot); PURE shapes —
-   *   the one record kind where `delete obj[k]` is lowered — additionally
-   *   guard every visit with a live presence test, Node's HasProperty
-   *   re-check, so keys deleted before their turn are skipped exactly
-   *   like Node.
-   * - ARRAYS: Node's canonical ascending index strings. The key set
-   *   snapshots at entry (pushes during the body are NOT visited — V8's
-   *   own-keys snapshot, verified against Node) while each visit re-checks
-   *   presence (i < live length), so pops during the body skip exactly
-   *   like Node. Sparse arrays cannot exist here (hole creation traps).
-   * - globalThis: the harness's leaked-globals sweep — a compiled binary's
-   *   global bindings are compile-time names, never enumerable runtime
-   *   properties, so the enumeration is honestly EMPTY (zero iterations;
-   *   the body typechecked but never evaluates — SEMANTICS.md documents
-   *   the divergence).
-   * - class instances fence: which keys exist on one depends on runtime
-   *   property creation (unset declared fields, useDefineForClassFields)
-   *   that the struct model does not track — named, not guessed.
-   * Bindings mirror for-of's: const/let declare the per-iteration string
-   * local, `var` assigns the hoisted shared slot, a pre-declared
-   * identifier target assigns per pass; destructuring heads are tsc
-   * errors. */
-export declare function lowerForIn(L: Lowerer, stmt: ts.ForInStatement): IrStmt;
-export declare function lowerForStatement(L: Lowerer, stmt: ts.ForStatement): IrStmt;
+export declare function lowerForOf(lowerer: Lowerer, stmt: ts.ForOfStatement): IrStmt;
+export declare function lowerForStatement(lowerer: Lowerer, stmt: ts.ForStatement): IrStmt;