lemmascript 0.3.0 → 0.3.2

package/package.json

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

package/tools/dist/dafny-commands.js

@@ -31,13 +31,14 @@ export function dafnyCheckDiff(genPath, dfyPath) {
     catch { /* diff not available */ }
     return true;
 }
-export function dafnyVerify(dfyPath, dir, timeLimit) {
+export function dafnyVerify(dfyPath, dir, timeLimit, extraFlags) {
     console.log("Running dafny verify...");
     try {
         const content = readFileSync(dfyPath, "utf-8");
         const stdLibFlag = content.includes("Std.") ? " --standard-libraries" : "";
         const timeLimitFlag = timeLimit ? ` --verification-time-limit ${timeLimit}` : "";
-        execSync(`dafny verify${stdLibFlag}${timeLimitFlag} "${dfyPath}"`, { cwd: dir, stdio: "inherit" });
+        const extra = extraFlags ? ` ${extraFlags}` : "";
+        execSync(`dafny verify${stdLibFlag}${timeLimitFlag}${extra} "${dfyPath}"`, { cwd: dir, stdio: "inherit" });
         return true;
     }
     catch {

package/tools/dist/dafny-emit.js

@@ -14,7 +14,7 @@ function tyToDafny(ty) {
         case "map": return `map<${tyToDafny(ty.key)}, ${tyToDafny(ty.value)}>`;
         case "set": return `set<${tyToDafny(ty.elem)}>`;
         case "optional": {
-            needsOptionType = true;
+            needPreamble("OptionType");
             return `Option<${tyToDafny(ty.inner)}>`;
         }
         case "user": return ty.name;
@@ -55,6 +55,22 @@ const OP_MAP = {
 };
 function mapOp(op) { return OP_MAP[op] ?? op; }
 // ── Expression emission ─────────────────────────────────────
+/** Emit a match scrutinee — either a variable name (string) or an expression. */
+function emitScrutinee(s) {
+    return typeof s === "string" ? escapeName(s) : emitExpr(s);
+}
+/** Collapse nested forall/exists into a single quantifier with multiple bound vars. */
+function emitQuantifier(e, keyword) {
+    const vars = [];
+    let body = e;
+    while (body.kind === e.kind) {
+        const dty = tyToDafny(body.type);
+        const ann = dty === "string" ? "" : `: ${dty}`;
+        vars.push(`${body.var}${ann}`);
+        body = body.body;
+    }
+    return `${keyword} ${vars.join(", ")} :: ${emitExpr(body)}`;
+}
 function emitExpr(e) {
     switch (e.kind) {
         case "var": return e.name === "undefined" ? "None" : escapeName(e.name);
@@ -78,6 +94,10 @@ function emitExpr(e) {
                     return `${obj}[${args[0]} := ${args[1]}]`;
                 if (e.method === "includes")
                     return `(${args[0]} in ${obj})`;
+                if (e.method === "indexOf") {
+                    needPreamble("SeqIndexOf");
+                    return `SeqIndexOf(${obj}, ${args[0]})`;
+                }
                 if (e.method === "push")
                     return `(${obj} + [${args[0]}])`;
                 if (e.method === "concat")
@@ -106,25 +126,25 @@ function emitExpr(e) {
             // String methods
             if (ty === "string") {
                 if (e.method === "indexOf") {
-                    needsStringIndexOf = true;
+                    needPreamble("StringIndexOf");
                     return `StringIndexOf(${obj}, ${args[0]})`;
                 }
                 if (e.method === "slice")
                     return `${obj}[${args[0]}..${args[1]}]`;
                 if (e.method === "trim") {
-                    needsStringTrim = true;
+                    needPreamble("StringTrim");
                     return `StringTrim(${obj})`;
                 }
                 if (e.method === "toLowerCase") {
-                    needsStringToLower = true;
+                    needPreamble("StringToLower");
                     return `StringToLower(${obj})`;
                 }
                 if (e.method === "toUpperCase") {
-                    needsStringToUpper = true;
+                    needPreamble("StringToUpper");
                     return `StringToUpper(${obj})`;
                 }
                 if (e.method === "includes") {
-                    needsStringIndexOf = true;
+                    needPreamble("StringIndexOf");
                     return `(StringIndexOf(${obj}, ${args[0]}) >= 0)`;
                 }
                 if (e.method === "charCodeAt")
@@ -135,7 +155,7 @@ function emitExpr(e) {
                 if (e.method === "getDirect")
                     return `${obj}[${args[0]}]`;
                 if (e.method === "get") {
-                    needsOptionType = true;
+                    needPreamble("OptionType");
                     return `(if ${args[0]} in ${obj} then Some(${obj}[${args[0]}]) else None)`;
                 }
                 if (e.method === "set")
@@ -187,14 +207,14 @@ function emitExpr(e) {
                 if (e.right.kind === "num") {
                     return `(${emitExpr(e.left)} / ${Math.pow(2, e.right.value)})`;
                 }
-                needsPow2 = true;
+                needPreamble("Pow2");
                 return `(${emitExpr(e.left)} / Pow2(${emitExpr(e.right)}))`;
             }
             if (e.op === "<<") {
                 if (e.right.kind === "num") {
                     return `(${emitExpr(e.left)} * ${Math.pow(2, e.right.value)})`;
                 }
-                needsPow2 = true;
+                needPreamble("Pow2");
                 return `(${emitExpr(e.left)} * Pow2(${emitExpr(e.right)}))`;
             }
             // x & mask → x % (mask + 1) for literal masks of form 2^n - 1, else BitAnd
@@ -206,7 +226,7 @@ function emitExpr(e) {
                         return `(${emitExpr(e.left)} % ${modulus})`;
                     }
                 }
-                needsBitAnd = true;
+                needPreamble("BitAnd");
                 return `BitAnd(${emitExpr(e.left)}, ${emitExpr(e.right)})`;
             }
             // int * real coercion: wrap int side with "as real"
@@ -228,7 +248,7 @@ function emitExpr(e) {
         case "app": {
             const args = e.args.map(emitExpr);
             if (e.fn === "SetToSeq") {
-                needsSetToSeq = true;
+                needPreamble("SetToSeq");
                 return `SetToSeq(${args.join(", ")})`;
             }
             if (e.fn === "BigInt" || e.fn === "Number")
@@ -237,19 +257,19 @@ function emitExpr(e) {
             if (e.fn === "SetLiteral")
                 return `{${args.join(", ")}}`;
             if (e.fn === "JSFloorDiv")
-                needsJSFloorDiv = true;
+                needPreamble("JSFloorDiv");
             if (e.fn === "CeilReal")
-                needsCeilReal = true;
+                needPreamble("CeilReal");
             if (e.fn === "FloorReal")
-                needsFloorReal = true;
+                needPreamble("FloorReal");
             if (e.fn === "NatToString")
-                needsNatToString = true;
+                needPreamble("NatToString");
             if (e.fn === "MathAbs")
-                needsMathAbs = true;
+                needPreamble("MathAbs");
             if (e.fn === "MathMin")
-                needsMathMin = true;
+                needPreamble("MathMin");
             if (e.fn === "MathMax")
-                needsMathMax = true;
+                needPreamble("MathMax");
             return `${escapeName(e.fn)}(${args.join(", ")})`;
         }
         case "field": {
@@ -295,7 +315,7 @@ function emitExpr(e) {
                         if (f)
                             return emitExpr(f.value);
                         if (sf.type.kind === "optional") {
-                            needsOptionType = true;
+                            needPreamble("OptionType");
                             return "None";
                         }
                         return `/* missing: ${sf.name} */`;
@@ -311,34 +331,12 @@ function emitExpr(e) {
         case "if":
             return `if ${emitExpr(e.cond)} then ${emitExpr(e.then)} else ${emitExpr(e.else)}`;
         case "match": {
-            const scrut = typeof e.scrutinee === "string" ? escapeName(e.scrutinee) : emitExpr(e.scrutinee);
+            const scrut = emitScrutinee(e.scrutinee);
             const arms = e.arms.map(a => `case ${translatePattern(a.pattern)} => ${emitExpr(a.body)}`);
             return `(match ${scrut} { ${arms.join(" ")} })`;
         }
-        case "forall": {
-            // Collapse nested foralls: forall x :: forall y :: P → forall x, y :: P
-            const vars = [];
-            let body = e;
-            while (body.kind === "forall") {
-                const dty = tyToDafny(body.type);
-                const ann = dty === "string" ? "" : `: ${dty}`;
-                vars.push(`${body.var}${ann}`);
-                body = body.body;
-            }
-            return `forall ${vars.join(", ")} :: ${emitExpr(body)}`;
-        }
-        case "exists": {
-            // Collapse nested exists: exists x :: exists y :: P → exists x, y :: P
-            const vars = [];
-            let body = e;
-            while (body.kind === "exists") {
-                const dty = tyToDafny(body.type);
-                const ann = dty === "string" ? "" : `: ${dty}`;
-                vars.push(`${body.var}${ann}`);
-                body = body.body;
-            }
-            return `exists ${vars.join(", ")} :: ${emitExpr(body)}`;
-        }
+        case "forall": return emitQuantifier(e, "forall");
+        case "exists": return emitQuantifier(e, "exists");
         case "let": return `var ${escapeName(e.name)} := ${emitExpr(e.value)}; ${emitExpr(e.body)}`;
         case "havoc": return "*";
     }
@@ -350,7 +348,7 @@ function emitPureExpr(e, indent) {
         case "if":
             return `${pad}if ${emitExpr(e.cond)} then\n${emitPureExpr(e.then, indent + 1)}\n${pad}else\n${emitPureExpr(e.else, indent + 1)}`;
         case "match": {
-            const scrut = typeof e.scrutinee === "string" ? escapeName(e.scrutinee) : emitExpr(e.scrutinee);
+            const scrut = emitScrutinee(e.scrutinee);
             const lines = [`${pad}match ${scrut} {`];
             for (const arm of e.arms) {
                 lines.push(`${pad}  case ${translatePattern(arm.pattern)} =>`);
@@ -415,7 +413,7 @@ function emitStmt(s, indent) {
             return out;
         }
         case "match": {
-            const scrut = typeof s.scrutinee === "string" ? escapeName(s.scrutinee) : emitExpr(s.scrutinee);
+            const scrut = emitScrutinee(s.scrutinee);
             const lines = [`${pad}match ${scrut} {`];
             for (const arm of s.arms) {
                 lines.push(`${pad}  case ${translatePattern(arm.pattern)} =>`);
@@ -480,8 +478,10 @@ function emitDecl(d) {
             lines.push(`}`);
             // Companion lemma for ensures (proof target for LLM)
             if (d.ensures.length > 0) {
+                // Strip constraints like (==) from type params — ghost lemmas don't need them
+                const lemmaTP = d.typeParams.length > 0 ? `<${d.typeParams.map(t => t.replace(/\(.*\)/, '')).join(", ")}>` : "";
                 lines.push("");
-                lines.push(`lemma ${d.name}_ensures${tp}(${paramList(d.params)})`);
+                lines.push(`lemma ${d.name}_ensures${lemmaTP}(${paramList(d.params)})`);
                 for (const r of d.requires)
                     lines.push(`  requires ${emitExpr(r)}`);
                 for (const e of d.ensures)
@@ -534,21 +534,9 @@ function emitDecl(d) {
 }
 // ── File emission ───────────────────────────────────────────
 // ── Preamble helpers ────────────────────────────────────────
-let needsStringIndexOf = false;
-let needsStringTrim = false;
-let needsStringToLower = false;
-let needsStringToUpper = false;
-let needsJSFloorDiv = false;
-let needsCeilReal = false;
-let needsFloorReal = false;
-let needsOptionType = false;
-let needsSetToSeq = false;
-let needsBitAnd = false;
-let needsPow2 = false;
-let needsNatToString = false;
-let needsMathAbs = false;
-let needsMathMin = false;
-let needsMathMax = false;
+/** Preamble tracking — emitters add keys via `needPreamble(key)`, emitDafnyFile emits them. */
+const _neededPreambles = new Set();
+function needPreamble(key) { _neededPreambles.add(key); }
 const POW2 = `function Pow2(n: int): int
   requires n >= 0
   decreases n
@@ -581,6 +569,25 @@ const CEIL_REAL = `function CeilReal(x: real): int
   if x == (x.Floor as real) then x.Floor
   else x.Floor + 1
 }`;
+const SEQ_INDEX_OF = `function SeqIndexOf<T(==)>(s: seq<T>, x: T): int
+  ensures -1 <= SeqIndexOf(s, x) < |s|
+  ensures SeqIndexOf(s, x) >= 0 ==> s[SeqIndexOf(s, x)] == x
+  ensures SeqIndexOf(s, x) == -1 ==> x !in s
+{
+  SeqIndexOfFrom(s, x, 0)
+}
+
+function SeqIndexOfFrom<T(==)>(s: seq<T>, x: T, from: nat): int
+  requires from <= |s|
+  ensures -1 <= SeqIndexOfFrom(s, x, from) < |s|
+  ensures SeqIndexOfFrom(s, x, from) >= 0 ==> s[SeqIndexOfFrom(s, x, from)] == x
+  ensures SeqIndexOfFrom(s, x, from) == -1 ==> forall i :: from <= i < |s| ==> s[i] != x
+  decreases |s| - from
+{
+  if from == |s| then -1
+  else if s[from] == x then from as int
+  else SeqIndexOfFrom(s, x, from + 1)
+}`;
 const STRING_INDEX_OF = `function StringIndexOf(s: string, sub: string): int
 {
   StringIndexOfFrom(s, sub, 0)
@@ -646,6 +653,42 @@ const NAT_TO_STRING = `function NatToString(n: nat): string
   else NatToString(n / 10) + [digit]
 }`;
 const MATH_ABS = `function MathAbs(x: int): nat { if x >= 0 then x else -x }`;
+const SET_TO_SEQ = `method SetToSeq<T>(s: set<T>) returns (res: seq<T>)
+  ensures forall x :: x in s <==> x in res
+  ensures |res| == |s|
+{
+  var remaining := s;
+  res := [];
+  while remaining != {}
+    invariant remaining <= s
+    invariant forall x :: x in res <==> (x in s && x !in remaining)
+    invariant |res| + |remaining| == |s|
+    decreases remaining
+  {
+    var x :| x in remaining;
+    res := res + [x];
+    remaining := remaining - {x};
+  }
+}`;
+/** Preamble code keyed by name. Emitted in this order when needed. */
+const PREAMBLE_CODE = [
+    ["OptionType", "datatype Option<T> = None | Some(value: T)"],
+    ["SetToSeq", SET_TO_SEQ],
+    ["Pow2", POW2],
+    ["BitAnd", BIT_AND],
+    ["JSFloorDiv", JS_FLOOR_DIV],
+    ["CeilReal", CEIL_REAL],
+    ["FloorReal", FLOOR_REAL],
+    ["SeqIndexOf", SEQ_INDEX_OF],
+    ["StringIndexOf", STRING_INDEX_OF],
+    ["StringTrim", STRING_TRIM],
+    ["StringToLower", STRING_TO_LOWER],
+    ["StringToUpper", STRING_TO_UPPER],
+    ["NatToString", NAT_TO_STRING],
+    ["MathAbs", MATH_ABS],
+    ["MathMin", MATH_MIN],
+    ["MathMax", MATH_MAX],
+];
 // ── Constructor and record helpers ───────────────────────────
 let _recordCtors = new Map();
 let _structureDecls = new Map();
@@ -714,26 +757,9 @@ function translatePattern(pattern) {
     const fieldNames = fields.split(/\s+/).map(escapeName);
     return `${ctorName}(${fieldNames.join(", ")})`;
 }
-const PREAMBLES = {
-    StringIndexOf: STRING_INDEX_OF,
-};
 export function emitDafnyFile(file, tsFileName) {
     buildRecordCtorMap(file.decls);
-    needsStringIndexOf = false;
-    needsStringTrim = false;
-    needsStringToLower = false;
-    needsStringToUpper = false;
-    needsJSFloorDiv = false;
-    needsCeilReal = false;
-    needsFloorReal = false;
-    needsOptionType = false;
-    needsSetToSeq = false;
-    needsBitAnd = false;
-    needsPow2 = false;
-    needsNatToString = false;
-    needsMathAbs = false;
-    needsMathMin = false;
-    needsMathMax = false;
+    _neededPreambles.clear();
     // Collect pure def names so we can skip their method wrappers
     const pureDefs = new Set();
     for (const d of file.decls) {
@@ -770,81 +796,11 @@ export function emitDafnyFile(file, tsFileName) {
     const lines = [];
     if (tsFileName)
         lines.push(`// Generated by lsc from ${tsFileName}`);
-    if (needsOptionType) {
-        lines.push("");
-        lines.push("datatype Option<T> = None | Some(value: T)");
-    }
-    if (needsSetToSeq) {
-        lines.push("");
-        lines.push(`method SetToSeq<T>(s: set<T>) returns (res: seq<T>)
-  ensures forall x :: x in s <==> x in res
-  ensures |res| == |s|
-{
-  var remaining := s;
-  res := [];
-  while remaining != {}
-    invariant remaining <= s
-    invariant forall x :: x in res <==> (x in s && x !in remaining)
-    invariant |res| + |remaining| == |s|
-    decreases remaining
-  {
-    var x :| x in remaining;
-    res := res + [x];
-    remaining := remaining - {x};
-  }
-}`);
-    }
-    if (needsPow2) {
-        lines.push("");
-        lines.push(POW2);
-    }
-    if (needsBitAnd) {
-        lines.push("");
-        lines.push(BIT_AND);
-    }
-    if (needsJSFloorDiv) {
-        lines.push("");
-        lines.push(JS_FLOOR_DIV);
-    }
-    if (needsCeilReal) {
-        lines.push("");
-        lines.push(CEIL_REAL);
-    }
-    if (needsFloorReal) {
-        lines.push("");
-        lines.push(FLOOR_REAL);
-    }
-    if (needsStringIndexOf) {
-        lines.push("");
-        lines.push(PREAMBLES.StringIndexOf);
-    }
-    if (needsStringTrim) {
-        lines.push("");
-        lines.push(STRING_TRIM);
-    }
-    if (needsStringToLower) {
-        lines.push("");
-        lines.push(STRING_TO_LOWER);
-    }
-    if (needsStringToUpper) {
-        lines.push("");
-        lines.push(STRING_TO_UPPER);
-    }
-    if (needsNatToString) {
-        lines.push("");
-        lines.push(NAT_TO_STRING);
-    }
-    if (needsMathAbs) {
-        lines.push("");
-        lines.push(MATH_ABS);
-    }
-    if (needsMathMin) {
-        lines.push("");
-        lines.push(MATH_MIN);
-    }
-    if (needsMathMax) {
-        lines.push("");
-        lines.push(MATH_MAX);
+    for (const [key, code] of PREAMBLE_CODE) {
+        if (_neededPreambles.has(key)) {
+            lines.push("");
+            lines.push(code);
+        }
     }
     lines.push(...declLines);
     return lines.join("\n") + "\n";

package/tools/dist/extract.js

@@ -196,6 +196,7 @@ function extractExpr(node) {
     if (Node.isObjectLiteralExpression(node)) {
         let spread = null;
         const fields = [];
+        const computedFields = [];
         for (const prop of node.getProperties()) {
             if (Node.isSpreadAssignment(prop)) {
                 spread = extractExpr(prop.getExpression());
@@ -205,10 +206,26 @@ function extractExpr(node) {
                 fields.push({ name, value: { kind: "var", name } });
             }
             else if (Node.isPropertyAssignment(prop)) {
+                const nameNode = prop.getNameNode();
                 const init = prop.getInitializer();
-                if (init)
+                if (init && Node.isComputedPropertyName(nameNode)) {
+                    computedFields.push({ key: extractExpr(nameNode.getExpression()), value: extractExpr(init) });
+                }
+                else if (init) {
                     fields.push({ name: prop.getName(), value: extractExpr(init) });
+                }
+            }
+        }
+        // Desugar computed keys: { ...base, [k]: v } → base.set(k, v)
+        // No spread: { [k]: v } → {}.set(k, v) (empty map base)
+        if (computedFields.length > 0) {
+            let result = spread ?? { kind: "record", spread: null, fields: [] };
+            for (const cf of computedFields) {
+                result = { kind: "call",
+                    fn: { kind: "field", obj: result, field: "set" },
+                    args: [cf.key, cf.value] };
             }
+            return result;
         }
         return { kind: "record", spread, fields };
     }
@@ -234,8 +251,9 @@ function extractExpr(node) {
             if (name === "Map" && args && args.length === 1) {
                 const argType = args[0].getType();
                 const argSymbol = argType.getSymbol()?.getName() ?? argType.getAliasSymbol()?.getName();
-                if (argSymbol === "Map") {
-                    // new Map(existingMap) — identity (Dafny maps are value types)
+                const argTypeText = _eraseGenerics(typeToString(argType));
+                if (argSymbol === "Map" || argTypeText.startsWith("Record<")) {
+                    // new Map(existingMap) or new Map(record) — identity (Dafny maps are value types)
                     return extractExpr(args[0]);
                 }
                 // new Map(entries) — map-from-array constructor
@@ -257,6 +275,17 @@ function extractExpr(node) {
     if (Node.isAsExpression(node)) {
         return extractExpr(node.getExpression());
     }
+    // delete obj[key] → map delete expression
+    if (Node.isDeleteExpression(node)) {
+        const expr = node.getExpression();
+        if (Node.isElementAccessExpression(expr)) {
+            return {
+                kind: "call",
+                fn: { kind: "field", obj: extractExpr(expr.getExpression()), field: "delete" },
+                args: [extractExpr(expr.getArgumentExpression())],
+            };
+        }
+    }
     // null → undefined (both map to None in backends)
     if (Node.isNullLiteral(node)) {
         return { kind: "var", name: "undefined" };
@@ -511,6 +540,38 @@ function extractStmts(stmts) {
                     }
                     continue;
                 }
+                // Destructuring rest: const { [k]: _, ...rest } = map → let rest = map.delete(k)
+                if (!isHavoc && Node.isObjectBindingPattern(nameNode)) {
+                    const elements = nameNode.getElements();
+                    const restEl = elements.find(el => el.getDotDotDotToken());
+                    const computedEls = elements.filter(el => {
+                        const pn = el.getPropertyNameNode();
+                        return pn && Node.isComputedPropertyName(pn);
+                    });
+                    if (restEl && computedEls.length > 0) {
+                        const initializer = d.getInitializer();
+                        if (initializer) {
+                            let deleteInit = extractExpr(initializer);
+                            for (const cel of computedEls) {
+                                const pn = cel.getPropertyNameNode();
+                                const keyExpr = extractExpr(pn.getExpression());
+                                deleteInit = { kind: "call",
+                                    fn: { kind: "field", obj: deleteInit, field: "delete" },
+                                    args: [keyExpr] };
+                            }
+                            const declType = d.getType();
+                            result.push({
+                                kind: "let",
+                                name: restEl.getName(),
+                                mutable: s.getDeclarationKind() === "let",
+                                tsType: _eraseGenerics(typeToString(declType)),
+                                init: deleteInit,
+                                line,
+                            });
+                            continue;
+                        }
+                    }
+                }
                 const declType = d.getType();
                 let init;
                 if (isHavoc && !havocKey) {
@@ -558,7 +619,9 @@ function extractStmts(stmts) {
                 const nameNode = decl?.getNameNode();
                 if (nameNode && Node.isArrayBindingPattern(nameNode)) {
                     for (const elem of nameNode.getElements()) {
-                        if (Node.isBindingElement(elem))
+                        if (Node.isOmittedExpression(elem))
+                            names.push("_");
+                        else if (Node.isBindingElement(elem))
                             names.push(elem.getNameNode().getText());
                     }
                 }
@@ -583,6 +646,27 @@ function extractStmts(stmts) {
             });
             continue;
         }
+        // for...in: for (const k in obj) → treat as forof with single key name
+        if (Node.isForInStatement(s)) {
+            const init = s.getInitializer();
+            let name = "_";
+            if (Node.isVariableDeclarationList(init)) {
+                name = init.getDeclarations()[0]?.getName() ?? "_";
+            }
+            const bodyNode = s.getStatement();
+            const bodyStmts = Node.isBlock(bodyNode) ? bodyNode.getStatements() : [bodyNode];
+            const annots = collectAnnotations(s, bodyStmts);
+            result.push({
+                kind: "forof",
+                names: [name],
+                iterable: extractExpr(s.getExpression()),
+                invariants: annots.filter(a => a.kind === "invariant").map(a => a.expr),
+                doneWith: annots.find(a => a.kind === "done_with")?.expr ?? null,
+                body: extractStmts(bodyStmts),
+                line,
+            });
+            continue;
+        }
         if (Node.isIfStatement(s)) {
             const thenNode = s.getThenStatement();
             const elseNode = s.getElseStatement();

package/tools/dist/lsc.js

@@ -33,6 +33,12 @@ function main() {
         timeLimit = parseInt(args[timeLimitIdx].split("=")[1]);
         args.splice(timeLimitIdx, 1);
     }
+    const extraFlagsIdx = args.findIndex(a => a.startsWith("--extra-flags="));
+    let extraFlags;
+    if (extraFlagsIdx >= 0) {
+        extraFlags = args[extraFlagsIdx].split("=").slice(1).join("=");
+        args.splice(extraFlagsIdx, 1);
+    }
     const [cmd, filePath] = args;
     if (!cmd || !filePath) {
         console.error("Usage: lsc <gen|check|regen|extract> [--backend=lean|dafny] <file.ts>");
@@ -101,7 +107,7 @@ function main() {
             dafnyGen(genPath, dfyPath, text);
             if (!dafnyCheckDiff(genPath, dfyPath))
                 process.exit(1);
-            if (!dafnyVerify(dfyPath, dir, timeLimit))
+            if (!dafnyVerify(dfyPath, dir, timeLimit, extraFlags))
                 process.exit(1);
             return;
         }