lemmascript 0.5.17 → 0.5.18

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "lemmascript",
-  "version": "0.5.17",
+  "version": "0.5.18",
   "description": "A verification toolchain for TypeScript — generates Lean 4 or Dafny from annotated TS",
   "type": "module",
   "engines": {

package/tools/dist/narrow.js

@@ -34,6 +34,7 @@
  * (early-return, let-cond) run in `walkStmts` so they can consume the rest
  * of the block.
  */
+import { isTerminatorKind } from "./typedir.js";
 import { freshName } from "./names.js";
 // ── Optional-check detection ────────────────────────────────
 /** Counter for naming optChain binders. Reset per module. */
@@ -918,8 +919,7 @@ function parseNegativeDiscriminantCond(cond) {
 function isTerminating(stmts) {
     if (stmts.length === 0)
         return false;
-    const last = stmts[stmts.length - 1];
-    return last.kind === "return" || last.kind === "throw" || last.kind === "break" || last.kind === "continue";
+    return isTerminatorKind(stmts[stmts.length - 1].kind);
 }
 /** Rule (list-level): consecutive `if (x.kind === "v") ...` chain → tagMatch.
  *  Walks consecutive top-level ifs on the same discriminator var; the first

package/tools/dist/resolve.js

@@ -4,7 +4,7 @@
  * Uses linked environments (Scheme-style) for lexical scoping.
  * No mutation — each let extends the chain, lookup walks it.
  */
-import { isBigInt, tyEqual } from "./typedir.js";
+import { isBigInt, tyEqual, isTerminatorKind } from "./typedir.js";
 import { parseTsType, tyToCanonical } from "./types.js";
 import { parseExpr } from "./specparser.js";
 import { freshName } from "./names.js";
@@ -1263,9 +1263,12 @@ function resolveBlock(stmts, ctx) {
         env = nextEnv;
         // Flow narrowing: if (x === undefined) { return } narrows x for rest of block.
         // Also handles compound: if (x === undefined || y === undefined) { return }
+        // Any terminator counts (return/throw/break/continue — same set as narrow's
+        // isTerminating): each exits the current block, so the rest of the block
+        // only runs when the guard was false.
         // Field chains are excluded — resolve can't substitute in statement lists;
         // transform's emitOptionalMatch handles field chains in statement contexts.
-        if (s.kind === "if" && s.then.length > 0 && s.then[s.then.length - 1].kind === "return" && s.else.length === 0) {
+        if (s.kind === "if" && s.then.length > 0 && isTerminatorKind(s.then[s.then.length - 1].kind) && s.else.length === 0) {
             const narrowings = collectEarlyReturnNarrowings(s.cond, withEnv(ctx, env));
             for (const n of narrowings) {
                 env = extend(env, n.varName, n.innerTy);

package/tools/dist/typedir.js

@@ -44,3 +44,9 @@ export function tyEqual(a, b) {
         case "unknown": return true; // no payload
     }
 }
+/** Statement kinds that unconditionally leave the enclosing block. Shared by
+ *  resolve (block-tail narrowing) and narrow (isTerminating); works on raw and
+ *  typed IR alike since both use these kind strings. */
+export function isTerminatorKind(kind) {
+    return kind === "return" || kind === "throw" || kind === "break" || kind === "continue";
+}