lemmascript 0.4.0 → 0.5.1

package/tools/dist/info-command.js

@@ -0,0 +1,38 @@
+/**
+ * `lsc info` — emit a JSON summary of verified functions in a TS file.
+ *
+ * Pipeline: extract only (no resolve/transform/emit). Walks Raw IR for
+ * top-level functions and class methods, preserving the original `//@ `
+ * source text for clauses (no specparser round-trip).
+ *
+ * Output: `foo.ts.json` next to `foo.ts`, with shape:
+ *   { method: { sig, requires, ensures, decreases }, ... }
+ * Class methods key as `ClassName.method`.
+ */
+import { writeFileSync } from "fs";
+import { parseTsType, tyToCanonical } from "./types.js";
+function renderSig(fn) {
+    const params = fn.params.map(p => `${p.name}: ${tyToCanonical(parseTsType(p.tsType))}`).join(", ");
+    return `(${params}): ${tyToCanonical(parseTsType(fn.returnType))}`;
+}
+function fnToInfo(fn) {
+    return {
+        sig: renderSig(fn),
+        requires: fn.requires,
+        ensures: fn.ensures,
+        decreases: fn.decreases,
+    };
+}
+export function runInfo(raw, outPath) {
+    const out = {};
+    for (const fn of raw.functions) {
+        out[fn.name] = fnToInfo(fn);
+    }
+    for (const cls of raw.classes) {
+        for (const m of cls.methods) {
+            out[`${cls.name}.${m.name}`] = fnToInfo(m);
+        }
+    }
+    writeFileSync(outPath, JSON.stringify(out, null, 2) + "\n");
+    console.log(`Wrote ${outPath}`);
+}

package/tools/dist/lean-emit.js

@@ -31,6 +31,15 @@ function tyToLean(ty) {
             return inner.includes(" ") ? `Option (${inner})` : `Option ${inner}`;
         }
         case "user": return ty.name;
+        case "fn": {
+            const params = ty.params.map(p => {
+                const s = tyToLean(p);
+                return s.includes(" ") ? `(${s})` : s;
+            });
+            const ret = tyToLean(ty.result);
+            const retStr = ret.includes(" ") ? `(${ret})` : ret;
+            return [...params, retStr].join(" → ");
+        }
         case "unknown": return "_";
     }
 }
@@ -45,6 +54,10 @@ const LEAN_KEYWORDS = new Set([
     "at", "from", "to", "deriving", "extends", "true", "false",
 ]);
 function escapeName(name) {
+    // \result is carried through the IR as the var name "\\result"; render it
+    // as Lean's canonical return-value identifier (matches `return (res : T)`).
+    if (name === "\\result")
+        return "res";
     return LEAN_KEYWORDS.has(name) ? `«${name}»` : name;
 }
 // ── Operator precedence (for parenthesization) ──────────────
@@ -109,6 +122,13 @@ function emitMethodCall(tyKind, method, monadic, obj, args) {
     throw new Error(`Unsupported Lean method call: .${method}() on ${tyKind}`);
 }
 // ── Expression emission ─────────────────────────────────────
+// Lean's `∀`/`∃` body extends as far as possible. So `(∃ x, P) <op> Q`
+// (or `∃ x, P → Q`) would parse with the operator absorbed into the body.
+// Wrap a quantifier in parens to terminate its body before the operator.
+function wrapQuantifier(sub, parentPrec) {
+    const inner = emitExpr(sub, parentPrec);
+    return (sub.kind === "forall" || sub.kind === "exists") ? `(${inner})` : inner;
+}
 function emitExpr(e, parentPrec) {
     switch (e.kind) {
         case "var": return escapeName(e.name);
@@ -163,11 +183,11 @@ function emitExpr(e, parentPrec) {
                 return `${wrap ? `(${recv})` : recv}.contains ${emitExpr(e.left)}`;
             }
             const op = e.op === "arrayConcat" ? "++" : e.op;
-            const s = `${emitExpr(e.left, prec(e.op))} ${op} ${emitExpr(e.right, prec(e.op))}`;
+            const s = `${wrapQuantifier(e.left, prec(e.op))} ${op} ${emitExpr(e.right, prec(e.op))}`;
             return (parentPrec !== undefined && prec(e.op) < parentPrec) ? `(${s})` : s;
         }
         case "implies": {
-            const parts = [...e.premises.map(p => emitExpr(p)), emitExpr(e.conclusion)];
+            const parts = [...e.premises.map(p => wrapQuantifier(p)), emitExpr(e.conclusion)];
             const s = parts.join(" → ");
             return parentPrec !== undefined ? `(${s})` : s;
         }
@@ -249,6 +269,8 @@ function emitStmt(s, indent) {
             return `${pad}let mut ${escapeName(s.name)} : ${tyToLean(s.type)} := ${emitExpr(s.value)}`;
         case "ghostAssign": return `${pad}${escapeName(s.target)} := ${emitExpr(s.value)}`;
         case "assert": {
+            if (s.assumed)
+                throw new Error("//@ assume: not supported in Lean backend.");
             // WPGen.assert needs a Prop; bare Bool expressions (`k in m` → `.contains`,
             // method calls, vars) lack a matching WPGen instance and silently fall back
             // to WPGen.default, which drops the assertion. Coerce to Prop via `= true`.
@@ -399,6 +421,10 @@ function emitDecl(d) {
             throw new Error(`Lean class support not yet implemented: ${d.name}`);
         case "const":
             return `def ${escapeName(d.name)} : ${tyToLean(d.type)} := ${emitExpr(d.value)}`;
+        case "extern":
+            // Lean: emit an opaque function declaration. The user is expected to
+            // provide an axiomatic body or a stub in the companion spec file.
+            throw new Error(`Lean extern support not yet implemented: ${d.name}`);
     }
 }
 /** Emit a pure expression with indented if/match blocks. */

package/tools/dist/lsc.js

@@ -2,7 +2,7 @@
 /**
  * lsc — LemmaScript compiler CLI
  *
- * Pipeline: extract → resolve → transform → emit
+ * Pipeline: extract → resolve → narrow → transform → peephole → emit
  */
 import { Project, ScriptTarget } from "ts-morph";
 import { existsSync } from "fs";
@@ -16,6 +16,7 @@ import { emitLeanFile } from "./lean-emit.js";
 import { emitDafnyFile } from "./dafny-emit.js";
 import { dafnyGen, dafnyCheckDiff, dafnyVerify, dafnyRegen } from "./dafny-commands.js";
 import { leanGen, leanCheck } from "./lean-commands.js";
+import { runInfo } from "./info-command.js";
 function main() {
     const args = process.argv.slice(2);
     const backendIdx = args.findIndex(a => a.startsWith("--backend="));
@@ -43,7 +44,7 @@ function main() {
     }
     const [cmd, filePath] = args;
     if (!cmd || !filePath) {
-        console.error("Usage: lsc <gen|check|regen|extract> [--backend=lean|dafny] <file.ts>");
+        console.error("Usage: lsc <gen|check|regen|extract|info> [--backend=lean|dafny] <file.ts>");
         process.exit(1);
     }
     const absPath = path.resolve(filePath);
@@ -70,18 +71,27 @@ function main() {
         : new Project({ compilerOptions: { strict: true, target: ScriptTarget.ESNext, lib: ["lib.esnext.d.ts"] } });
     const sourceFile = project.addSourceFileAtPath(absPath);
     project.resolveSourceFileDependencies();
-    // Check //@ backend directive — skip if backend doesn't match
-    const backendDirective = sourceFile.getFullText().match(/\/\/@ backend (\w+)/);
-    if (backendDirective && backendDirective[1] !== backend) {
+    const fullText = sourceFile.getFullText();
+    // Check //@ backend directive — skip if backend doesn't match.
+    // `extract` and `info` are backend-neutral and always run.
+    const backendDirective = fullText.match(/\/\/@ backend (\w+)/);
+    if (cmd !== "extract" && cmd !== "info" && backendDirective && backendDirective[1] !== backend) {
         console.log(`Skipped: ${path.basename(filePath)} (//@ backend ${backendDirective[1]}, current: ${backend})`);
         return;
     }
+    // File-level directives consumed by the Dafny emitter.
+    const safeSlice = /\/\/@ safe-slice\b/.test(fullText);
     // Extract: ts-morph → Raw IR
     const raw = extractModule(sourceFile);
     if (cmd === "extract") {
         console.log(JSON.stringify(raw, null, 2));
         return;
     }
+    if (cmd === "info") {
+        const outPath = path.join(path.dirname(absPath), `${path.basename(filePath, ".ts")}.ts.json`);
+        runInfo(raw, outPath);
+        return;
+    }
     // Resolve: Raw IR → Typed IR
     const resolved = resolveModule(raw);
     // Narrow: Typed IR → Typed IR (rewrites optional-narrowing patterns to someMatch)
@@ -96,7 +106,7 @@ function main() {
         defFile = peepholeModule(defFile, "dafny");
         const allDecls = [...(typesFile?.decls ?? []), ...defFile.decls];
         const merged = { ...defFile, decls: allDecls };
-        const text = emitDafnyFile(merged, path.basename(filePath));
+        const text = emitDafnyFile(merged, path.basename(filePath), { safeSlice });
         const genPath = path.join(dir, `${base}.dfy.gen`);
         const dfyPath = path.join(dir, `${base}.dfy`);
         const basePath = path.join(dir, `${base}.dfy.base`);

package/tools/dist/narrow.js

@@ -87,14 +87,16 @@ function binderHintFor(e) {
     }
     if (cur.kind !== "var")
         return null;
-    return fields.length === 0 ? `_${cur.name}_val` : `_${cur.name}_${fields.join("_")}_val`;
+    // \result is stored as the IR var name "\\result"; sanitize for a valid identifier.
+    const root = cur.name === "\\result" ? "result" : cur.name;
+    return fields.length === 0 ? `_${root}_val` : `_${root}_${fields.join("_")}_val`;
 }
 // Aliased for code that historically called the simpler check.
 const parseSimpleOptionalCheck = parseOptionalCheck;
 // ── Walkers ──────────────────────────────────────────────────
 function walkExpr(e) {
     const r = recurseExpr(e);
-    return ruleNullish(r) ?? ruleOptChain(r) ?? ruleImplOptional(r) ?? ruleConditionalAndOptional(r) ?? ruleConditionalOptionalSimple(r) ?? ruleConditionalInMap(r) ?? ruleConditionalOptionalTruthy(r) ?? r;
+    return ruleNullish(r) ?? ruleOptChain(r) ?? ruleImplOptional(r) ?? ruleImplArrayIsArray(r) ?? ruleConditionalArrayIsArray(r) ?? ruleConditionalAndArrayIsArray(r) ?? ruleConditionalAndOptional(r) ?? ruleConditionalOptionalSimple(r) ?? ruleConditionalInMap(r) ?? ruleConditionalOptionalTruthy(r) ?? r;
 }
 function recurseExpr(e) {
     const re = walkExpr;
@@ -103,7 +105,6 @@ function recurseExpr(e) {
         case "num":
         case "str":
         case "bool":
-        case "result":
         case "havoc":
             return e;
         case "binop": return { ...e, left: re(e.left), right: re(e.right) };
@@ -132,10 +133,14 @@ function recurseExpr(e) {
 function walkStmt(s) {
     // Recurse into children first, then try rules at this node.
     const r = recurseStmt(s);
-    // && rule fires before simple rule because it produces nested ifs whose
-    // inner shape doesn't match simple rule directly. someMatch result needs
-    // no further rewriting at this level.
-    return ruleIfAndOptional(r) ?? ruleIfOptionalSimple(r) ?? r;
+    // Optional narrowing fires before Array.isArray narrowing: in a chain like
+    // `next && Array.isArray(next.content)` the optional check must unwrap `next`
+    // *outside* the array match, since `next.content` is unreachable until then.
+    // (When the chain has no leading optional, ruleIfAndOptional no-ops and the
+    // array rule fires; independent narrows commute, so the order is harmless.)
+    // && rules fire before the simple rule because they produce nested ifs whose
+    // inner shape doesn't match the simple rule directly.
+    return ruleIfAndOptional(r) ?? ruleIfAndArrayIsArray(r) ?? ruleIfOptionalSimple(r) ?? r;
 }
 function walkStmts(stmts) {
     const result = [];
@@ -307,6 +312,60 @@ function ruleConditionalOptionalSimple(e) {
         ty: e.ty,
     };
 }
+/** Rule (expression): `Array.isArray(x) ==> B` or `!Array.isArray(x) ==> B` —
+ *  premise narrowing for spec implications. Mirrors `ruleImplOptional` but for
+ *  synth array-union discriminators.
+ *  → `tagMatch x { ArrayBranch => walkExpr(B), _ => true }` (or NonArrayBranch).
+ *  The other variant becomes a vacuous-true fallthrough (the implication is
+ *  trivially satisfied when the premise is false). */
+function ruleImplArrayIsArray(e) {
+    if (e.kind !== "binop" || e.op !== "==>")
+        return null;
+    const pos = parseArrayIsArrayCall(e.left);
+    const neg = e.left.kind === "unop" && e.left.op === "!"
+        ? parseArrayIsArrayCall(e.left.expr)
+        : null;
+    const matched = pos ?? (neg ? { scrutinee: neg.scrutinee, typeName: neg.typeName, variant: "NonArrayBranch" } : null);
+    if (!matched)
+        return null;
+    return {
+        kind: "tagMatch",
+        scrutinee: matched.scrutinee,
+        typeName: matched.typeName,
+        cases: [{ variant: matched.variant, body: walkExpr(e.right) }],
+        fallthrough: { kind: "bool", value: true, ty: { kind: "bool" } },
+        ty: { kind: "bool" },
+    };
+}
+/** Rule (expression): `Array.isArray(x) ? a : b` — ternary narrowing for
+ *  synth array-unions. Mirrors `ruleImplArrayIsArray` but at the conditional
+ *  position rather than the `==>` position.
+ *  → `tagMatch x { ArrayBranch => walkExpr(a) } fallthrough walkExpr(b)`
+ *  (or NonArrayBranch when the condition is negated).
+ *  Inside the matched arm, bare references to `x` are rewritten to the
+ *  variant's payload field (e.g. `x.arr`) by `transformExpr` when emitting
+ *  the tagMatch — same mechanism `ruleImplArrayIsArray` already relies on. */
+function ruleConditionalArrayIsArray(e) {
+    if (e.kind !== "conditional")
+        return null;
+    const pos = parseArrayIsArrayCall(e.cond);
+    const neg = e.cond.kind === "unop" && e.cond.op === "!"
+        ? parseArrayIsArrayCall(e.cond.expr)
+        : null;
+    const matched = pos ?? (neg ? { scrutinee: neg.scrutinee, typeName: neg.typeName, variant: "NonArrayBranch" } : null);
+    if (!matched)
+        return null;
+    const thenBody = pos ? e.then : e.else;
+    const elseBody = pos ? e.else : e.then;
+    return {
+        kind: "tagMatch",
+        scrutinee: matched.scrutinee,
+        typeName: matched.typeName,
+        cases: [{ variant: matched.variant, body: walkExpr(thenBody) }],
+        fallthrough: walkExpr(elseBody),
+        ty: e.ty,
+    };
+}
 /** Rule (expression): `(path !== undefined [&& rest]) ==> B` — premise narrowing
  *  for spec implications (ensures/requires). The premise's optional checks
  *  bind narrowed values that the conclusion can use.
@@ -471,19 +530,29 @@ function ruleConditionalOptionalTruthy(e) {
         someBody: e.then, noneBody: e.else, ty: e.ty,
     };
 }
-/** Extract the leftmost optional check from an `&&` chain.
- *  `(x !== undefined && b) && c` → { check, restCond: b && c }. */
+/** Extract an optional check from any position in an `&&` chain.
+ *  `(x !== undefined && b) && c` → { check, restCond: b && c }.
+ *  `a && (x !== undefined)`     → { check, restCond: a }.
+ *  Conjunct order doesn't carry semantic weight, so either side is fine. */
 function extractLeftmostOptionalCheck(cond) {
     if (cond.kind !== "binop" || cond.op !== "&&")
         return null;
-    const check = parseSimpleOptionalCheck(cond.left);
-    if (check && !check.negated)
-        return { check, restCond: cond.right };
+    const leftCheck = parseSimpleOptionalCheck(cond.left);
+    if (leftCheck && !leftCheck.negated)
+        return { check: leftCheck, restCond: cond.right };
+    const rightCheck = parseSimpleOptionalCheck(cond.right);
+    if (rightCheck && !rightCheck.negated)
+        return { check: rightCheck, restCond: cond.left };
     if (cond.left.kind === "binop" && cond.left.op === "&&") {
         const inner = extractLeftmostOptionalCheck(cond.left);
         if (inner)
             return { check: inner.check, restCond: { ...cond, left: inner.restCond } };
     }
+    if (cond.right.kind === "binop" && cond.right.op === "&&") {
+        const inner = extractLeftmostOptionalCheck(cond.right);
+        if (inner)
+            return { check: inner.check, restCond: { ...cond, right: inner.restCond } };
+    }
     return null;
 }
 /** Rule: `if (x !== undefined && rest) then` (no else) where x is a pure
@@ -510,8 +579,68 @@ function ruleIfAndOptional(s) {
     };
 }
 // ── Discriminant narrowing ──────────────────────────────────
-/** Detect `x.kind === "variant"` or `'key' in x` as a positive discriminant
- *  check. Returns the scrutinee var (with its type), type name, and variant. */
+/** Detect `Array.isArray(<path>)` where `<path>` is a var or a chain of
+ *  field accesses rooted at a var, and the path's type is a synthesized
+ *  array-union (discriminant `"__isArray__"`). Returns the variant name to
+ *  narrow to. The scrutinee is whatever path the user wrote — downstream
+ *  transforms substitute it inside the matched arm. */
+function parseArrayIsArrayCall(call) {
+    if (call.kind !== "call")
+        return null;
+    if (call.fn.kind !== "field" || call.fn.field !== "isArray")
+        return null;
+    if (call.fn.obj.kind !== "var" || call.fn.obj.name !== "Array")
+        return null;
+    if (call.args.length !== 1)
+        return null;
+    const arg = call.args[0];
+    if (!isNarrowablePath(arg) || arg.ty.kind !== "user")
+        return null;
+    const baseTyName = arg.ty.name.includes("<") ? arg.ty.name.slice(0, arg.ty.name.indexOf("<")) : arg.ty.name;
+    const decl = _typeDecls.find(d => d.name === baseTyName);
+    if (decl?.kind !== "discriminated-union" || decl.discriminant !== "__isArray__")
+        return null;
+    return { scrutinee: arg, typeName: arg.ty.name, variant: "ArrayBranch" };
+}
+/** A "narrowable path" is a var or a chain of field accesses rooted at a var
+ *  — i.e., pure and structurally addressable, so transforms can substitute
+ *  occurrences inside a matched arm without worrying about re-evaluation. */
+function isNarrowablePath(e) {
+    if (e.kind === "var")
+        return true;
+    if (e.kind === "field")
+        return isNarrowablePath(e.obj);
+    return false;
+}
+/** Mirror of `extractLeftmostOptionalCheck` for synth-array-union checks:
+ *  finds `Array.isArray(path)` somewhere in a `&&` chain, returns it plus
+ *  the remaining conjunction. The check must be the positive form (negated
+ *  `!Array.isArray(...)` would narrow to the wrong variant for then-body
+ *  consumers, so we leave those to the existing untouched-conditional path). */
+function extractLeftmostArrayIsArrayCheck(cond) {
+    if (cond.kind !== "binop" || cond.op !== "&&")
+        return null;
+    const leftCheck = parseArrayIsArrayCall(cond.left);
+    if (leftCheck)
+        return { check: leftCheck, restCond: cond.right };
+    const rightCheck = parseArrayIsArrayCall(cond.right);
+    if (rightCheck)
+        return { check: rightCheck, restCond: cond.left };
+    if (cond.left.kind === "binop" && cond.left.op === "&&") {
+        const inner = extractLeftmostArrayIsArrayCheck(cond.left);
+        if (inner)
+            return { check: inner.check, restCond: { ...cond, left: inner.restCond } };
+    }
+    if (cond.right.kind === "binop" && cond.right.op === "&&") {
+        const inner = extractLeftmostArrayIsArrayCheck(cond.right);
+        if (inner)
+            return { check: inner.check, restCond: { ...cond, right: inner.restCond } };
+    }
+    return null;
+}
+/** Detect `x.kind === "variant"`, `'key' in x`, or `Array.isArray(x)` (synth
+ *  array-union) as a positive discriminant check. Returns the scrutinee var
+ *  (with its type), type name, and variant. */
 function parseDiscriminantCond(cond) {
     // Pattern: x.discriminant === "variant"
     if (cond.kind === "binop" && cond.op === "===" && cond.right.kind === "str" &&
@@ -534,15 +663,35 @@ function parseDiscriminantCond(cond) {
             }
         }
     }
+    // Pattern: Array.isArray(x) — narrows x to the ArrayBranch variant of a
+    // synthesized array-union (discriminant "__isArray__"). Statement-level
+    // discriminant chains (`if (Array.isArray(x)) {...} else if (...)`) still
+    // require a bare-var scrutinee since the existing var-name-keyed
+    // replacement machinery in transform.ts only handles that shape; path
+    // scrutinees (e.g. `m.content`) are handled exclusively by
+    // `ruleConditionalArrayIsArray` and the expression-form tagMatch path.
+    const arrCheck = parseArrayIsArrayCall(cond);
+    if (arrCheck && arrCheck.scrutinee.kind === "var") {
+        return { scrutinee: arrCheck.scrutinee, typeName: arrCheck.typeName, variant: arrCheck.variant };
+    }
     return null;
 }
-/** Detect `x.kind !== "variant"` (negative discriminant check). */
+/** Detect `x.kind !== "variant"` (negative discriminant check) or
+ *  `!Array.isArray(x)` (synth array-union, narrows to NonArrayBranch). */
 function parseNegativeDiscriminantCond(cond) {
     if (cond.kind === "binop" && cond.op === "!==" && cond.right.kind === "str" &&
         cond.left.kind === "field" && cond.left.isDiscriminant &&
         cond.left.obj.kind === "var" && cond.left.obj.ty.kind === "user") {
         return { scrutinee: cond.left.obj, typeName: cond.left.obj.ty.name, variant: cond.right.value };
     }
+    // Pattern: !Array.isArray(x) — narrows x to the NonArrayBranch variant.
+    // Same var-scrutinee restriction as parseDiscriminantCond.
+    if (cond.kind === "unop" && cond.op === "!") {
+        const arrCheck = parseArrayIsArrayCall(cond.expr);
+        if (arrCheck && arrCheck.scrutinee.kind === "var") {
+            return { scrutinee: arrCheck.scrutinee, typeName: arrCheck.typeName, variant: "NonArrayBranch" };
+        }
+    }
     return null;
 }
 function isTerminating(stmts) {
@@ -657,7 +806,6 @@ function containsMethodCall(e) {
         case "num":
         case "str":
         case "bool":
-        case "result":
         case "havoc":
             return false;
         case "binop": return containsMethodCall(e.left) || containsMethodCall(e.right);
@@ -712,6 +860,53 @@ function ruleConditionalAndOptional(e) {
         someBody: walkExpr(innerCond), noneBody: e.else, ty: e.ty,
     };
 }
+/** Rule (statement): `if (<rest> && Array.isArray(path) && <more>) then [else]`
+ *  → `tagMatch path { ArrayBranch => if (<rest && more>) then [else] }`.
+ *  The remaining conjuncts move inside the matched arm so any narrowing the
+ *  `then` body relies on (typed `path` accesses) sees the unwrapped variant.
+ *  Mirrors `ruleIfAndOptional` but for synth array-unions. */
+function ruleIfAndArrayIsArray(s) {
+    if (s.kind !== "if")
+        return null;
+    const extracted = extractLeftmostArrayIsArrayCheck(s.cond);
+    if (!extracted)
+        return null;
+    const { check, restCond } = extracted;
+    // Inner if uses the remaining conjunction (or just the then-body if rest is
+    // a tautology — but in practice extractLeftmost leaves at least one other
+    // conjunct). Walk recursively so nested checks compose.
+    const innerThen = [{ kind: "if", cond: restCond, then: s.then, else: s.else }];
+    return {
+        kind: "tagMatch",
+        scrutinee: check.scrutinee,
+        typeName: check.typeName,
+        cases: [{ variant: check.variant, body: innerThen.map(walkStmt) }],
+        fallthrough: s.else,
+    };
+}
+/** Rule (expression): `(<rest> && Array.isArray(path)) ? a : b`
+ *  → `tagMatch path { ArrayBranch => (<rest>) ? a : b } fallthrough b`.
+ *  Mirrors `ruleConditionalAndOptional`. */
+function ruleConditionalAndArrayIsArray(e) {
+    if (e.kind !== "conditional")
+        return null;
+    const extracted = extractLeftmostArrayIsArrayCheck(e.cond);
+    if (!extracted)
+        return null;
+    const { check, restCond } = extracted;
+    const innerCond = {
+        kind: "conditional",
+        cond: restCond, then: e.then, else: e.else, ty: e.ty,
+    };
+    return {
+        kind: "tagMatch",
+        scrutinee: check.scrutinee,
+        typeName: check.typeName,
+        cases: [{ variant: check.variant, body: walkExpr(innerCond) }],
+        fallthrough: e.else,
+        ty: e.ty,
+    };
+}
 // ── Function / module entry ──────────────────────────────────
 function narrowFunction(fn) {
     return {

package/tools/dist/peephole.js

@@ -12,7 +12,8 @@ function mapExpr(e, f) {
         case "constructor":
         case "emptyMap":
         case "emptySet":
-        case "havoc": return e;
+        case "havoc":
+        case "mapLiteral": return e;
         case "binop": return { ...e, left: r(e.left), right: r(e.right) };
         case "unop": return { ...e, expr: r(e.expr) };
         case "implies": return { ...e, premises: e.premises.map(r), conclusion: r(e.conclusion) };
@@ -355,7 +356,8 @@ function rewriteChildrenExpr(e) {
         case "constructor":
         case "emptyMap":
         case "emptySet":
-        case "havoc": return e;
+        case "havoc":
+        case "mapLiteral": return e;
         case "binop": return { ...e, left: r(e.left), right: r(e.right) };
         case "unop": return { ...e, expr: r(e.expr) };
         case "implies": return { ...e, premises: e.premises.map(r), conclusion: r(e.conclusion) };
@@ -443,6 +445,7 @@ function peepholeDecl(d) {
         case "inductive":
         case "structure":
         case "type-alias":
+        case "extern":
             return d;
     }
 }