lemmascript 0.5.13 → 0.5.15

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "lemmascript",
-  "version": "0.5.13",
+  "version": "0.5.15",
   "description": "A verification toolchain for TypeScript — generates Lean 4 or Dafny from annotated TS",
   "type": "module",
   "engines": {
@@ -32,7 +32,7 @@
     "type": "git",
     "url": "https://github.com/midspiral/LemmaScript"
   },
-  "homepage": "https://lemmascript.com",
+  "homepage": "https://lemmascript.org",
   "keywords": [
     "lemmascript",
     "verification",

package/tools/dist/dafny-emit.js

@@ -2,7 +2,7 @@
  * Dafny emitter — IR → Dafny text.
  */
 import { usesName, usesNameInDecl } from "./ir.js";
-import { freshName } from "./names.js";
+import { freshName, userNames } from "./names.js";
 import { renameFreeVar } from "./transform.js";
 /** Fresh binder for a comprehension wrapping the given subexpressions: `base`
  *  verbatim unless one of them references it, then primed until free. A *local*
@@ -42,7 +42,7 @@ function tyToDafny(ty) {
             needPreamble("OptionType");
             return `Option<${tyToDafny(ty.inner)}>`;
         }
-        case "user": return ty.name;
+        case "user": return escapeName(ty.name);
         case "fn": return `(${ty.params.map(tyToDafny).join(", ")}) -> ${tyToDafny(ty.result)}`;
         // Out-of-subset (`any`/`unknown`); opaque so real ops on it fail loudly
         // rather than silently verify as `int`. Mirrors the Lean backend's `_`.
@@ -75,28 +75,82 @@ const DAFNY_KEYWORDS = new Set([
     "copredicate", "inductive",
 ]);
 // The Dafny out-parameter name for the method currently being emitted. Default
-// `res`, but bumped (e.g. `res_`) when a parameter is named `res` — set by
-// methodHeader and reset per decl. `\result` in an ensures must use the *same*
-// name, so escapeName routes it here.
+// `res`, but bumped (e.g. `res'`) when the method's own scope uses `res` — set
+// by methodHeader and reset per decl. `\result` in an ensures must use the
+// *same* name, so escapeName routes it here.
 let _resultName = "res";
+// ── Dafny name allocation ──────────────────────────────────
+//
+// freshName (names.ts) freshens in the *raw TS* namespace — but that is not the
+// namespace Dafny sees. Escaping maps `_x`→`i_x` and keyword `match`→`match_`,
+// so two raw-distinct names can collapse *after* escaping: a raw-freshened temp
+// `_t0'`→`i_t0'` colliding with a user `_t0` that escaped-and-primed to `i_t0'`.
+// So Dafny hygiene is a second allocator, layered at emission: escape to a base,
+// then freshen against the names already claimed in the Dafny namespace. User
+// names are allocated up front (Dafny-safe ones kept exact); generated names are
+// allocated on first sight and cached so a decl and its references agree. Reset
+// per file. (The raw freshName layer stays — Lean has a different escaping story.)
+function dafnyBaseName(name) {
+    if (DAFNY_KEYWORDS.has(name))
+        return `${name}_`;
+    if (name.startsWith("_"))
+        return `i${name}`; // Dafny forbids leading `_`
+    return name;
+}
+let _userDafnyNames = new Map();
+let _generatedDafnyNames = new Map();
+let _takenDafnyNames = new Set();
+/** `base`, primed until free in the Dafny namespace. A prime can't occur in a
+ *  TS identifier, so priming always leaves user-name space. */
+function freshDafnyName(base) {
+    let out = base;
+    while (_takenDafnyNames.has(out))
+        out += "'";
+    return out;
+}
+function resetDafnyNameCache() {
+    _userDafnyNames = new Map();
+    _generatedDafnyNames = new Map();
+    _takenDafnyNames = new Set();
+    const raws = [...userNames()].sort();
+    // Dafny-safe source names keep their spelling; names that must mangle are then
+    // freshened in the emitted namespace (safe-first, sorted → deterministic).
+    for (const raw of raws)
+        if (dafnyBaseName(raw) === raw) {
+            _userDafnyNames.set(raw, raw);
+            _takenDafnyNames.add(raw);
+        }
+    for (const raw of raws)
+        if (dafnyBaseName(raw) !== raw) {
+            const emitted = freshDafnyName(dafnyBaseName(raw));
+            _userDafnyNames.set(raw, emitted);
+            _takenDafnyNames.add(emitted);
+        }
+}
 function escapeName(name) {
-    // \result is carried through the IR as the var name "\\result"; render it
-    // as the current method's out-parameter name.
+    // \result is carried through the IR as var "\\result"; render it as the
+    // current method's out-parameter name (chosen locally by methodHeader).
     if (name === "\\result")
         return _resultName;
-    let out = name;
-    if (DAFNY_KEYWORDS.has(name))
-        out = `${name}_`;
-    // Dafny doesn't allow identifiers starting with _
-    else if (name.startsWith("_"))
-        out = `i${name}`;
-    else
-        return name;
-    // Mangling must stay injective: the mangled form may itself be a name the
-    // user wrote (`match` → `match_` beside a real `match_`, `_x` → `i_x` beside
-    // a real `i_x`), silently merging two distinct variables. `freshName` primes
-    // it clear of user-name space (a prime can't occur in a TS identifier).
-    return freshName(out);
+    const user = _userDafnyNames.get(name);
+    if (user !== undefined)
+        return user;
+    return escapeGeneratedName(name);
+}
+/** Allocate a toolchain-generated name (an ANF temp, a comprehension binder, a
+ *  companion `_ensures` lemma). Escapes to a base, then freshens in the Dafny
+ *  namespace so it can't collapse onto an escaped user name. Bypasses the user
+ *  map on purpose: the raw name is synthesized, so it must be freshened *away
+ *  from* a same-spelled user name, not aliased onto it. Cached so a declaration
+ *  and its references render identically. */
+function escapeGeneratedName(name) {
+    const cached = _generatedDafnyNames.get(name);
+    if (cached !== undefined)
+        return cached;
+    const emitted = freshDafnyName(dafnyBaseName(name));
+    _generatedDafnyNames.set(name, emitted);
+    _takenDafnyNames.add(emitted);
+    return emitted;
 }
 /** Format a typed parameter list for Dafny: "x: int, y: seq<int>" */
 function paramList(params) {
@@ -139,7 +193,7 @@ function emitQuantifier(e, keyword) {
     while (body.kind === e.kind) {
         const dty = tyToDafny(body.type);
         const ann = dty === "string" ? "" : `: ${dty}`;
-        vars.push(`${body.var}${ann}`);
+        vars.push(`${escapeName(body.var)}${ann}`);
         body = body.body;
     }
     return `${keyword} ${vars.join(", ")} :: ${emitExpr(body)}`;
@@ -337,7 +391,7 @@ function emitExpr(e) {
                     // Minted comprehension binder: freshen so a user variable `k` in the
                     // receiver or key isn't captured (`k != k` would delete nothing).
                     // Local check — only this comprehension's own operands can collide.
-                    const k = freshBinder("k", e.obj, e.args[0]);
+                    const k = escapeName(freshBinder("k", e.obj, e.args[0]));
                     return `(map ${k} | ${k} in ${obj} && ${k} != ${args[0]} :: ${obj}[${k}])`;
                 }
             }
@@ -485,9 +539,11 @@ function emitExpr(e) {
         }
         case "field": {
             const obj = emitExpr(e.obj);
-            if (e.field === "size" || e.field === "length" || e.field === "collectionSize")
+            // `size`/`length`/`keys` are collection intrinsics unless the transform
+            // proved this is a declared datatype field (then project it).
+            if (!e.datatypeField && (e.field === "size" || e.field === "length" || e.field === "collectionSize"))
                 return `|${obj}|`;
-            if (e.field === "keys")
+            if (!e.datatypeField && e.field === "keys")
                 return `${obj}.Keys`;
             if (e.field === "toNat")
                 return obj;
@@ -719,23 +775,23 @@ function emitDecl(d) {
                 const fields = c.fields.map(f => collides.has(f.name) ? { ...f, name: `${f.name}_${c.name}` } : f);
                 return `${escapeName(c.name)}(${paramList(fields)})`;
             });
-            return `datatype ${d.name}${tp} = ${ctors.join(" | ")}`;
+            return `datatype ${escapeName(d.name)}${tp} = ${ctors.join(" | ")}`;
         }
         case "structure": {
             const tp = d.typeParams?.length ? `<${d.typeParams.join(", ")}>` : "";
-            return `datatype ${d.name}${tp} = ${d.name}(${paramList(d.fields)})`;
+            return `datatype ${escapeName(d.name)}${tp} = ${escapeName(d.name)}(${paramList(d.fields)})`;
         }
         case "type-alias": {
-            return `type ${d.name} = ${tyToDafny(d.target)}`;
+            return `type ${escapeName(d.name)} = ${tyToDafny(d.target)}`;
         }
         case "opaque-type": {
             // Abstract type — no definition. `(==)` so it can sit inside datatypes
             // that derive structural equality. Never constructed or destructured.
-            return `type ${d.name}(==)`;
+            return `type ${escapeName(d.name)}(==)`;
         }
         case "def": {
             const tp = d.typeParams.length > 0 ? `<${d.typeParams.join(", ")}>` : "";
-            const lines = [`function ${d.name}${tp}(${paramList(d.params)}): ${tyToDafny(d.returnType)}`];
+            const lines = [`function ${escapeName(d.name)}${tp}(${paramList(d.params)}): ${tyToDafny(d.returnType)}`];
             for (const r of d.requires)
                 lines.push(`  requires ${emitExpr(r)}`);
             if (d.decreases)
@@ -748,7 +804,7 @@ function emitDecl(d) {
                 // 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${lemmaTP}(${paramList(d.params)})`);
+                lines.push(`lemma ${escapeGeneratedName(`${d.name}_ensures`)}${lemmaTP}(${paramList(d.params)})`);
                 for (const r of d.requires)
                     lines.push(`  requires ${emitExpr(r)}`);
                 for (const e of d.ensures)
@@ -760,7 +816,7 @@ function emitDecl(d) {
         }
         case "def-by-method": {
             const tp = d.typeParams.length > 0 ? `<${d.typeParams.join(", ")}>` : "";
-            const lines = [`function ${d.name}${tp}(${paramList(d.params)}): ${tyToDafny(d.returnType)}`];
+            const lines = [`function ${escapeName(d.name)}${tp}(${paramList(d.params)}): ${tyToDafny(d.returnType)}`];
             for (const r of d.requires)
                 lines.push(`  requires ${emitExpr(r)}`);
             if (d.decreases)
@@ -774,7 +830,7 @@ function emitDecl(d) {
         }
         case "method": {
             const tp = d.typeParams.length > 0 ? `<${d.typeParams.join(", ")}>` : "";
-            const lines = [methodHeader(`method ${d.name}${tp}`, d.params, d.returnType, d)];
+            const lines = [methodHeader(`method ${escapeName(d.name)}${tp}`, d.params, d.returnType, d)];
             for (const r of d.requires)
                 lines.push(`  requires ${emitExpr(r)}`);
             for (const e of d.ensures)
@@ -787,14 +843,14 @@ function emitDecl(d) {
             return lines.join("\n");
         }
         case "class": {
-            const lines = [`class ${d.name} {`];
+            const lines = [`class ${escapeName(d.name)} {`];
             for (const f of d.fields) {
                 lines.push(`  var ${escapeName(f.name)}: ${tyToDafny(f.type)}`);
             }
             if (d.fields.length > 0 && d.methods.length > 0)
                 lines.push("");
             for (const m of d.methods) {
-                lines.push(`  ${methodHeader(`method ${m.name}`, m.params, m.returnType, m)}`);
+                lines.push(`  ${methodHeader(`method ${escapeName(m.name)}`, m.params, m.returnType, m)}`);
                 for (const r of m.requires)
                     lines.push(`    requires ${emitExpr(r)}`);
                 for (const e of m.ensures)
@@ -1027,22 +1083,39 @@ const SEQ_SORT_BY = `function {:axiom} SeqSortBy<T(==,!new)>(s: seq<T>, cmp: (T,
   ensures multiset(SeqSortBy(s, cmp)) == multiset(s)
   ensures |SeqSortBy(s, cmp)| == |s|
   ensures forall i: int, j: int :: 0 <= i <= j < |SeqSortBy(s, cmp)| ==> cmp(SeqSortBy(s, cmp)[i], SeqSortBy(s, cmp)[j]) <= 0`;
-const STRING_TRIM = `function StringTrimLeft(s: string): string
+// TS/JS String.prototype.trim() strips ECMAScript WhiteSpace ∪ LineTerminator:
+// Unicode general-category Zs plus TAB/VT/FF/CR/LF, LS/PS, and the BOM — NOT just
+// U+0020, and NOT U+0085 (NEL, which is Cc). See
+// https://tc39.es/ecma262/#sec-white-space and
+// https://tc39.es/ecma262/#sec-line-terminators.
+// `\\U{..}` are Dafny char escapes (not JS: the string
+// is emitted verbatim), so the enumeration below is Dafny source, not decoded.
+const STRING_TRIM = `predicate IsJSWhitespace(c: char)
+{
+  c == '\\U{0009}' || c == '\\U{000A}' || c == '\\U{000B}' || c == '\\U{000C}' || c == '\\U{000D}' ||
+  c == '\\U{0020}' || c == '\\U{00A0}' || c == '\\U{1680}' ||
+  ('\\U{2000}' <= c <= '\\U{200A}') ||
+  c == '\\U{2028}' || c == '\\U{2029}' || c == '\\U{202F}' || c == '\\U{205F}' ||
+  c == '\\U{3000}' || c == '\\U{FEFF}'
+}
+
+function StringTrimLeft(s: string): string
   ensures |StringTrimLeft(s)| <= |s|
-  ensures StringTrimLeft(s) == "" || (|StringTrimLeft(s)| > 0 && StringTrimLeft(s)[0] != ' ')
+  ensures StringTrimLeft(s) == "" || (|StringTrimLeft(s)| > 0 && !IsJSWhitespace(StringTrimLeft(s)[0]))
   decreases |s|
 {
   if |s| == 0 then ""
-  else if s[0] == ' ' then StringTrimLeft(s[1..])
+  else if IsJSWhitespace(s[0]) then StringTrimLeft(s[1..])
   else s
 }
 
 function StringTrimRight(s: string): string
   ensures |StringTrimRight(s)| <= |s|
+  ensures StringTrimRight(s) == "" || (|StringTrimRight(s)| > 0 && !IsJSWhitespace(StringTrimRight(s)[|StringTrimRight(s)|-1]))
   decreases |s|
 {
   if |s| == 0 then ""
-  else if s[|s|-1] == ' ' then StringTrimRight(s[..|s|-1])
+  else if IsJSWhitespace(s[|s|-1]) then StringTrimRight(s[..|s|-1])
   else s
 }
 
@@ -1249,21 +1322,17 @@ function qualifyCtor(name, type) {
  *  "_" → "_"
  */
 const CTOR_MAP = { "some": "Some", "none": "None" };
-function translatePattern(pattern) {
-    if (pattern === "_")
+function translatePattern(p) {
+    if (p.kind === "wild")
         return "_";
-    const m = pattern.match(/^\.(\w+)\s*(.*)$/);
-    if (!m)
-        return pattern;
-    const ctorName = CTOR_MAP[m[1]] ?? escapeName(m[1]);
-    const fields = m[2].trim();
-    if (!fields)
+    const ctorName = CTOR_MAP[p.ctor] ?? escapeName(p.ctor);
+    if (p.binders.length === 0)
         return ctorName;
-    const fieldNames = fields.split(/\s+/).map(escapeName);
-    return `${ctorName}(${fieldNames.join(", ")})`;
+    return `${ctorName}(${p.binders.map(escapeName).join(", ")})`;
 }
 export function emitDafnyFile(file, tsFileName, opts) {
     _useSafeSlice = !!opts?.safeSlice;
+    resetDafnyNameCache();
     buildRecordCtorMap(file.decls);
     _neededPreambles.clear();
     // Track successfully emitted pure defs — method wrappers are only

package/tools/dist/ir.js

@@ -4,6 +4,19 @@
  * The transform phase produces these types.
  * The emit phase pretty-prints them to backend syntax (Lean or Dafny).
  */
+export const pWild = () => ({ kind: "wild" });
+export const pCtor = (ctor, ...binders) => ({ kind: "ctor", ctor, binders });
+/** Binder identifiers a pattern introduces (`[]` for wildcard / nullary ctor). */
+export function patternBinders(p) {
+    return p.kind === "ctor" ? p.binders : [];
+}
+export function patternCtor(p) {
+    return p.kind === "ctor" ? p.ctor : null;
+}
+/** Does the pattern bind `name`? */
+export function patternBinds(p, name) {
+    return patternBinders(p).includes(name);
+}
 export function anyExpr(e, pred) {
     if (pred(e))
         return true;
@@ -75,8 +88,32 @@ export function usesName(e, name) {
 export function usesNameInStmts(stmts, name) {
     return anyExprInStmts(stmts, _refsName(name));
 }
-/** Does a declaration's spec (requires/ensures) or body reference `name`? The
- *  scope a method's out-parameter binder must dodge, shared by both emitters. */
+/** Names a statement tree *binds, targets, or introduces* — `let`/`let-bind`/
+ *  `ghostLet` names, `assign`/`bind`/`ghostAssign` targets, `for-in` indices,
+ *  and `match`-arm pattern binders — recursing through nested blocks. Distinct
+ *  from `usesNameInStmts` (expression references only): an unread or assign-only
+ *  local still duplicate-declares against a method's out-parameter in Dafny. */
+export function bindsNameInStmts(stmts, name) {
+    return stmts.some(s => {
+        switch (s.kind) {
+            case "let":
+            case "let-bind":
+            case "ghostLet": return s.name === name;
+            case "assign":
+            case "bind":
+            case "ghostAssign": return s.target === name;
+            case "forin": return s.idx === name || bindsNameInStmts(s.body, name);
+            case "if": return bindsNameInStmts(s.then, name) || bindsNameInStmts(s.else, name);
+            case "while": return bindsNameInStmts(s.body, name);
+            case "match": return s.arms.some(a => patternBinds(a.pattern, name) || bindsNameInStmts(a.body, name));
+            default: return false;
+        }
+    });
+}
+/** Every occurrence of `name` a method's out-parameter binder must dodge —
+ *  referenced in a spec (requires/ensures) or body, *or* bound/targeted anywhere
+ *  in the body (an unread local still duplicate-declares). Both emitters share it. */
 export function usesNameInDecl(requires, ensures, body, name) {
-    return requires.some(e => usesName(e, name)) || ensures.some(e => usesName(e, name)) || usesNameInStmts(body, name);
+    return requires.some(e => usesName(e, name)) || ensures.some(e => usesName(e, name))
+        || usesNameInStmts(body, name) || bindsNameInStmts(body, name);
 }

package/tools/dist/lean-emit.js

@@ -1,8 +1,10 @@
 /**
- * Lean emitter — IR → Lean text.
- * No logic, no type decisions — just serialization.
+ * Lean emitter — IR → Lean text. Beyond serialization it makes type-driven
+ * decisions: Bool-vs-Prop connectives, dropping Repr/DecidableEq for
+ * opaque-tainted types, discriminator/destructor lowering, method dispatch,
+ * and support-import selection.
  */
-import { anyExpr, usesNameInDecl } from "./ir.js";
+import { anyExpr, usesNameInDecl, patternBinders } from "./ir.js";
 import { freshName } from "./names.js";
 // ── Ty → Lean type string ──────────────────────────────────
 function tyToLean(ty) {
@@ -178,6 +180,10 @@ let _unknownEmitted = false; // across files in one run — the def file imports
 // built only from decidable atoms (comparisons, Bool-returning calls) coerces fine
 // and stays in the more proof-friendly Prop form.
 let _boolCtx = false;
+/** Render a match pattern to Lean syntax: `_`, `.none`, `.some x`, `.syn seq`. */
+function renderLeanPattern(p) {
+    return p.kind === "wild" ? "_" : "." + [p.ctor, ...p.binders].join(" ");
+}
 // A Bool-valued atom that does NOT coerce to Prop: an inlined union discriminator
 // (lowered to a match-bool `match x with | .C .. => true | _ => false`) or a raw
 // `match` used as a Bool — neither has a `Decidable` instance Lean can synthesize
@@ -465,7 +471,7 @@ function emitExpr(e, parentPrec) {
             // Always parenthesize inline matches — Lean parses alternatives greedily,
             // so any token after an arm body (`→`, another match's `|`, etc.) would
             // bleed into the last `.none` case without explicit bracketing.
-            const arms = e.arms.map(a => `| ${a.pattern} => ${emitExpr(a.body)}`);
+            const arms = e.arms.map(a => `| ${renderLeanPattern(a.pattern)} => ${emitExpr(a.body)}`);
             const scrut = typeof e.scrutinee === "string" ? e.scrutinee : emitExpr(e.scrutinee);
             return `(match ${scrut} with ${arms.join(" ")})`;
         }
@@ -557,10 +563,10 @@ function emitStmt(s, indent) {
             const scrut = typeof s.scrutinee === "string" ? s.scrutinee : emitExpr(s.scrutinee);
             // Option match (.some/.none) → emit as if/let for WPGen.if compatibility
             if (s.arms.length === 2) {
-                const someArm = s.arms.find(a => a.pattern.startsWith(".some "));
-                const noneArm = s.arms.find(a => a.pattern === ".none");
+                const someArm = s.arms.find(a => a.pattern.kind === "ctor" && a.pattern.ctor === "some");
+                const noneArm = s.arms.find(a => a.pattern.kind === "ctor" && a.pattern.ctor === "none");
                 if (someArm && noneArm) {
-                    const boundVar = someArm.pattern.slice(6); // strip ".some "
+                    const boundVar = patternBinders(someArm.pattern)[0]; // ".some x" ⇒ "x"
                     const hName = `h_${scrut.replace(/[^a-zA-Z0-9_]/g, "_")}`;
                     const lines = [
                         `${pad}if ${hName} : (${scrut}).isSome = true then`,
@@ -585,7 +591,7 @@ function emitStmt(s, indent) {
             // General match
             const lines = [`${pad}match ${scrut} with`];
             for (const arm of s.arms) {
-                lines.push(`${pad}| ${arm.pattern} =>`);
+                lines.push(`${pad}| ${renderLeanPattern(arm.pattern)} =>`);
                 if (arm.body.length === 0) {
                     lines.push(`${pad}  pure ()`);
                 }
@@ -744,7 +750,7 @@ function emitPureExpr(e, indent) {
         case "match": {
             const lines = [`${pad}match ${typeof e.scrutinee === "string" ? e.scrutinee : emitExpr(e.scrutinee)} with`];
             for (const arm of e.arms) {
-                lines.push(`${pad}| ${arm.pattern} =>`);
+                lines.push(`${pad}| ${renderLeanPattern(arm.pattern)} =>`);
                 lines.push(emitPureExpr(arm.body, indent + 1));
             }
             return lines.join("\n");
@@ -756,6 +762,20 @@ function emitPureExpr(e, indent) {
     }
 }
 // ── File emission ────────────────────────────────────────────
+/** Reset per-module emitter state. Call once per module before the types file
+ *  (not between types and def — the def file reads the types file's registries). */
+export function resetLeanModule() {
+    _resultName = "res";
+    _unionCtors.clear();
+    _opaqueNames.clear();
+    _opaqueNames.add("Unknown");
+    _typeRefs.clear();
+    _taintedTypes.clear();
+    _needsJSString = false;
+    _needsUnknown = false;
+    _unknownEmitted = false;
+    _boolCtx = false;
+}
 export function emitLeanFile(file) {
     _needsJSString = false;
     _needsUnknown = false;

package/tools/dist/lsc.js

@@ -15,7 +15,7 @@ import { narrowModule } from "./narrow.js";
 import { autoHavocModule } from "./autohavoc.js";
 import { transformModuleLean, transformModuleDafny } from "./transform.js";
 import { peepholeModule } from "./peephole.js";
-import { emitLeanFile } from "./lean-emit.js";
+import { emitLeanFile, resetLeanModule } 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";
@@ -261,6 +261,7 @@ function runFile(cmd, filePath, backend, timeLimit, extraFlags) {
     if (typesFile)
         typesFile = peepholeModule(typesFile, "lean");
     defFile = peepholeModule(defFile, "lean");
+    resetLeanModule(); // clear per-module emitter state so batch mode doesn't leak into this module
     const typesPath = typesFile ? path.join(dir, `${leanBase}.types.lean`) : null;
     const typesText = typesFile ? emitLeanFile(typesFile) : null;
     const defPath = path.join(dir, `${leanBase}.def.lean`);

package/tools/dist/names.js

@@ -34,6 +34,11 @@ export function setUserNames(names) {
 export function isUserName(name) {
     return _userNames.has(name);
 }
+/** The raw user identifiers, for a backend that needs to allocate its own
+ *  emitted names against them (e.g. Dafny escaping — see dafny-emit). */
+export function userNames() {
+    return [..._userNames];
+}
 /** A toolchain-internal name: `base` verbatim, primed on collision. The one
  *  place the priming rule lives. `taken` says what counts as a collision —
  *  by default a user-written name anywhere in the module; callers that know

package/tools/dist/narrow.js

@@ -417,6 +417,26 @@ function ruleImplOptional(e) {
         ty: { kind: "bool" },
     };
 }
+/** Apply an optional chain's steps (field / index / call) to a base expr —
+ *  shared by `ruleOptChain` (base = binder) and `ruleOptChainIndex` (base = arr[i]). */
+function applyChain(body, chain) {
+    for (const step of chain) {
+        if (step.kind === "field")
+            body = { kind: "field", obj: body, field: step.name, ty: step.ty };
+        else if (step.kind === "index")
+            body = { kind: "index", obj: body, idx: step.idx, ty: step.ty };
+        else
+            body = { kind: "call", fn: body, args: step.args, ty: step.ty, callKind: step.callKind };
+    }
+    return body;
+}
+/** `0 <= idx && idx < arr.length` — the in-bounds guard for an array index. */
+function arrayBoundsCond(arr, idx) {
+    const len = { kind: "field", obj: arr, field: "length", ty: { kind: "int" } };
+    const lo = { kind: "binop", op: "<=", left: { kind: "num", value: 0, ty: { kind: "int" } }, right: idx, ty: { kind: "bool" } };
+    const hi = { kind: "binop", op: "<", left: idx, right: len, ty: { kind: "bool" } };
+    return { kind: "binop", op: "&&", left: lo, right: hi, ty: { kind: "bool" } };
+}
 /** Rule (expression): `left ?? right` — nullish coalescing.
  *  → `someMatch left { Some(_v) => _v, None => right }`.
  *  Single-evaluation: scrutinee may be any expression. */
@@ -448,11 +468,7 @@ function ruleNullishIndex(e) {
         return null;
     if (e.left.obj.ty.kind !== "array")
         return null;
-    const idx = e.left.idx;
-    const len = { kind: "field", obj: e.left.obj, field: "length", ty: { kind: "int" } };
-    const lo = { kind: "binop", op: "<=", left: { kind: "num", value: 0, ty: { kind: "int" } }, right: idx, ty: { kind: "bool" } };
-    const hi = { kind: "binop", op: "<", left: idx, right: len, ty: { kind: "bool" } };
-    const cond = { kind: "binop", op: "&&", left: lo, right: hi, ty: { kind: "bool" } };
+    const cond = arrayBoundsCond(e.left.obj, e.left.idx);
     return { kind: "conditional", cond, then: e.left, else: e.right, ty: e.ty };
 }
 /** Rule (expression): `arr[i]?.<chain>` — optional chaining on an array index,
@@ -470,23 +486,8 @@ function ruleOptChainIndex(e) {
         return null;
     if (e.obj.obj.ty.kind !== "array")
         return null;
-    const idx = e.obj.idx;
-    const len = { kind: "field", obj: e.obj.obj, field: "length", ty: { kind: "int" } };
-    const lo = { kind: "binop", op: "<=", left: { kind: "num", value: 0, ty: { kind: "int" } }, right: idx, ty: { kind: "bool" } };
-    const hi = { kind: "binop", op: "<", left: idx, right: len, ty: { kind: "bool" } };
-    const cond = { kind: "binop", op: "&&", left: lo, right: hi, ty: { kind: "bool" } };
-    let body = e.obj; // arr[i] — in bounds under `cond`
-    for (const step of e.chain) {
-        if (step.kind === "field") {
-            body = { kind: "field", obj: body, field: step.name, ty: step.ty };
-        }
-        else if (step.kind === "index") {
-            body = { kind: "index", obj: body, idx: step.idx, ty: step.ty };
-        }
-        else {
-            body = { kind: "call", fn: body, args: step.args, ty: step.ty, callKind: step.callKind };
-        }
-    }
+    const cond = arrayBoundsCond(e.obj.obj, e.obj.idx);
+    const body = applyChain(e.obj, e.chain); // arr[i] — in bounds under `cond`
     const undef = { kind: "var", name: "undefined", ty: { kind: "void" } };
     return { kind: "conditional", cond, then: body, else: undef, ty: e.ty };
 }
@@ -501,18 +502,7 @@ function ruleOptChain(e) {
         return null;
     const innerTy = e.obj.ty.inner;
     const binder = freshName(`_oc${_ocCounter++}_val`);
-    let body = { kind: "var", name: binder, ty: innerTy };
-    for (const step of e.chain) {
-        if (step.kind === "field") {
-            body = { kind: "field", obj: body, field: step.name, ty: step.ty };
-        }
-        else if (step.kind === "index") {
-            body = { kind: "index", obj: body, idx: step.idx, ty: step.ty };
-        }
-        else {
-            body = { kind: "call", fn: body, args: step.args, ty: step.ty, callKind: step.callKind };
-        }
-    }
+    const body = applyChain({ kind: "var", name: binder, ty: innerTy }, e.chain);
     const noneBody = { kind: "var", name: "undefined", ty: { kind: "void" } };
     return {
         kind: "someMatch",
@@ -604,31 +594,39 @@ function ruleConditionalOptionalTruthy(e) {
         someBody: e.then, noneBody: e.else, ty: e.ty,
     };
 }
-/** 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) {
+/** Find the leftmost `parse`-matching conjunct anywhere in an `&&` chain,
+ *  returning it plus the remaining conjunction. Conjunct order doesn't carry
+ *  semantic weight, so either side is fine. Shared by the optional and
+ *  Array.isArray chain extractors — they differ only in `parse`.
+ *  `(x !== undefined && b) && c` → { check, restCond: b && c }. */
+function extractLeftmostCheck(cond, parse) {
     if (cond.kind !== "binop" || cond.op !== "&&")
         return null;
-    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 };
+    const left = parse(cond.left);
+    if (left)
+        return { check: left, restCond: cond.right };
+    const right = parse(cond.right);
+    if (right)
+        return { check: right, restCond: cond.left };
     if (cond.left.kind === "binop" && cond.left.op === "&&") {
-        const inner = extractLeftmostOptionalCheck(cond.left);
+        const inner = extractLeftmostCheck(cond.left, parse);
         if (inner)
             return { check: inner.check, restCond: { ...cond, left: inner.restCond } };
     }
     if (cond.right.kind === "binop" && cond.right.op === "&&") {
-        const inner = extractLeftmostOptionalCheck(cond.right);
+        const inner = extractLeftmostCheck(cond.right, parse);
         if (inner)
             return { check: inner.check, restCond: { ...cond, right: inner.restCond } };
     }
     return null;
 }
+/** `&&`-chain extractor for a positive optional check. */
+function extractLeftmostOptionalCheck(cond) {
+    return extractLeftmostCheck(cond, e => {
+        const c = parseSimpleOptionalCheck(e);
+        return c && !c.negated ? c : null;
+    });
+}
 /** Rule: `if (x !== undefined && rest) then` (no else) where x is a pure
  *  access path.
  *  → `someMatch x { Some(_x_val) => if rest then then; , None => {} }`.
@@ -745,31 +743,11 @@ function isNarrowablePath(e) {
         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). */
+/** `&&`-chain extractor for `Array.isArray(path)` (positive form only — a negated
+ *  `!Array.isArray(...)` would narrow to the wrong variant for then-body consumers,
+ *  so those are left to the 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;
+    return extractLeftmostCheck(cond, parseArrayIsArrayCall);
 }
 /** Detect `x.kind === "variant"`, `'key' in x`, or `Array.isArray(x)` (synth
  *  array-union) as a positive discriminant check. Returns the scrutinee var

package/tools/dist/peephole.js

@@ -1,3 +1,4 @@
+import { patternCtor, patternBinders } from "./ir.js";
 // ── Generic walkers (same shape as transform.ts) ─────────────
 function mapExpr(e, f) {
     const hit = f(e);
@@ -44,21 +45,19 @@ function isMapGet(e) {
         return null;
     return { obj: e.obj, key: e.args[0], objTy: e.objTy };
 }
-/** Parse Some-arm pattern like ".some _val" — returns binder name, or null for ".some _" or unparseable. */
-function parseSomeBinder(pattern) {
-    if (!pattern.startsWith(".some"))
+/** Binder of a Some arm — its name, or null for `.some _` / a non-`some` pattern. */
+function parseSomeBinder(p) {
+    if (patternCtor(p) !== "some")
         return null;
-    const rest = pattern.slice(5).trim();
-    if (rest === "" || rest === "_")
-        return null;
-    return rest.split(/\s+/)[0];
+    const b = patternBinders(p)[0];
+    return b === undefined || b === "_" ? null : b;
 }
 /** Identify a Some/None match's arms. */
 function getSomeNoneArms(arms) {
     if (arms.length !== 2)
         return null;
-    const someArm = arms.find(a => a.pattern.startsWith(".some"));
-    const noneArm = arms.find(a => a.pattern === ".none");
+    const someArm = arms.find(a => patternCtor(a.pattern) === "some");
+    const noneArm = arms.find(a => patternCtor(a.pattern) === "none");
     if (!someArm || !noneArm)
         return null;
     return { someArm, noneArm, binder: parseSomeBinder(someArm.pattern) };

package/tools/dist/transform.js

@@ -4,7 +4,7 @@
  * Consumes resolved types and classifications.
  * No type lookups, no string parsing, no re-inference.
  */
-import { anyExprInStmts } from "./ir.js";
+import { anyExprInStmts, pWild, pCtor, patternBinders, patternBinds, patternCtor } from "./ir.js";
 import { parseTsType } from "./types.js";
 import { freshName } from "./names.js";
 // ── Generic IR walkers ──────────────────────────────────────
@@ -74,11 +74,6 @@ function mapStmt(s, f) {
         case "assert": return { ...s, expr: r(s.expr) };
     }
 }
-/** Binders a match-arm pattern string (`.Ctor a b`, `_x_val`, `_`) introduces. */
-function patternBinders(pattern) {
-    const toks = pattern.match(/[A-Za-z_][A-Za-z0-9_']*/g) ?? [];
-    return pattern.trimStart().startsWith(".") ? toks.slice(1) : toks;
-}
 /** Rename free occurrences of `from` to `to`, stopping at every construct that
  *  rebinds `from` — lambda params, `let`/`let-bind`/`ghostLet` (shadows the
  *  rest of the block), `match` arm patterns, `forall`/`exists`, and `for-in`
@@ -98,7 +93,7 @@ export function renameFreeVar(e, from, to) {
         if (x.kind === "match") {
             const scr = typeof x.scrutinee === "string"
                 ? (x.scrutinee === from ? to : x.scrutinee) : mapExpr(x.scrutinee, f);
-            return { ...x, scrutinee: scr, arms: x.arms.map(a => patternBinders(a.pattern).includes(from) ? a : { ...a, body: mapExpr(a.body, f) }) };
+            return { ...x, scrutinee: scr, arms: x.arms.map(a => patternBinds(a.pattern, from) ? a : { ...a, body: mapExpr(a.body, f) }) };
         }
         if (x.kind === "lambda") {
             if (x.params.some(p => p.name === from))
@@ -203,15 +198,19 @@ function matchBinder(fieldName, prefix) {
 }
 /** Build a match arm pattern like `.VariantName _v_field1 _v_field2` from variant info. */
 function buildMatchPattern(variantName, fields, scopePrefix) {
-    if (fields.length === 0)
-        return `.${variantName}`;
-    return `.${variantName} ${fields.map(f => matchBinder(f.name, scopePrefix)).join(" ")}`;
+    return pCtor(variantName, ...fields.map(f => matchBinder(f.name, scopePrefix)));
 }
 const _forofCounters = new Map();
 function isNat(ty) { return ty.kind === "nat"; }
 function isIntegral(ty) { return ty.kind === "int" || ty.kind === "nat"; }
 function isArray(ty) { return ty.kind === "array"; }
 function isUser(ty) { return ty.kind === "user"; }
+function isRecordType(ty) {
+    if (ty.kind !== "user")
+        return false;
+    const base = ty.name.includes("<") ? ty.name.slice(0, ty.name.indexOf("<")) : ty.name;
+    return _typeDecls.find(d => d.name === base)?.kind === "record";
+}
 /** Truthiness test for a *lowered* value of source type `ty`, used by `||`
  *  falsiness lowering. Mirrors narrow.ts's `canBeFalsy`: only int/nat/string/bool
  *  values can be falsy in JS (`0`, `""`, `false`); every other value (array, user
@@ -432,8 +431,8 @@ function lowerExpr(e, binds) {
                 return {
                     kind: "match", scrutinee: lowerExpr(e.expr, binds),
                     arms: [
-                        { pattern: `.some ${bound}`, body: truthy ? { kind: "unop", op: "¬", expr: truthy } : { kind: "bool", value: false } },
-                        { pattern: ".none", body: { kind: "bool", value: true } },
+                        { pattern: pCtor("some", bound), body: truthy ? { kind: "unop", op: "¬", expr: truthy } : { kind: "bool", value: false } },
+                        { pattern: pCtor("none"), body: { kind: "bool", value: true } },
                     ],
                 };
             }
@@ -485,8 +484,8 @@ function lowerExpr(e, binds) {
                     return {
                         kind: "match", scrutinee: optExpr,
                         arms: [
-                            { pattern: ".some _", body: { kind: "bool", value: !isNone } },
-                            { pattern: ".none", body: { kind: "bool", value: isNone } },
+                            { pattern: pCtor("some", "_"), body: { kind: "bool", value: !isNone } },
+                            { pattern: pCtor("none"), body: { kind: "bool", value: isNone } },
                         ],
                     };
                 }
@@ -503,8 +502,8 @@ function lowerExpr(e, binds) {
                 return {
                     kind: "match", scrutinee: optExpr,
                     arms: [
-                        { pattern: `.some ${bound}`, body: { kind: "binop", op: cmpOp, left: { kind: "var", name: bound }, right: valExpr } },
-                        { pattern: ".none", body: { kind: "bool", value: noneVal } },
+                        { pattern: pCtor("some", bound), body: { kind: "binop", op: cmpOp, left: { kind: "var", name: bound }, right: valExpr } },
+                        { pattern: pCtor("none"), body: { kind: "bool", value: noneVal } },
                     ],
                 };
             }
@@ -522,12 +521,12 @@ function lowerExpr(e, binds) {
                 return {
                     kind: "match", scrutinee: optExpr,
                     arms: [
-                        { pattern: `.some ${bound}`, body: {
+                        { pattern: pCtor("some", bound), body: {
                                 kind: "if", cond: truthy,
                                 then: { kind: "app", fn: "Some", args: [{ kind: "var", name: bound }] },
                                 else: { kind: "var", name: "undefined" }
                             } },
-                        { pattern: ".none", body: { kind: "var", name: "undefined" } },
+                        { pattern: pCtor("none"), body: { kind: "var", name: "undefined" } },
                     ],
                 };
             }
@@ -546,8 +545,8 @@ function lowerExpr(e, binds) {
                 return {
                     kind: "match", scrutinee: optExpr,
                     arms: [
-                        { pattern: `.some ${bound}`, body: someBody },
-                        { pattern: ".none", body: defaultExpr },
+                        { pattern: pCtor("some", bound), body: someBody },
+                        { pattern: pCtor("none"), body: defaultExpr },
                     ],
                 };
             }
@@ -692,10 +691,10 @@ function lowerExpr(e, binds) {
                 const baseName = e.obj.ty.name.includes("<") ? e.obj.ty.name.slice(0, e.obj.ty.name.indexOf("<")) : e.obj.ty.name;
                 const decl = _typeDecls.find(d => d.name === baseName && d.kind === "discriminated-union");
                 if (decl?.variants?.some(v => v.fields.some(f => f.name === e.field))) {
-                    return { kind: "field", obj: transformExpr(e.obj), field: e.field, fromUnion: baseName };
+                    return { kind: "field", obj: transformExpr(e.obj), field: e.field, fromUnion: baseName, datatypeField: true };
                 }
             }
-            return { kind: "field", obj: transformExpr(e.obj), field: e.field };
+            return { kind: "field", obj: transformExpr(e.obj), field: e.field, datatypeField: isRecordType(e.obj.ty) };
         case "index": {
             const idx = transformExpr(e.idx);
             if (e.obj.ty.kind === "map") {
@@ -997,8 +996,8 @@ function lowerExpr(e, binds) {
             return {
                 kind: "match", scrutinee,
                 arms: [
-                    { pattern: `.some ${e.binder}`, body: someBody },
-                    { pattern: ".none", body: noneBody },
+                    { pattern: pCtor("some", e.binder), body: someBody },
+                    { pattern: pCtor("none"), body: noneBody },
                 ],
             };
         }
@@ -1040,7 +1039,7 @@ function lowerExpr(e, binds) {
                 let body = lowerExpr(e.fallthrough, binds);
                 if (wrapOpt)
                     body = wrapOptionalBranch(body, e.fallthrough);
-                arms.push({ pattern: "_", body });
+                arms.push({ pattern: pWild(), body });
             }
             return { kind: "match", scrutinee: varName ?? scrutinee, arms };
         }
@@ -1082,7 +1081,7 @@ function ensuresToMatch(e, typeDecls) {
     const pattern = buildMatchPattern(variantName, fields, obj.name);
     let rhs = transformExpr(e.right);
     rhs = replaceFieldAccess(rhs, obj.name, fields);
-    return { kind: "match", scrutinee: obj.name, arms: [{ pattern, body: rhs }, { pattern: "_", body: { kind: "bool", value: true } }] };
+    return { kind: "match", scrutinee: obj.name, arms: [{ pattern, body: rhs }, { pattern: pWild(), body: { kind: "bool", value: true } }] };
 }
 function replaceFieldAccess(e, varName, fields) {
     return mapExpr(e, x => {
@@ -1269,8 +1268,8 @@ function matchToIfChains(stmts) {
         if (s.kind !== "match")
             return [s];
         const arms = s.arms.map(a => ({ ...a, body: matchToIfChains(a.body) }));
-        const ctorArms = arms.filter(a => a.pattern.trim() !== "_");
-        const firstCtor = ctorArms[0]?.pattern.trim().split(/\s+/)[0].replace(/^\./, "");
+        const ctorArms = arms.filter(a => a.pattern.kind !== "wild");
+        const firstCtor = ctorArms[0] ? patternCtor(ctorArms[0].pattern) : undefined;
         const decl = firstCtor
             ? _typeDecls.find(d => (d.kind === "discriminated-union" || d.kind === "string-union") &&
                 ((d.variants?.some(v => v.name === firstCtor)) || (d.values?.includes(firstCtor))))
@@ -1278,15 +1277,14 @@ function matchToIfChains(stmts) {
         if (!decl)
             return [{ ...s, arms }]; // not a user union (e.g. Option) — leave as match
         const scrutExpr = typeof s.scrutinee === "string" ? { kind: "var", name: s.scrutinee } : s.scrutinee;
-        const defaultArm = arms.find(a => a.pattern.trim() === "_");
+        const defaultArm = arms.find(a => a.pattern.kind === "wild");
         let elseBranch = defaultArm ? defaultArm.body : [];
         for (let k = ctorArms.length - 1; k >= 0; k--) {
             const armBody = ctorArms[k].body;
             if (armBody.length === 0)
                 continue; // empty arm (no-op) — let it fall through to `else`
-            const toks = ctorArms[k].pattern.trim().split(/\s+/);
-            const ctor = toks[0].replace(/^\./, "");
-            const binders = toks.slice(1);
+            const ctor = patternCtor(ctorArms[k].pattern) ?? "";
+            const binders = patternBinders(ctorArms[k].pattern);
             const variant = decl.variants?.find(v => v.name === ctor);
             // Discriminator condition. A nullary discriminated-union constructor would
             // need `DecidableEq` for `x = .Ctor` (which such unions don't derive), so
@@ -1294,8 +1292,8 @@ function matchToIfChains(stmts) {
             // string-unions derive DecidableEq, so `=` is fine there.
             const cond = decl.kind === "discriminated-union" && binders.length === 0
                 ? { kind: "match", scrutinee: scrutExpr, arms: [
-                        { pattern: `.${ctor}`, body: { kind: "bool", value: true } },
-                        { pattern: "_", body: { kind: "bool", value: false } }
+                        { pattern: pCtor(ctor), body: { kind: "bool", value: true } },
+                        { pattern: pWild(), body: { kind: "bool", value: false } }
                     ] }
                 : { kind: "binop", op: "=", left: scrutExpr, right: { kind: "constructor", name: ctor, type: decl.name } };
             // Bind only the constructor-field binders the body actually uses, pinning the
@@ -1681,8 +1679,8 @@ function transformStmt(s, typeDecls) {
                 return [{
                         kind: "match", scrutinee,
                         arms: [
-                            { pattern: `.some ${s.binder}`, body: someBody },
-                            { pattern: ".none", body: noneBody },
+                            { pattern: pCtor("some", s.binder), body: someBody },
+                            { pattern: pCtor("none"), body: noneBody },
                         ],
                     }];
             }
@@ -1766,7 +1764,7 @@ function emitMatchStmt(scrutinee, typeName, cases, fallthrough, typeDecls) {
             arms.push({ pattern, body });
         }
         else {
-            arms.push({ pattern: "_", body: transformStmts(fallthrough, typeDecls) });
+            arms.push({ pattern: pWild(), body: transformStmts(fallthrough, typeDecls) });
         }
     }
     return { kind: "match", scrutinee: isPath ? transformExpr(scrutinee) : prefix, arms };
@@ -1822,7 +1820,7 @@ function emitSwitchStmt(s, typeDecls) {
         ? buildMatchArms(cases, undefined, ef.enumTyName, typeDecls, (body) => transformStmts(body, typeDecls))
         : buildMatchArms(cases, s.expr.kind === "var" ? s.expr.name : "?", s.expr.ty.kind === "user" ? s.expr.ty.name : undefined, typeDecls, (body, vn, fields) => transformStmts(replaceFieldAccessInTStmts(body, vn, fields), typeDecls));
     if (s.defaultBody.length > 0)
-        arms.push({ pattern: "_", body: transformStmts(s.defaultBody, typeDecls) });
+        arms.push({ pattern: pWild(), body: transformStmts(s.defaultBody, typeDecls) });
     return { kind: "match", scrutinee: ef ? ef.scrutinee : (s.expr.kind === "var" ? s.expr.name : "?"), arms };
 }
 /** Replace obj.field → replacement var in typed IR.
@@ -1954,8 +1952,8 @@ function transformPureBody(stmts, typeDecls) {
                     return {
                         kind: "match", scrutinee,
                         arms: [
-                            { pattern: `.some ${s.binder}`, body: someExpr },
-                            { pattern: ".none", body: noneExpr },
+                            { pattern: pCtor("some", s.binder), body: someExpr },
+                            { pattern: pCtor("none"), body: noneExpr },
                         ],
                     };
                 }
@@ -1977,7 +1975,7 @@ function transformPureSwitch(s, typeDecls) {
             const body = transformPureBody(s.defaultBody, typeDecls);
             if (!body)
                 return null;
-            arms.push({ pattern: "_", body });
+            arms.push({ pattern: pWild(), body });
         }
         return { kind: "match", scrutinee: ef.scrutinee, arms };
     }
@@ -2000,7 +1998,7 @@ function transformPureSwitch(s, typeDecls) {
         const body = transformPureBody(s.defaultBody, typeDecls);
         if (!body)
             return null;
-        arms.push({ pattern: "_", body });
+        arms.push({ pattern: pWild(), body });
     }
     if (s.expr.kind !== "var")
         return null;
@@ -2048,7 +2046,7 @@ function transformPureMatch(chain, typeDecls) {
             const body = transformPureBody(chain.fallthrough, typeDecls);
             if (!body)
                 return null;
-            arms.push({ pattern: "_", body });
+            arms.push({ pattern: pWild(), body });
         }
     }
     return { kind: "match", scrutinee: chain.varName, arms };