@scriptc/compiler 0.1.7 → 0.2.1

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, IrStmt, IrType, SrcLoc } from "../../ir/ir.js";
+import { type IrExpr, type IrStmt, type IrType, type 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
@@ -39,8 +39,8 @@ export declare function lowerStmts(lowerer: Lowerer, stmts: readonly ts.Statemen
    * threads captures normally. The source declaration later becomes the
    * initializing `assign` (lowerVarDecl consumes tdzPredeclared). Reads
    * 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. */
+   * is empty. Mutable bindings also guard writes; only the declaration's
+   * initializing assignment may leave the temporal dead zone. */
 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
@@ -49,10 +49,9 @@ export declare function predeclareForwardCapture(lowerer: Lowerer, symbol: ts.Sy
    * declaration and initializing assignment are 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
-   * (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. */
+   * (the owner's hoistedFnDecls). Forward references from nested functions
+   * lower the declaration under the owning statement list's context, then
+   * resume the caller and thread its captures normally. */
 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
@@ -150,15 +149,15 @@ export declare function checkBindingElement(lowerer: Lowerer, el: ts.BindingElem
    * pattern has no engine form (the caller fences). */
 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
-   * function-scoped binding with no per-iteration copies to model, so
-   * `for (var i = 0, n = xs.length; ...)` is just two hoisted-slot
-   * assignments (wrapped in a block when several). Statement position goes
-   * through lowerVarStatement. */
+/** For-loop initializers evaluate declarators from left to right. The LLVM
+ * loop emitter keeps their scope alive and freshens every captured let
+ * binding before the first condition and each subsequent update. */
 export declare function lowerVarDeclList(lowerer: Lowerer, list: ts.VariableDeclarationList): IrStmt | null;
 export declare function lowerVarDecl(lowerer: Lowerer, decl: ts.VariableDeclaration, isLet: boolean): IrStmt | null;
+export declare function hasJsTypeAnnotation(decl: ts.VariableDeclaration): boolean;
+/** Inferred JS scalar initializers do not constrain later writes through
+ * an any-valued callback. Keep those bindings open, including captured writes. */
+export declare function jsBindingHasOpenWrites(lowerer: Lowerer, decl: ts.VariableDeclaration): boolean;
 /** 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
@@ -171,9 +170,10 @@ export declare function lowerSwitch(lowerer: Lowerer, stmt: ts.SwitchStatement):
    *   narrowing tests (`e instanceof C` over hierarchy classes, `typeof e
    *   === "string"/"number"/"boolean"`), reads under a proven narrow
    *   (caughtRead bridges them with caughtNarrow, trust-the-checker like
-   *   unionNarrow), and rethrow (`throw e`). Raw uses, captures, and
-   *   assignment are fenced (SC1063 and friends); destructuring patterns
-   *   are SC1062. The `: any` / `: unknown` annotations tsc admits both
+   *   unionNarrow), and rethrow (`throw e`). Unsupported raw uses and
+   *   assignments are fenced (SC1063 and friends); destructuring patterns
+   *   are SC1062. Captures retain the snapshot beyond the catch scope.
+   *   The `: any` / `: unknown` annotations tsc admits both
    *   lower the same way (tsc narrows either through the tests).
    * - `finally` runs on normal completion, exception paths, and every
    *   abrupt completion that crosses it. Return values are snapshotted