@scriptc/compiler 0.1.1 → 0.1.2

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

@@ -97,21 +97,6 @@ export declare function noteBlockedBindings(lowerer: Lowerer, stmt: ts.Statement
 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(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
-   * value snapshotted first — Node-exact); what stays rejected is (a) any
-   * jump out of a finally BLOCK itself (a return there would REPLACE a
-   * pending completion — clearing a still-propagating exception or
-   * abandoning a pending return, a model the emitter doesn't implement),
-   * and (b) break/continue crossing a try-with-finally (their targets bind
-   * inside the function; the pending-action plumbing exists only for
-   * return, the shape real code needs). Rejected, not miscompiled. Plain
-   * try/catch is transparent to jumps (it never appears in ctl). A LABELED
-   * 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(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
@@ -178,7 +163,7 @@ export declare function lowerVarDecl(lowerer: Lowerer, decl: ts.VariableDeclarat
    * 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(lowerer: Lowerer, stmt: ts.SwitchStatement): IrStmt;
-/** try/catch/finally. Supported subset:
+/** try/catch/finally:
    * - `catch { }` (bindingless) discards the thrown value on entry.
    * - `catch (e)` binds it as a CAUGHT local — a snapshot of the exception
    *   cell, deliberately narrower than dyn: the supported uses are the
@@ -189,14 +174,10 @@ export declare function lowerSwitch(lowerer: Lowerer, stmt: ts.SwitchStatement):
    *   assignment are fenced (SC1063 and friends); destructuring patterns
    *   are SC1062. The `: any` / `: unknown` annotations tsc admits both
    *   lower the same way (tsc narrows either through the tests).
-   * - `finally` runs on normal completion, on exception paths, and on the
-   *   way out of a `return` in the try/catch body (the backend's
-   *   pending-return path — inner-to-outer through nested finallys, the
-   *   value snapshotted before the finally runs, Node-exact).
-   *   break/continue crossing a try-with-finally stay rejected, as does
-   *   any jump out of the finally body itself (it would replace a pending
-   *   completion — rejectJumpCrossingFinally). Plain try/catch places no
-   *   restriction on jumps.
+   * - `finally` runs on normal completion, exception paths, and every
+   *   abrupt completion that crosses it. Return values are snapshotted
+   *   before cleanup; an abrupt completion inside the finally replaces the
+   *   pending one, matching JavaScript completion-record semantics.
    * 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(lowerer: Lowerer, stmt: ts.TryStatement): IrStmt;