lemmascript 0.4.0 → 0.5.0

package/tools/dist/transform.js

@@ -24,6 +24,7 @@ function mapExpr(e, f) {
         case "emptyMap":
         case "emptySet":
         case "havoc": return e;
+        case "mapLiteral": return { ...e, entries: e.entries.map(en => ({ key: r(en.key), value: r(en.value) })) };
         case "constructor": return e.args ? { ...e, args: e.args.map(r) } : e;
         case "binop": return { ...e, left: r(e.left), right: r(e.right) };
         case "unop": return { ...e, expr: r(e.expr) };
@@ -80,7 +81,6 @@ function mapTExpr(e, f) {
         case "num":
         case "str":
         case "bool":
-        case "result":
         case "havoc": return e;
         case "binop": return { ...e, left: r(e.left), right: r(e.right) };
         case "unop": return { ...e, expr: r(e.expr) };
@@ -187,6 +187,40 @@ const BOOL_OP_MAP = {
     ...OP_MAP, "===": "==", "!==": "!=",
 };
 function transformExpr(e) { return lowerExpr(e, null); }
+/** Reduce an if/let/return-shaped statement body to a single expression, for
+ *  expression-only lambda bodies. Returns null for shapes that can't be a pure
+ *  expression (loops, assignments, bare side effects), so callers leave the
+ *  body as statements. A `return` is terminal — statements after it are
+ *  unreachable and dropped.
+ *    [return e]                          → e
+ *    [let x = e, …rest]                  → Expr.let(x, e, flatten(rest))
+ *    [if (c) thenStmts elseStmts, …rest] → Expr.if(c, …) where each branch
+ *        absorbs `rest` if it doesn't already terminate with a return. */
+function flattenLambdaBody(stmts) {
+    if (stmts.length === 0)
+        return null;
+    const first = stmts[0];
+    const rest = stmts.slice(1);
+    if (first.kind === "return")
+        return first.value;
+    if (first.kind === "let" && !first.mutable) {
+        const body = flattenLambdaBody(rest);
+        return body === null ? null : { kind: "let", name: first.name, value: first.value, body };
+    }
+    if (first.kind === "if") {
+        const thenTerminates = flattenLambdaBody(first.then);
+        if (thenTerminates !== null) {
+            // then-branch yields a value (ends in return) → `rest` is the else path.
+            const elseExpr = flattenLambdaBody(first.else.length > 0 ? [...first.else, ...rest] : rest);
+            return elseExpr === null ? null : { kind: "if", cond: first.cond, then: thenTerminates, else: elseExpr };
+        }
+        // then-branch falls through → both branches continue into `rest`.
+        const thenExpr = flattenLambdaBody([...first.then, ...rest]);
+        const elseExpr = flattenLambdaBody(first.else.length > 0 ? [...first.else, ...rest] : rest);
+        return thenExpr === null || elseExpr === null ? null : { kind: "if", cond: first.cond, then: thenExpr, else: elseExpr };
+    }
+    return null;
+}
 /**
  * Lower a typed expression to Backend IR.
  *
@@ -196,6 +230,18 @@ function transformExpr(e) { return lowerExpr(e, null); }
  * a method call can appear inline in TS.  It does NOT propagate into
  * field, index, record, forall, or exists sub-expressions.
  */
+/** JS truthiness coercion for `if`/`while`/`?:` conditions.
+ *  Dafny requires bool; TS treats number/string/array as truthy when non-empty.
+ *  Optional conds are handled separately by narrow.ts (rewritten to someMatch). */
+function coerceCondToBool(cond, ty) {
+    if (ty.kind === "bool")
+        return cond;
+    if (ty.kind === "int" || ty.kind === "nat")
+        return { kind: "binop", op: ">", left: cond, right: { kind: "num", value: 0 } };
+    if (ty.kind === "string" || ty.kind === "array")
+        return { kind: "binop", op: ">", left: { kind: "field", obj: cond, field: "size" }, right: { kind: "num", value: 0 } };
+    return cond;
+}
 /** Wrap an expression in Some/None for optional-typed conditionals.
  *  If the raw TExpr is `undefined`, emit `.none`; otherwise wrap in `Some`. */
 function wrapOptionalBranch(expr, raw) {
@@ -225,7 +271,6 @@ function lowerExpr(e, binds) {
         case "var": return { kind: "var", name: e.name };
         case "num": return { kind: "num", value: e.value };
         case "bool": return { kind: "bool", value: e.value };
-        case "result": return { kind: "var", name: "res" };
         case "str":
             if (e.ty.kind === "user")
                 return { kind: "constructor", name: e.value, type: e.ty.name };
@@ -336,10 +381,27 @@ function lowerExpr(e, binds) {
                 (e.left.ty.kind === "user" && e.right.ty.kind === "string"))) {
                 const left = lowerExpr(e.left, binds);
                 const right = lowerExpr(e.right, binds);
+                // `s || undefined` produces `Option<string>` — wrap the truthy branch in Some.
+                const rightIsUndef = e.right.kind === "var" && e.right.name === "undefined";
                 return {
                     kind: "if",
                     cond: { kind: "binop", op: ">", left: { kind: "field", obj: left, field: "size" }, right: { kind: "num", value: 0 } },
-                    then: left, else: right,
+                    then: rightIsUndef ? { kind: "app", fn: "Some", args: [left] } : left,
+                    else: right,
+                };
+            }
+            // `bool || undefined` → `if bool then Some(bool) else None`. Used in
+            // optional-field initialization where the source assigns a truthy/false
+            // bool to a `T?` field. Without this, emit produces `bool || None`,
+            // which Dafny rejects (bool || Option<?> is ill-typed).
+            if (e.op === "||" && e.left.ty.kind === "bool" &&
+                e.right.kind === "var" && e.right.name === "undefined") {
+                const left = lowerExpr(e.left, binds);
+                return {
+                    kind: "if",
+                    cond: left,
+                    then: { kind: "app", fn: "Some", args: [left] },
+                    else: { kind: "var", name: "undefined" },
                 };
             }
             // int + string → NatToString(int) + string (string concatenation)
@@ -397,6 +459,25 @@ function lowerExpr(e, binds) {
             return { kind: "index", arr: transformExpr(e.obj), idx: wrappedIdx };
         }
         case "call": {
+            // Array.isArray(x) on a synth array-union (discriminant "__isArray__")
+            // → constructor predicate `x.ArrayBranch?`. Used in spec ensures and
+            // anywhere `Array.isArray` escapes the narrowing rule (narrow rewrites
+            // top-level if-cond Array.isArray uses; this catches the rest).
+            if (e.fn.kind === "field" && e.fn.obj.kind === "var" && e.fn.obj.name === "Array" &&
+                e.fn.field === "isArray" && e.args.length === 1) {
+                const arg = e.args[0];
+                if (arg.ty.kind === "user") {
+                    const baseName = arg.ty.name.includes("<") ? arg.ty.name.slice(0, arg.ty.name.indexOf("<")) : arg.ty.name;
+                    const decl = _typeDecls.find(d => d.name === baseName);
+                    if (decl?.kind === "discriminated-union" && decl.discriminant === "__isArray__") {
+                        return {
+                            kind: "binop", op: "=",
+                            left: lowerExpr(arg, binds),
+                            right: { kind: "constructor", name: "ArrayBranch", type: arg.ty.name },
+                        };
+                    }
+                }
+            }
             // Math.abs/min/max → preamble functions
             if (e.fn.kind === "field" && e.fn.obj.kind === "var" && e.fn.obj.name === "Math") {
                 if (e.fn.field === "abs" && e.args.length === 1)
@@ -536,6 +617,19 @@ function lowerExpr(e, binds) {
             if (e.fields.length === 0 && !e.spread && e.ty.kind === "map") {
                 return { kind: "emptyMap" };
             }
+            // Non-empty record literal with map type — emit as a flat Dafny map
+            // literal `map[k1 := v1, k2 := v2, ...]`. (A chain of `m["k" := v]`
+            // works for a handful of entries but Dafny's type resolver stack-
+            // overflows on hundreds; the flat form is fine at any size.)
+            if (e.fields.length > 0 && !e.spread && e.ty.kind === "map") {
+                return {
+                    kind: "mapLiteral",
+                    entries: e.fields.map(f => ({
+                        key: { kind: "str", value: f.name },
+                        value: lowerExpr(f.value, binds),
+                    })),
+                };
+            }
             return { kind: "record", spread: null, fields: e.fields.map(f => ({ name: f.name, value: lowerExpr(f.value, binds) })) };
         }
         case "arrayLiteral":
@@ -547,14 +641,29 @@ function lowerExpr(e, binds) {
             if (e.ty.kind === "set")
                 return { kind: "app", fn: "SetLiteral", args: e.elems.map(el => lowerExpr(el, binds)) };
             return { kind: "arrayLiteral", elems: e.elems.map(el => lowerExpr(el, binds)) };
-        case "lambda":
-            return { kind: "lambda", params: e.params.map(p => ({ name: p.name, type: p.ty })), body: transformStmts(e.body, []) };
+        case "lambda": {
+            const body = transformStmts(e.body, []);
+            // Flatten an if/let/return-shaped multi-statement body into a single
+            // `return <expr>` so both backends' single-return-lambda fast path emits
+            // it (Dafny lambdas are expression-only; Lean prefers the expression form
+            // over a `do` block). Bodies with shapes we can't reduce (loops, bare
+            // side effects) are left as-is.
+            const flat = flattenLambdaBody(body);
+            return {
+                kind: "lambda",
+                params: e.params.map(p => ({ name: p.name, type: p.ty })),
+                body: flat === null ? body : [{ kind: "return", value: flat }],
+            };
+        }
         case "forall":
             return { kind: "forall", var: e.var, type: e.varTy, body: transformExpr(e.body) };
         case "exists":
             return { kind: "exists", var: e.var, type: e.varTy, body: transformExpr(e.body) };
         case "conditional": {
-            const cond = lowerExpr(e.cond, binds);
+            // JS truthiness coercion (string/array/int → ... > 0).  Matches SPEC §3.1
+            // negation forms (`!s` → `s == ""`).  Optional conds are already
+            // rewritten to someMatch by narrow.ts.
+            const cond = coerceCondToBool(lowerExpr(e.cond, binds), e.cond.ty);
             let thenExpr = lowerExpr(e.then, binds);
             let elseExpr = lowerExpr(e.else, binds);
             if (e.ty.kind === "optional") {
@@ -586,7 +695,11 @@ function lowerExpr(e, binds) {
                 // path with the binder pre-lowering.
                 const replaced = replacePathInTExpr(e.someBody, path, e.binder, e.binderTy);
                 someBody = lowerExpr(replaced, binds);
-                scrutinee = path.fields.length === 0 ? path.rootVar : lowerExpr(e.scrutinee, binds);
+                // Bare-var shortcut, but route \result through lowerExpr so the
+                // lemma-side replaceVar pass can substitute it with the function call.
+                scrutinee = path.fields.length === 0 && path.rootVar !== "\\result"
+                    ? path.rootVar
+                    : lowerExpr(e.scrutinee, binds);
             }
             else {
                 // Complex scrutinee — narrow pre-bound the someBody to use the binder directly,
@@ -607,11 +720,48 @@ function lowerExpr(e, binds) {
                 ],
             };
         }
-        case "tagMatch":
-            // Spec/expr-position tagMatch — narrow shouldn't produce these (it only
-            // emits stmt-form tagMatch from if-chain detection on stmts). If reached,
-            // bug in narrow.
-            throw new Error(`tagMatch reached lowerExpr — narrow only emits stmt-form tagMatch`);
+        case "tagMatch": {
+            // Expression-form tagMatch — emitted by `ruleImplArrayIsArray` for spec
+            // implications like `Array.isArray(x) ==> B` and by
+            // `ruleConditionalArrayIsArray` for ternary narrowing. Substitutes
+            // scrutinee field accesses and (for synth array-unions) scrutinee
+            // path occurrences inside each arm with the variant's payload binder.
+            // Path scrutinees (e.g. `m.content`) get a synthesized hint derived
+            // from the last field/var name so the binder reads naturally.
+            const scrutinee = lowerExpr(e.scrutinee, binds);
+            const decl = _typeDecls.find(d => d.name === e.typeName);
+            const isSynthArrayUnion = decl?.discriminant === "__isArray__";
+            const varName = e.scrutinee.kind === "var" ? e.scrutinee.name : undefined;
+            const pathHint = varName ?? scrutineeHint(e.scrutinee);
+            const wrapOpt = e.ty.kind === "optional";
+            const arms = e.cases.map(c => {
+                const variant = decl?.variants?.find(v => v.name === c.variant);
+                const fields = variant?.fields ?? [];
+                let body = lowerExpr(c.body, binds);
+                if (varName && fields.length > 0) {
+                    body = replaceFieldAccess(body, varName, fields);
+                    if (isSynthArrayUnion && fields.length === 1) {
+                        body = replaceVarInExpr(body, varName, matchBinder(fields[0].name, varName));
+                    }
+                }
+                else if (!varName && isSynthArrayUnion && fields.length === 1) {
+                    // Path scrutinee (e.g. `m.content`): replace structural occurrences
+                    // with the binder var ref.
+                    const binderName = matchBinder(fields[0].name, pathHint);
+                    body = replaceExprInExpr(body, scrutinee, { kind: "var", name: binderName });
+                }
+                if (wrapOpt)
+                    body = wrapOptionalBranch(body, c.body);
+                return { pattern: buildMatchPattern(c.variant, fields, pathHint), body };
+            });
+            if (e.fallthrough) {
+                let body = lowerExpr(e.fallthrough, binds);
+                if (wrapOpt)
+                    body = wrapOptionalBranch(body, e.fallthrough);
+                arms.push({ pattern: "_", body });
+            }
+            return { kind: "match", scrutinee: varName ?? scrutinee, arms };
+        }
     }
 }
 function flattenImpl(e) {
@@ -665,7 +815,119 @@ function replaceFieldAccess(e, varName, fields) {
         return null;
     });
 }
+/** Replace bare `var(oldName)` references → `var(newName)` in lowered IR.
+ *  Used inside synth array-union match arms: the user code refers to the
+ *  scrutinee by its bare name (`content`), but in the arm body that name
+ *  must refer to the variant's sole payload binder (`i_content_arr`). */
+function replaceVarInExpr(e, oldName, newName) {
+    return mapExpr(e, x => {
+        if (x.kind === "var" && x.name === oldName)
+            return { kind: "var", name: newName };
+        // If a binding shadows the name, stop substituting inside its body.
+        if (x.kind === "let" && x.name === oldName)
+            return { ...x, value: replaceVarInExpr(x.value, oldName, newName) };
+        return null;
+    });
+}
+/** Structural equality on Expr access-paths (var / field chain). Enough to
+ *  match the scrutinee `m.content` against later occurrences in a match arm. */
+function exprPathEqual(a, b) {
+    if (a.kind !== b.kind)
+        return false;
+    if (a.kind === "var" && b.kind === "var")
+        return a.name === b.name;
+    if (a.kind === "field" && b.kind === "field")
+        return a.field === b.field && exprPathEqual(a.obj, b.obj);
+    return false;
+}
+/** Substitute every occurrence of `target` (an access-path Expr) with `repl`
+ *  inside `e`. Mirror of `replaceVarInExpr` but keyed on a sub-path rather
+ *  than a bare name — needed when the narrowing scrutinee is `m.content`
+ *  (field access) rather than a bare `content` (var). */
+function replaceExprInExpr(e, target, repl) {
+    return mapExpr(e, x => {
+        if (exprPathEqual(x, target))
+            return repl;
+        return null;
+    });
+}
+/** Extract a short reader-friendly hint for a TExpr access-path: the last
+ *  field name in a field chain, or the var name. Used to derive a stable
+ *  binder prefix when the scrutinee isn't a bare var. */
+function scrutineeHint(e) {
+    if (e.kind === "var")
+        return e.name;
+    if (e.kind === "field")
+        return e.field;
+    return "x";
+}
 // ── Transform statements ─────────────────────────────────────
+// `if (X) continue; rest` → `if (!X) { rest }` at the top of a loop body.
+// Dafny's lowered while-loops have the index increment at the bottom, so a
+// `continue` would skip it and loop forever; rewriting to if/else lets the
+// loop fall through normally.
+function negateExpr(e) {
+    if (e.kind === "unop" && e.op === "!")
+        return e.expr;
+    return { kind: "unop", op: "!", expr: e };
+}
+/** Build the two pieces of an `arr.pop()` lowering on a named array variable:
+ *  - `optValue` is `(if |arr|>0 then Some(arr[|arr|-1]) else None)` (the popped element)
+ *  - `guardedTrunc` is `(if |arr|>0 then arr[..|arr|-1] else arr)` (the array minus its last element)
+ *  Callers wrap these in let/assign statements appropriate to their context. */
+function buildPopLowering(arrName, arrTy) {
+    const arrVar = { kind: "var", name: arrName };
+    const arrLen = { kind: "field", obj: arrVar, field: "size" };
+    const lastIdx = { kind: "binop", op: "-", left: arrLen, right: { kind: "num", value: 1 } };
+    const lastElem = { kind: "index", arr: arrVar, idx: lastIdx };
+    const isNonEmpty = { kind: "binop", op: ">", left: arrLen, right: { kind: "num", value: 0 } };
+    const optValue = { kind: "if", cond: isNonEmpty,
+        then: { kind: "app", fn: "Some", args: [lastElem] },
+        else: { kind: "var", name: "undefined" } };
+    const truncated = { kind: "methodCall", obj: arrVar, objTy: arrTy, method: "slice",
+        args: [{ kind: "num", value: 0 }, lastIdx], monadic: false };
+    const guardedTrunc = { kind: "if", cond: isNonEmpty, then: truncated, else: arrVar };
+    return { optValue, guardedTrunc };
+}
+function eliminateTopLevelContinue(stmts) {
+    const out = [];
+    for (let i = 0; i < stmts.length; i++) {
+        const s = stmts[i];
+        // `if (X) {...A, continue}; rest` (empty else, trailing continue in then)
+        // — if A is empty, rewrite to `if (!X) { rest }`; otherwise rewrite to
+        // `if (X) { ...A } else { rest }`. Either form lets the loop fall through
+        // naturally past the bottom of the body.
+        if (s.kind === "if" && s.else.length === 0 &&
+            s.then.length >= 1 && s.then[s.then.length - 1].kind === "continue") {
+            const rest = eliminateTopLevelContinue(stmts.slice(i + 1));
+            const thenWithoutContinue = s.then.slice(0, -1);
+            if (thenWithoutContinue.length === 0) {
+                out.push({ kind: "if", cond: negateExpr(s.cond), then: rest, else: [] });
+            }
+            else {
+                out.push({ kind: "if", cond: s.cond, then: thenWithoutContinue, else: rest });
+            }
+            return out;
+        }
+        // narrow.ts's ruleEarlyReturnConsume rewrites `if (!x) continue; rest`
+        // (when x is Optional) to a someMatch which transform.ts then emits as a
+        // `match`. A trailing `continue` inside a match arm is a no-op when the
+        // match is the last statement in the loop body — drop it.
+        if (s.kind === "match" && i === stmts.length - 1) {
+            const arms = s.arms.map(arm => {
+                const b = arm.body;
+                if (b.length > 0 && b[b.length - 1].kind === "continue") {
+                    return { ...arm, body: b.slice(0, -1) };
+                }
+                return arm;
+            });
+            out.push({ ...s, arms });
+            continue;
+        }
+        out.push(s);
+    }
+    return out;
+}
 function transformStmts(stmts, typeDecls) {
     const result = [];
     let i = 0;
@@ -690,7 +952,7 @@ function transformStmts(stmts, typeDecls) {
                 const idxName = `_${keyName}_idx${suffix}`;
                 const idx = { kind: "var", name: idxName };
                 const arrSize = { kind: "field", obj: keysVar, field: "size" };
-                const bodyStmts = transformStmts(s.body, typeDecls);
+                const bodyStmts = eliminateTopLevelContinue(transformStmts(s.body, typeDecls));
                 const letKey = { kind: "let", name: keyName, type: keyTy, mutable: false, value: { kind: "index", arr: keysVar, idx } };
                 const boundInv = { kind: "binop", op: "≤", left: idx, right: arrSize };
                 result.push({
@@ -716,7 +978,7 @@ function transformStmts(stmts, typeDecls) {
                 const idxName = `_${keyName}_idx${suffix}`;
                 const idx = { kind: "var", name: idxName };
                 const arrSize = { kind: "field", obj: keysVar, field: "size" };
-                const bodyStmts = transformStmts(s.body, typeDecls);
+                const bodyStmts = eliminateTopLevelContinue(transformStmts(s.body, typeDecls));
                 const letKey = { kind: "let", name: keyName, type: keyTy, mutable: false, value: { kind: "index", arr: keysVar, idx } };
                 const letVal = { kind: "let", name: valueName, type: valueTy, mutable: false,
                     value: { kind: "methodCall", obj: iterExpr, objTy: s.iterable.ty, method: "getDirect", args: [{ kind: "var", name: keyName }], monadic: false } };
@@ -743,7 +1005,7 @@ function transformStmts(stmts, typeDecls) {
             const idxName = `_${varName}_idx${suffix}`;
             const idx = { kind: "var", name: idxName };
             const arrSize = { kind: "field", obj: iterExpr, field: "size" };
-            const bodyStmts = transformStmts(s.body, typeDecls);
+            const bodyStmts = eliminateTopLevelContinue(transformStmts(s.body, typeDecls));
             const letElem = { kind: "let", name: varName, type: varTy, mutable: false, value: { kind: "index", arr: iterExpr, idx } };
             // Auto-add bound invariant: idx ≤ bound (always true for range loops)
             const boundInv = { kind: "binop", op: "≤", left: idx, right: arrSize };
@@ -788,6 +1050,17 @@ function transformStmt(s, typeDecls) {
                     return [letHead, sliceTail];
                 }
             }
+            // let x = arr.pop() → let x: T? = (Option-expr); arr := (truncated-or-self)
+            if (init && init.fn.kind === "field" && init.fn.field === "pop" && init.fn.obj.ty.kind === "array") {
+                const arrName = init.fn.obj.kind === "var" ? init.fn.obj.name : undefined;
+                if (arrName) {
+                    const { optValue, guardedTrunc } = buildPopLowering(arrName, init.fn.obj.ty);
+                    return [
+                        { kind: "let", name: s.name, type: s.ty, mutable: s.mutable, value: optValue },
+                        { kind: "assign", target: arrName, value: guardedTrunc },
+                    ];
+                }
+            }
             // new Map(arr.map(n => [n.field, n])) → let m = map[]; for (n of arr) m[n.field] := n
             if (init && init.fn.kind === "var" && init.fn.name === "__mapFromArray" &&
                 init.args.length === 1 && init.args[0].kind === "call" &&
@@ -838,6 +1111,17 @@ function transformStmt(s, typeDecls) {
             return [...binds, { kind: "let", name: s.name, type: s.ty, mutable: s.mutable, value: expr }];
         }
         case "assign": {
+            // x = arr.pop() → x := (Option-expr); arr := (truncated-or-self)
+            if (s.value.kind === "call" && s.value.fn.kind === "field" &&
+                s.value.fn.field === "pop" && s.value.fn.obj.ty.kind === "array" &&
+                s.value.fn.obj.kind === "var") {
+                const arrName = s.value.fn.obj.name;
+                const { optValue, guardedTrunc } = buildPopLowering(arrName, s.value.fn.obj.ty);
+                return [
+                    { kind: "assign", target: s.target, value: optValue },
+                    { kind: "assign", target: arrName, value: guardedTrunc },
+                ];
+            }
             // Top-level method call → direct monadic bind, no lifting needed
             if (s.value.kind === "call" && s.value.callKind === "method")
                 return [{ kind: "bind", target: s.target, value: transformExpr(s.value) }];
@@ -892,16 +1176,16 @@ function transformStmt(s, typeDecls) {
         case "if": {
             // Lift from condition only (Lean rule: don't lift from branches).
             const { binds, expr: cond } = liftMethodCalls(s.cond);
-            return [...binds, { kind: "if", cond, then: transformStmts(s.then, typeDecls), else: transformStmts(s.else, typeDecls) }];
+            return [...binds, { kind: "if", cond: coerceCondToBool(cond, s.cond.ty), then: transformStmts(s.then, typeDecls), else: transformStmts(s.else, typeDecls) }];
         }
         case "while":
             return [{
                     kind: "while",
-                    cond: transformExpr(s.cond),
+                    cond: coerceCondToBool(transformExpr(s.cond), s.cond.ty),
                     invariants: s.invariants.map(transformExpr),
                     decreasing: s.decreases ? transformExpr(s.decreases) : null,
                     doneWith: s.doneWith ? transformExpr(s.doneWith) : null,
-                    body: transformStmts(s.body, typeDecls),
+                    body: eliminateTopLevelContinue(transformStmts(s.body, typeDecls)),
                 }];
         case "throw":
             return [{ kind: "assert", expr: { kind: "bool", value: false } }];
@@ -914,7 +1198,7 @@ function transformStmt(s, typeDecls) {
         case "ghostAssign":
             return [{ kind: "ghostAssign", target: s.target, value: transformExpr(s.value) }];
         case "assert":
-            return [{ kind: "assert", expr: transformExpr(s.expr) }];
+            return [{ kind: "assert", expr: transformExpr(s.expr), assumed: s.assumed }];
         case "someMatch": {
             const path = asTAccessPath(s.scrutinee);
             if (path) {
@@ -932,11 +1216,8 @@ function transformStmt(s, typeDecls) {
             }
             throw new Error(`someMatch stmt scrutinee must be a pure access path, got ${s.scrutinee.kind}`);
         }
-        case "tagMatch": {
-            const varName = s.scrutinee.kind === "var" ? s.scrutinee.name : "?";
-            const chain = { varName, typeName: s.typeName, cases: s.cases, fallthrough: s.fallthrough };
-            return [emitMatchStmt(chain, typeDecls)];
-        }
+        case "tagMatch":
+            return [emitMatchStmt(s.scrutinee, s.typeName, s.cases, s.fallthrough, typeDecls)];
     }
 }
 /** Apply an expression transform to all expressions in a statement (convenience wrapper). */
@@ -961,30 +1242,80 @@ function buildMatchArms(cases, varName, typeName, typeDecls, transformBody) {
     }
     return arms;
 }
-function emitMatchStmt(chain, typeDecls) {
-    const cases = chain.cases.map(c => ({ name: c.variant, body: c.body }));
-    const arms = buildMatchArms(cases, chain.varName, chain.typeName, typeDecls, (body, vn, fields) => transformStmts(replaceFieldAccessInTStmts(body, vn, fields), typeDecls));
-    if (chain.fallthrough.length > 0) {
-        const remaining = remainingVariant(chain, typeDecls);
+function emitMatchStmt(scrutinee, typeName, cases, fallthrough, typeDecls) {
+    const decl = typeDecls.find(d => d.name === typeName);
+    // Synth array-unions (discriminant "__isArray__") have single-field variants
+    // ArrayBranch(arr) / NonArrayBranch(val). The matched arm refers to the
+    // scrutinee by its bare name/path (`content`, `m.content`), not `.arr`, so
+    // we substitute that whole reference with the variant's sole field binder.
+    const isSynthArrayUnion = decl?.discriminant === "__isArray__";
+    // The scrutinee is a bare var (`current`) or a field-access path
+    // (`current.content`). `prefix` names the binder scope — the var name, or a
+    // safe id derived from the path (`current.content` → `current_content`) —
+    // and is used for both pattern binders and arm-body substitution so they
+    // always agree. A var scrutinee has empty `fields`, so `prefix` is just its
+    // name and the emitted code is unchanged from before this generalization.
+    const path = asTAccessPath(scrutinee);
+    const isPath = !!path && path.fields.length > 0;
+    const prefix = path ? [path.rootVar, ...path.fields].join("_") : "?";
+    function transformArmBody(body, fields) {
+        let stmts;
+        if (isPath && path) {
+            // Path scrutinee: the matched value is referred to by the bare path, so
+            // substitute the whole path (only the synth single-field shape arises
+            // here — discriminant chains require a var scrutinee).
+            stmts = isSynthArrayUnion && fields.length === 1
+                ? replacePathInTStmts(body, path, matchBinder(fields[0].name, prefix), fields[0].type ?? parseTsType(fields[0].tsType))
+                : body;
+        }
+        else {
+            stmts = replaceFieldAccessInTStmts(body, prefix, fields);
+            if (isSynthArrayUnion && fields.length === 1) {
+                const f = fields[0];
+                stmts = replaceVarInTStmts(stmts, prefix, matchBinder(f.name, prefix), f.type ?? parseTsType(f.tsType));
+            }
+        }
+        return transformStmts(stmts, typeDecls);
+    }
+    const armCases = cases.map(c => ({ name: c.variant, body: c.body }));
+    const arms = buildMatchArms(armCases, prefix, typeName, typeDecls, (body, _vn, fields) => transformArmBody(body, fields));
+    // Add the fallthrough arm whenever the listed cases don't cover every
+    // variant — needed for exhaustiveness even when there's no `else`
+    // (`fallthrough` empty), e.g. `if (Array.isArray(x)) {...}` with no else
+    // becomes `match x { case ArrayBranch(..) => ... case NonArrayBranch(..) => }`.
+    const allCovered = !!decl?.variants && cases.length >= decl.variants.length;
+    if (!allCovered) {
+        const remaining = remainingVariant(typeName, cases, typeDecls);
         if (remaining) {
             // Exactly one variant left — destructure so the fallthrough body can
             // access variant-specific fields (Lean requires this; Dafny tolerates `_`).
-            const pattern = buildMatchPattern(remaining.name, remaining.fields, chain.varName);
-            const body = transformStmts(replaceFieldAccessInTStmts(chain.fallthrough, chain.varName, remaining.fields), typeDecls);
+            const pattern = buildMatchPattern(remaining.name, remaining.fields, prefix);
+            const body = transformArmBody(fallthrough, remaining.fields);
             arms.push({ pattern, body });
         }
         else {
-            arms.push({ pattern: "_", body: transformStmts(chain.fallthrough, typeDecls) });
+            arms.push({ pattern: "_", body: transformStmts(fallthrough, typeDecls) });
         }
     }
-    return { kind: "match", scrutinee: chain.varName, arms };
+    return { kind: "match", scrutinee: isPath ? transformExpr(scrutinee) : prefix, arms };
+}
+/** Replace bare `var(oldName)` references → `var(newName)` with the given type.
+ *  Used by emitMatchStmt for synth array-unions where the variant has a single
+ *  payload field and the user code refers to the scrutinee by its bare name. */
+function replaceVarInTStmts(stmts, oldName, newName, newTy) {
+    return stmts.map(s => mapTStmt(s, e => {
+        if (e.kind === "var" && e.name === oldName) {
+            return { kind: "var", name: newName, ty: newTy };
+        }
+        return null;
+    }));
 }
 /** If the chain has matched all variants but one, return that remaining variant. */
-function remainingVariant(chain, typeDecls) {
-    const decl = typeDecls.find(d => d.name === chain.typeName);
+function remainingVariant(typeName, cases, typeDecls) {
+    const decl = typeDecls.find(d => d.name === typeName);
     if (!decl?.variants)
         return null;
-    const matched = new Set(chain.cases.map(c => c.variant));
+    const matched = new Set(cases.map(c => c.variant));
     const remaining = decl.variants.filter(v => !matched.has(v.name));
     if (remaining.length !== 1)
         return null;
@@ -1168,12 +1499,20 @@ function transformPureSwitch(s, typeDecls) {
 }
 function transformPureMatch(chain, typeDecls) {
     const cases = chain.cases.map(c => ({ name: c.variant, body: c.body }));
+    const decl = typeDecls.find(d => d.name === chain.typeName);
+    // Synth array-unions have single-field variants and user code refers to the
+    // scrutinee by its bare name, not field-accessed. See emitMatchStmt for
+    // the statement-level counterpart of this substitution.
+    const isSynthArrayUnion = decl?.discriminant === "__isArray__";
     const arms = buildMatchArms(cases, chain.varName, chain.typeName, typeDecls, (body, vn, fields) => {
         let result = transformPureBody(body, typeDecls);
         if (!result)
             return null;
         if (fields.length > 0 && vn)
             result = replaceFieldAccess(result, vn, fields);
+        if (isSynthArrayUnion && fields.length === 1 && vn) {
+            result = replaceVarInExpr(result, vn, matchBinder(fields[0].name, vn));
+        }
         return result;
     });
     if (!arms)
@@ -1181,10 +1520,9 @@ function transformPureMatch(chain, typeDecls) {
     // Idiomatic TS often has an unreachable fallthrough after exhaustive if-chains on
     // discriminated unions. Skip the catch-all arm when all variants are matched,
     // since Lean errors on redundant match arms.
-    const decl = typeDecls.find(d => d.name === chain.typeName);
     const allCovered = decl?.variants && chain.cases.length >= decl.variants.length;
     if (chain.fallthrough.length > 0 && !allCovered) {
-        const remaining = remainingVariant(chain, typeDecls);
+        const remaining = remainingVariant(chain.typeName, chain.cases, typeDecls);
         if (remaining) {
             // Exactly one variant left — destructure for variant-specific field access.
             let body = transformPureBody(chain.fallthrough, typeDecls);
@@ -1192,6 +1530,9 @@ function transformPureMatch(chain, typeDecls) {
                 return null;
             if (remaining.fields.length > 0)
                 body = replaceFieldAccess(body, chain.varName, remaining.fields);
+            if (isSynthArrayUnion && remaining.fields.length === 1) {
+                body = replaceVarInExpr(body, chain.varName, matchBinder(remaining.fields[0].name, chain.varName));
+            }
             arms.push({ pattern: buildMatchPattern(remaining.name, remaining.fields, chain.varName), body });
         }
         else {
@@ -1350,9 +1691,9 @@ export function transformModule(mod, specImport) {
             continue;
         const body = transformPureBody(fn.body, mod.typeDecls);
         if (body) {
-            // For ensures, replace \result (→ "res") with the function call
+            // For pure-function lemmas, replace \result with the function call.
             const fnCall = { kind: "app", fn: fn.name, args: fn.params.map(p => ({ kind: "var", name: p.name })) };
-            const ensures = fn.ensures.map(e => replaceVar(transformExpr(e), "res", fnCall));
+            const ensures = fn.ensures.map(e => replaceVar(transformExpr(e), "\\result", fnCall));
             pureDefs.push({
                 kind: "def",
                 name: fn.name,
@@ -1383,18 +1724,35 @@ export function transformModule(mod, specImport) {
         }
     }
     const base = mod.file.split("/").pop()?.replace(/\.ts$/, "") ?? "module";
+    // Externs: emit as top-of-file `function {:axiom}` (Dafny) declarations.
+    // Any `requires`/`ensures` from the source declaration come along so callers
+    // see the same spec the source itself verified. Substitute `\result` with the
+    // function call (same pattern as for in-file pure-function ensures).
+    const externDecls = (mod.externs ?? []).map(ext => {
+        const fnCall = { kind: "app", fn: ext.flat, args: ext.params.map(p => ({ kind: "var", name: p.name })) };
+        return {
+            kind: "extern",
+            name: ext.flat,
+            typeParams: ext.typeParams,
+            params: ext.params.map(p => ({ name: p.name, type: p.ty })),
+            returnType: ext.returnTy,
+            requires: ext.requires.map(transformExpr),
+            ensures: ext.ensures.map(e => replaceVar(transformExpr(e), "\\result", fnCall)),
+        };
+    });
     // Types file
     const typesImports = ["LemmaScript"];
     let typesFile = null;
     const pureNamespace = pureDefs.length > 0
         ? [{ kind: "namespace", name: "Pure", decls: pureDefs }]
         : [];
-    if (typeDecls.length > 0 || pureDefs.length > 0) {
+    if (typeDecls.length > 0 || pureDefs.length > 0 || externDecls.length > 0) {
         typesFile = {
             comment: "  Generated by lsc — Lean types and pure function mirrors.",
             imports: typesImports,
             options: [],
-            decls: [...typeDecls, ...pureNamespace],
+            // Externs come first so they're in scope for every later declaration.
+            decls: [...externDecls, ...typeDecls, ...pureNamespace],
         };
     }
     // Def file: Velvet methods