lemmascript 0.5.5 → 0.5.7

package/tools/dist/lean-emit.js

@@ -77,6 +77,7 @@ function escapeName(name) {
 }
 // ── Operator precedence (for parenthesization) ──────────────
 const PREC = {
+    "↔": 0, // Lean: Iff (20) binds looser than → (25)
     "→": 1, "∨": 2, "∧": 3,
     "=": 4, "≠": 4, "≥": 4, "≤": 4, ">": 4, "<": 4,
     "+": 5, "-": 5, "++": 5, "arrayConcat": 5, "*": 6, "/": 6, "%": 6,
@@ -96,15 +97,15 @@ function emitMethodCall(tyKind, method, monadic, obj, args) {
         if (method === "some")
             return `${obj}.${monadic ? "anyM" : "any"} ${args[0]}`;
         if (method === "includes")
-            return `${obj}.contains ${args[0]}`;
+            return args.length > 1 ? `(${obj}.extract ${args[1]} ${obj}.size).contains ${args[0]}` : `${obj}.contains ${args[0]}`;
         if (method === "find")
             return `${obj}.find? ${args[0]}`;
         if (method === "with")
             return `${obj}.set! ${args[0]} ${args[1]}`;
         if (method === "push")
-            return `Array.push ${obj} ${args[0]}`;
+            return args.length === 1 ? `Array.push ${obj} ${args[0]}` : `${obj} ++ #[${args.join(", ")}]`;
         if (method === "concat")
-            return `Array.push ${obj} ${args[0]}`;
+            return args.length === 1 ? `Array.push ${obj} ${args[0]}` : `${obj} ++ #[${args.join(", ")}]`;
         // arr.slice → Array.extract. No-arg slice is a full copy (Array is a value
         // type in Lean, so the receiver itself); one arg drops the prefix, two args
         // give the half-open range. Matches JS for non-negative bounds (negative
@@ -184,7 +185,7 @@ function emitExpr(e, parentPrec) {
         case "emptySet": return `Std.HashSet.empty`;
         case "methodCall": {
             const obj = emitExpr(e.obj);
-            const wrap = e.obj.kind === "binop" || e.obj.kind === "app" || e.obj.kind === "methodCall";
+            const wrap = e.obj.kind === "binop" || e.obj.kind === "app" || e.obj.kind === "methodCall" || e.obj.kind === "if" || e.obj.kind === "let";
             const receiver = wrap ? `(${obj})` : obj;
             const args = e.args.map(a => (a.kind === "binop" || a.kind === "unop" || a.kind === "implies" || a.kind === "app" || a.kind === "methodCall") ? `(${emitExpr(a)})` : emitExpr(a));
             return emitMethodCall(e.objTy.kind, e.method, e.monadic, receiver, args);
@@ -213,11 +214,23 @@ function emitExpr(e, parentPrec) {
                 return `${wrap ? `(${recv})` : recv}.contains ${emitExpr(e.left)}`;
             }
             const op = e.op === "arrayConcat" ? "++" : e.op;
-            const s = `${wrapOperand(e.left, prec(e.op))} ${op} ${wrapOperand(e.right, prec(e.op))}`;
+            // ↔ does not chain in Lean — a nested iff operand needs parens.
+            const childPrec = e.op === "↔" ? prec(e.op) + 1 : prec(e.op);
+            // `-`, `/`, `%` are left-associative and non-associative, so an equal-
+            // precedence right operand must be parenthesized: `a - (b - c)` would
+            // otherwise emit as `a - b - c`, i.e. `(a - b) - c`.
+            const rightPrec = e.op === "↔" ? childPrec
+                : ["-", "/", "%"].includes(e.op) ? prec(e.op) + 1 : childPrec;
+            const s = `${wrapOperand(e.left, childPrec)} ${op} ${wrapOperand(e.right, rightPrec)}`;
             return (parentPrec !== undefined && prec(e.op) < parentPrec) ? `(${s})` : s;
         }
         case "implies": {
-            const parts = [...e.premises.map(p => wrapOperand(p)), emitExpr(e.conclusion)];
+            // Premises bind at →'s level: a nested-implication premise must keep its
+            // parens (→ is right-associative, so `(a → b) → c` ≠ `a → b → c`), and
+            // ↔ binds looser than → in Lean. The conclusion is the right-assoc tail,
+            // where a nested implication is safe bare — only ↔ needs parens there.
+            const wrapIff = (x) => x.kind === "binop" && x.op === "↔" ? `(${emitExpr(x)})` : undefined;
+            const parts = [...e.premises.map(p => wrapOperand(p, prec("→"))), wrapIff(e.conclusion) ?? emitExpr(e.conclusion)];
             const s = parts.join(" → ");
             return parentPrec !== undefined ? `(${s})` : s;
         }
@@ -231,6 +244,16 @@ function emitExpr(e, parentPrec) {
             // SetToSeq → .toArray for Lean (HashSet has native toArray)
             if (e.fn === "SetToSeq" && args.length === 1)
                 return `${args[0]}.toArray`;
+            if (e.fn === "SetFromSeq" && args.length === 1)
+                return `Std.HashSet.ofList ${args[0]}.toList`;
+            if (e.fn === "ToString" && args.length === 1)
+                return `toString ${args[0]}`;
+            // JSRem (JS truncated remainder) → Lean's native truncated `Int.tmod`
+            if (e.fn === "JSRem" && args.length === 2)
+                return `Int.tmod ${args[0]} ${args[1]}`;
+            // JSTruncDiv (JS truncated bigint division) → Lean's native `Int.tdiv`
+            if (e.fn === "JSTruncDiv" && args.length === 2)
+                return `Int.tdiv ${args[0]} ${args[1]}`;
             // perm(a, b) → `List.Perm` on the underlying lists. Dafny lowers it to
             // `multiset(a) == multiset(b)`; the Lean image is `a.toList ~ b.toList`,
             // which mathlib's `List.Perm` provides (reflexivity, symmetry,

package/tools/dist/narrow.js

@@ -249,6 +249,8 @@ function ruleEarlyReturnConsume(s, rest) {
     const noneBranch = check.negated ? s.then : s.else;
     if (someBranch.length !== 0)
         return null;
+    if (!isTerminating(noneBranch))
+        return null;
     return {
         kind: "someMatch",
         scrutinee: check.scrutinee, binderTy: check.innerTy,
@@ -292,11 +294,14 @@ function ruleEarlyReturnOrChain(s, rest) {
     let inner = rest;
     for (let i = checks.length - 1; i >= 0; i--) {
         const check = checks[i];
+        const someBody = canBeFalsy(check)
+            ? [{ kind: "if", cond: bound(check), then: inner, else: s.then }]
+            : inner;
         inner = [{
                 kind: "someMatch",
                 scrutinee: check.scrutinee, binderTy: check.innerTy,
                 binder: check.binderHint,
-                someBody: inner,
+                someBody,
                 noneBody: s.then,
             }];
     }
@@ -582,11 +587,14 @@ function ruleIfAndOptional(s) {
         return null;
     const { check, restCond } = extracted;
     const innerIf = { kind: "if", cond: restCond, then: s.then, else: [] };
+    const someBody = canBeFalsy(check)
+        ? [{ kind: "if", cond: bound(check), then: [walkStmt(innerIf)], else: [] }]
+        : [walkStmt(innerIf)];
     return {
         kind: "someMatch",
         scrutinee: check.scrutinee, binderTy: check.innerTy,
         binder: check.binderHint,
-        someBody: [walkStmt(innerIf)],
+        someBody,
         noneBody: [],
     };
 }
@@ -776,8 +784,16 @@ function ruleDiscriminantChain(stmts) {
     }
     if (cases.length === 0)
         return null;
+    // If every case terminates, the trailing statements are the default arm
+    // (preserving the clean dispatch-as-expression shape). Otherwise the tail runs
+    // after the match for every variant, so leave it to the caller (empty default)
+    // rather than mis-routing it into the default arm only.
+    if (cases.every(c => isTerminating(c.body))) {
+        return { stmt: { kind: "tagMatch", scrutinee: first.scrutinee, typeName: first.typeName,
+                cases, fallthrough: stmts.slice(consumed) }, consumed: stmts.length };
+    }
     return { stmt: { kind: "tagMatch", scrutinee: first.scrutinee, typeName: first.typeName,
-            cases, fallthrough: stmts.slice(consumed) }, consumed: stmts.length };
+            cases, fallthrough: [] }, consumed };
 }
 /** Rule (list-level): `if (x.kind !== "v") terminate; rest` → tagMatch
  *  with cases = [{ variant: v, body: rest }] and fallthrough = terminate. */
@@ -809,12 +825,16 @@ function ruleLetCondAndOptional(s) {
     if (!extracted)
         return null;
     const { check, restCond } = extracted;
+    const assignIf = { kind: "if", cond: restCond,
+        then: [{ kind: "assign", target: s.name, value: s.init.then }], else: [] };
+    const someBody = canBeFalsy(check)
+        ? [{ kind: "if", cond: bound(check), then: [assignIf], else: [] }]
+        : [assignIf];
     const sm = {
         kind: "someMatch",
         scrutinee: check.scrutinee, binderTy: check.innerTy,
         binder: check.binderHint,
-        someBody: [{ kind: "if", cond: restCond,
-                then: [{ kind: "assign", target: s.name, value: s.init.then }], else: [] }],
+        someBody,
         noneBody: [],
     };
     return [
@@ -889,11 +909,15 @@ function ruleConditionalAndOptional(e) {
         kind: "conditional",
         cond: restCond, then: e.then, else: e.else, ty: e.ty,
     };
+    const someExpr = walkExpr(innerCond);
+    const someBody = canBeFalsy(check)
+        ? { kind: "conditional", cond: bound(check), then: someExpr, else: e.else, ty: e.ty }
+        : someExpr;
     return {
         kind: "someMatch",
         scrutinee: check.scrutinee, binderTy: check.innerTy,
         binder: check.binderHint,
-        someBody: walkExpr(innerCond), noneBody: e.else, ty: e.ty,
+        someBody, noneBody: e.else, ty: e.ty,
     };
 }
 /** Rule (statement): `if (<rest> && Array.isArray(path) && <more>) then [else]`

package/tools/dist/resolve.js

@@ -685,7 +685,9 @@ function resolveExpr(e, ctx) {
                 }
             }
             let ty = { kind: "unknown" };
-            if (["===", "!==", ">=", "<=", ">", "<", "in"].includes(e.op))
+            // <==> is bool like the comparisons; unlike ==>, neither side narrows
+            // the other (no premise to assume).
+            if (["===", "!==", ">=", "<=", ">", "<", "in", "<==>"].includes(e.op))
                 ty = { kind: "bool" };
             else if (e.op === "&&")
                 ty = right.ty;
@@ -727,6 +729,16 @@ function resolveExpr(e, ctx) {
                 const fn = { kind: "var", name: "Perm", ty: { kind: "unknown" } };
                 return { kind: "call", fn, args: [a, b], ty: { kind: "bool" }, callKind: "pure" };
             }
+            // new Set(arr): build a deduplicated set from the array's elements (extract
+            // marks the array form `__setFromArray`). Lowers to the SetFromSeq preamble
+            // (Dafny `set x | x in s`); size/membership are then set semantics.
+            if (e.fn.kind === "var" && e.fn.name === "__setFromArray" && e.args.length === 1) {
+                const arr = resolveExpr(e.args[0], ctx);
+                if (arr.ty.kind !== "array")
+                    throw new Error(`new Set(...) expects an array argument (got ${arr.ty.kind})`);
+                const fn = { kind: "var", name: "SetFromSeq", ty: { kind: "unknown" } };
+                return { kind: "call", fn, args: [arr], ty: { kind: "set", elem: arr.ty.elem }, callKind: "pure" };
+            }
             // Extern dispatch: `NS.method(args)` where NS.method is declared via
             // `//@ extern`. Rewrite into a flat-name call (`NS_method(args)`) so the
             // rest of the pipeline sees an ordinary pure function. The extern's

package/tools/dist/specparser.js

@@ -2,7 +2,7 @@
  * Spec expression parser.
  * Parses //@ annotation expressions into RawExpr AST nodes.
  */
-const MULTI_OPS = ["==>", "===", "!==", "==", "!=", ">=", "<=", "&&", "||"];
+const MULTI_OPS = ["<==>", "==>", "===", "!==", "==", "!=", ">=", "<=", "&&", "||"];
 function tokenize(input) {
     const tokens = [];
     let i = 0;
@@ -20,8 +20,22 @@ function tokenize(input) {
             const quote = input[i];
             i++;
             let s = "";
-            while (i < input.length && input[i] !== quote)
-                s += input[i++];
+            while (i < input.length && input[i] !== quote) {
+                if (input[i] === "\\") {
+                    // Standard escapes, where TS source, Dafny, and Lean all agree.
+                    // The emitters re-escape on output, so the round trip is faithful.
+                    const esc = input[i + 1];
+                    const mapped = esc === "n" ? "\n" : esc === "r" ? "\r" : esc === "t" ? "\t"
+                        : esc === "0" ? "\0" : esc === "\\" || esc === '"' || esc === "'" ? esc : null;
+                    if (mapped === null)
+                        throw new Error(`Unsupported string escape '\\${esc}' at ${i} in: ${input}`);
+                    s += mapped;
+                    i += 2;
+                }
+                else {
+                    s += input[i++];
+                }
+            }
             if (i < input.length)
                 i++;
             tokens.push({ type: "str", value: s });
@@ -103,11 +117,19 @@ class Parser {
         return false;
     }
     parse() {
-        const r = this.parseImplies();
+        const r = this.parseIff();
         if (this.pos < this.tokens.length)
             throw new Error(`Unexpected: ${JSON.stringify(this.peek())}`);
         return r;
     }
+    // <==> binds loosest (Dafny precedence: a ==> b <==> c is (a ==> b) <==> c),
+    // right-associative like ==> — immaterial semantically, iff is associative.
+    parseIff() {
+        const left = this.parseImplies();
+        if (this.match("op", "<==>"))
+            return { kind: "binop", op: "<==>", left, right: this.parseIff() };
+        return left;
+    }
     parseImplies() {
         const left = this.parseTernary();
         if (this.match("op", "==>"))
@@ -117,9 +139,9 @@ class Parser {
     parseTernary() {
         const cond = this.parseOr();
         if (this.match("op", "?")) {
-            const then_ = this.parseImplies();
+            const then_ = this.parseIff();
             this.expect("punc", ":");
-            const else_ = this.parseImplies();
+            const else_ = this.parseIff();
             return { kind: "conditional", cond, then: then_, else: else_ };
         }
         return cond;
@@ -187,16 +209,16 @@ class Parser {
                 expr = { kind: "field", obj: expr, field: this.expect("ident").value };
             }
             else if (this.match("punc", "[")) {
-                const idx = this.parseImplies();
+                const idx = this.parseIff();
                 this.expect("punc", "]");
                 expr = { kind: "index", obj: expr, idx };
             }
             else if (this.match("punc", "(")) {
                 const args = [];
                 if (!this.match("punc", ")")) {
-                    args.push(this.parseImplies());
+                    args.push(this.parseIff());
                     while (this.match("punc", ","))
-                        args.push(this.parseImplies());
+                        args.push(this.parseIff());
                     this.expect("punc", ")");
                 }
                 expr = { kind: "call", fn: expr, args };
@@ -276,7 +298,7 @@ class Parser {
                     varType = ty;
                 }
                 this.expect("punc", ",");
-                const body = this.parseImplies();
+                const body = this.parseIff();
                 this.expect("punc", ")");
                 return { kind: q, var: v, varType, body };
             }
@@ -285,7 +307,7 @@ class Parser {
         }
         if (t.type === "punc" && t.value === "(") {
             this.advance();
-            const expr = this.parseImplies();
+            const expr = this.parseIff();
             this.expect("punc", ")");
             return expr;
         }
@@ -293,9 +315,9 @@ class Parser {
             this.advance();
             const elems = [];
             if (!this.match("punc", "]")) {
-                elems.push(this.parseImplies());
+                elems.push(this.parseIff());
                 while (this.match("punc", ","))
-                    elems.push(this.parseImplies());
+                    elems.push(this.parseIff());
                 this.expect("punc", "]");
             }
             return { kind: "arrayLiteral", elems };
@@ -306,11 +328,11 @@ class Parser {
             if (!this.match("punc", "}")) {
                 const name = this.expect("ident").value;
                 this.expect("punc", ":");
-                fields.push({ name, value: this.parseImplies() });
+                fields.push({ name, value: this.parseIff() });
                 while (this.match("punc", ",")) {
                     const n = this.expect("ident").value;
                     this.expect("punc", ":");
-                    fields.push({ name: n, value: this.parseImplies() });
+                    fields.push({ name: n, value: this.parseIff() });
                 }
                 this.expect("punc", "}");
             }