lemmascript 0.5.12 → 0.5.14

package/tools/dist/transform.js

@@ -4,8 +4,9 @@
  * 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 ──────────────────────────────────────
 /**
  * Map over all sub-expressions in an Expr. `f` is called on each node;
@@ -73,6 +74,49 @@ function mapStmt(s, f) {
         case "assert": return { ...s, expr: r(s.expr) };
     }
 }
+/** 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`
+ *  indices. Capture-avoiding: a nested scope that reintroduces `from` keeps its
+ *  own binding untouched. `mapExpr` doesn't descend into lambda bodies, so this
+ *  walks them by hand. */
+export function renameFreeVar(e, from, to) {
+    const f = (x) => {
+        if (x.kind === "var")
+            return x.name === from ? { ...x, name: to } : x;
+        // let-expression: `value` is in the outer scope (rename), `body` sees the
+        // rebound `from` (leave it), so handle the recursion here to stop descent.
+        if (x.kind === "let" && x.name === from)
+            return { ...x, value: mapExpr(x.value, f) };
+        if ((x.kind === "forall" || x.kind === "exists") && x.var === from)
+            return x;
+        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 => patternBinds(a.pattern, from) ? a : { ...a, body: mapExpr(a.body, f) }) };
+        }
+        if (x.kind === "lambda") {
+            if (x.params.some(p => p.name === from))
+                return x; // param shadows `from`
+            const body = [];
+            let shadowed = false;
+            for (const s of x.body) {
+                if (shadowed) {
+                    body.push(s);
+                    continue;
+                }
+                body.push(s.kind === "forin" && s.idx === from
+                    ? { ...s, bound: mapExpr(s.bound, f) } // idx shadows in the loop body
+                    : mapStmt(s, f));
+                if ((s.kind === "let" || s.kind === "let-bind" || s.kind === "ghostLet") && s.name === from)
+                    shadowed = true;
+            }
+            return { ...x, body };
+        }
+        return null;
+    };
+    return mapExpr(e, f);
+}
 /** Map over all sub-expressions in a TExpr (typed IR). */
 function mapTExpr(e, f) {
     const hit = f(e);
@@ -145,21 +189,28 @@ let _opts = DAFNY_OPTIONS;
 let _typeDecls = [];
 /** Prefix match-bound field names to avoid capturing user variables.
  *  When prefix is given (the scrutinee name), include it to avoid
- *  collisions in nested matches on different variables. */
+ *  collisions in nested matches on different variables. `freshName` closes
+ *  the residual gap: a user variable literally named `_value`/`_x_field` in an
+ *  arm body would still be captured, so prime on any module-wide collision.
+ *  Deterministic, so the pattern binder and its body substitutions agree. */
 function matchBinder(fieldName, prefix) {
-    return prefix ? `_${prefix}_${fieldName}` : `_${fieldName}`;
+    return freshName(prefix ? `_${prefix}_${fieldName}` : `_${fieldName}`);
 }
 /** 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
@@ -351,7 +402,7 @@ function lowerExpr(e, binds) {
     // callKind "unknown" and fall through to the regular case below where
     // they become `methodCall`.
     if (binds && e.kind === "call" && e.callKind === "method" && e.fn.kind === "var") {
-        const name = `_t${_liftCounter++}`;
+        const name = freshName(`_t${_liftCounter++}`);
         const args = e.args.map(a => lowerExpr(a, binds));
         binds.push({ kind: "let-bind", name, value: { kind: "app", fn: e.fn.name, args } });
         return { kind: "var", name };
@@ -380,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 } },
                     ],
                 };
             }
@@ -433,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 } },
                         ],
                     };
                 }
@@ -451,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 } },
                     ],
                 };
             }
@@ -470,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" } },
                     ],
                 };
             }
@@ -494,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 },
                     ],
                 };
             }
@@ -640,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") {
@@ -751,7 +802,7 @@ function lowerExpr(e, binds) {
                 const result = { kind: "methodCall", obj: recv, objTy: e.fn.obj.ty, method, args, monadic: needsMonadic };
                 // Monadic HOF call is itself monadic — lift via binds like a method call
                 if (_opts.monadic && needsMonadic && binds) {
-                    const name = `_t${_liftCounter++}`;
+                    const name = freshName(`_t${_liftCounter++}`);
                     binds.push({ kind: "let-bind", name, value: result });
                     return { kind: "var", name };
                 }
@@ -911,7 +962,7 @@ function lowerExpr(e, binds) {
         case "havoc":
             // Dafny's * only works in var/assign positions — lift to own declaration
             if (binds) {
-                const name = `_t${_liftCounter++}`;
+                const name = freshName(`_t${_liftCounter++}`);
                 binds.push({ kind: "let", name, type: e.ty, mutable: false, value: { kind: "havoc", type: e.ty } });
                 return { kind: "var", name };
             }
@@ -945,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 },
                 ],
             };
         }
@@ -988,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 };
         }
@@ -1030,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 => {
@@ -1217,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))))
@@ -1226,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
@@ -1242,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
@@ -1357,11 +1407,11 @@ function transformStmts(stmts, typeDecls) {
                 const count = _forofCounters.get(keyName) ?? 0;
                 _forofCounters.set(keyName, count + 1);
                 const suffix = count === 0 ? "" : `${count + 1}`;
-                const keysSeqName = `_${keyName}_keys${suffix}`;
+                const keysSeqName = freshName(`_${keyName}_keys${suffix}`);
                 const convExpr = { kind: "app", fn: "SetToSeq", args: [{ kind: "field", obj: iterExpr, field: "keys" }] };
                 result.push({ kind: "let", name: keysSeqName, type: { kind: "array", elem: keyTy }, mutable: false, value: convExpr });
                 const keysVar = { kind: "var", name: keysSeqName };
-                const idxName = `_${keyName}_idx${suffix}`;
+                const idxName = freshName(`_${keyName}_idx${suffix}`);
                 const idx = { kind: "var", name: idxName };
                 const arrSize = { kind: "field", obj: keysVar, field: "size" };
                 const bodyStmts = eliminateTopLevelContinue(transformStmts(s.body, typeDecls));
@@ -1383,11 +1433,11 @@ function transformStmts(stmts, typeDecls) {
                 const count = _forofCounters.get(keyName) ?? 0;
                 _forofCounters.set(keyName, count + 1);
                 const suffix = count === 0 ? "" : `${count + 1}`;
-                const keysSeqName = `_${keyName}_keys${suffix}`;
+                const keysSeqName = freshName(`_${keyName}_keys${suffix}`);
                 const convExpr = { kind: "app", fn: "SetToSeq", args: [{ kind: "field", obj: iterExpr, field: "keys" }] };
                 result.push({ kind: "let", name: keysSeqName, type: { kind: "array", elem: keyTy }, mutable: false, value: convExpr });
                 const keysVar = { kind: "var", name: keysSeqName };
-                const idxName = `_${keyName}_idx${suffix}`;
+                const idxName = freshName(`_${keyName}_idx${suffix}`);
                 const idx = { kind: "var", name: idxName };
                 const arrSize = { kind: "field", obj: keysVar, field: "size" };
                 const bodyStmts = eliminateTopLevelContinue(transformStmts(s.body, typeDecls));
@@ -1405,7 +1455,7 @@ function transformStmts(stmts, typeDecls) {
             }
             // Sets aren't indexable — bind SetToSeq to a variable for iteration
             if (s.iterable.ty.kind === "set") {
-                const seqName = `_${varName}_seq`;
+                const seqName = freshName(`_${varName}_seq`);
                 const convExpr = { kind: "app", fn: "SetToSeq", args: [iterExpr] };
                 const elemTy = varTy.kind !== "unknown" ? varTy : { kind: "string" };
                 result.push({ kind: "let", name: seqName, type: { kind: "array", elem: elemTy }, mutable: false, value: convExpr });
@@ -1414,7 +1464,7 @@ function transformStmts(stmts, typeDecls) {
             const count = _forofCounters.get(varName) ?? 0;
             _forofCounters.set(varName, count + 1);
             const suffix = count === 0 ? "" : `${count + 1}`;
-            const idxName = `_${varName}_idx${suffix}`;
+            const idxName = freshName(`_${varName}_idx${suffix}`);
             const idx = { kind: "var", name: idxName };
             const arrSize = { kind: "field", obj: iterExpr, field: "size" };
             const bodyStmts = eliminateTopLevelContinue(transformStmts(s.body, typeDecls));
@@ -1489,15 +1539,17 @@ function transformStmt(s, typeDecls) {
                     const arrIR = transformExpr(arrExpr);
                     const arrTy = arrExpr.ty;
                     const elemTy = arrTy.kind === "array" ? arrTy.elem : { kind: "unknown" };
-                    const idxName = `_${param}_idx`;
+                    const idxName = freshName(`_${param}_idx`);
                     const idx = { kind: "var", name: idxName };
                     const arrSize = { kind: "field", obj: arrIR, field: "size" };
                     const elemVar = { kind: "var", name: param };
                     const keyIR = transformExpr(keyExpr);
                     const valIR = transformExpr(valExpr);
                     const mapSet = { kind: "methodCall", obj: { kind: "var", name: s.name }, objTy: s.ty, method: "set", args: [keyIR, valIR], monadic: false };
-                    // Auto-invariant: all processed elements' keys are in the map
-                    const kVar = { kind: "var", name: "ki" };
+                    // Auto-invariant: all processed elements' keys are in the map. The
+                    // quantifier wraps user expressions, so its binder must be fresh.
+                    const kiName = freshName("ki");
+                    const kVar = { kind: "var", name: kiName };
                     const mapHasKey = {
                         kind: "implies",
                         premises: [
@@ -1506,7 +1558,7 @@ function transformStmt(s, typeDecls) {
                         ],
                         conclusion: { kind: "methodCall", obj: { kind: "var", name: s.name }, objTy: s.ty, method: "has", args: [keyIR.kind === "field" ? { kind: "field", obj: { kind: "index", arr: arrIR, idx: kVar }, field: keyIR.field } : keyIR], monadic: false },
                     };
-                    const autoInv = { kind: "forall", var: "ki", type: { kind: "int" }, body: mapHasKey };
+                    const autoInv = { kind: "forall", var: kiName, type: { kind: "int" }, body: mapHasKey };
                     const stmts = [
                         { kind: "let", name: s.name, type: s.ty, mutable: true, value: { kind: "emptyMap" } },
                         { kind: "forin", idx: idxName, bound: arrSize,
@@ -1627,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 },
                         ],
                     }];
             }
@@ -1712,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 };
@@ -1768,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.
@@ -1900,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 },
                         ],
                     };
                 }
@@ -1923,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 };
     }
@@ -1946,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;
@@ -1994,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 };