lemmascript 0.3.3 → 0.5.0

package/tools/dist/info-command.js

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

package/tools/dist/lean-emit.js

@@ -31,6 +31,15 @@ function tyToLean(ty) {
             return inner.includes(" ") ? `Option (${inner})` : `Option ${inner}`;
         }
         case "user": return ty.name;
+        case "fn": {
+            const params = ty.params.map(p => {
+                const s = tyToLean(p);
+                return s.includes(" ") ? `(${s})` : s;
+            });
+            const ret = tyToLean(ty.result);
+            const retStr = ret.includes(" ") ? `(${ret})` : ret;
+            return [...params, retStr].join(" → ");
+        }
         case "unknown": return "_";
     }
 }
@@ -45,6 +54,10 @@ const LEAN_KEYWORDS = new Set([
     "at", "from", "to", "deriving", "extends", "true", "false",
 ]);
 function escapeName(name) {
+    // \result is carried through the IR as the var name "\\result"; render it
+    // as Lean's canonical return-value identifier (matches `return (res : T)`).
+    if (name === "\\result")
+        return "res";
     return LEAN_KEYWORDS.has(name) ? `«${name}»` : name;
 }
 // ── Operator precedence (for parenthesization) ──────────────
@@ -75,6 +88,8 @@ function emitMethodCall(tyKind, method, monadic, obj, args) {
             return `${obj}.set! ${args[0]} ${args[1]}`;
         if (method === "push")
             return `Array.push ${obj} ${args[0]}`;
+        if (method === "concat")
+            return `Array.push ${obj} ${args[0]}`;
     }
     // String methods
     if (tyKind === "string") {
@@ -107,13 +122,30 @@ function emitMethodCall(tyKind, method, monadic, obj, args) {
     throw new Error(`Unsupported Lean method call: .${method}() on ${tyKind}`);
 }
 // ── Expression emission ─────────────────────────────────────
+// Lean's `∀`/`∃` body extends as far as possible. So `(∃ x, P) <op> Q`
+// (or `∃ x, P → Q`) would parse with the operator absorbed into the body.
+// Wrap a quantifier in parens to terminate its body before the operator.
+function wrapQuantifier(sub, parentPrec) {
+    const inner = emitExpr(sub, parentPrec);
+    return (sub.kind === "forall" || sub.kind === "exists") ? `(${inner})` : inner;
+}
 function emitExpr(e, parentPrec) {
     switch (e.kind) {
         case "var": return escapeName(e.name);
         case "num": return `${e.value}`;
         case "bool": return e.value ? "true" : "false";
         case "str": return `"${e.value.replace(/\\/g, '\\\\').replace(/"/g, '\\"').replace(/\n/g, '\\n')}"`;
-        case "constructor": return `.${e.name}`;
+        case "constructor": {
+            // With type: emit `Type.name` (unambiguous; needed in expression positions
+            // like `match ... | .none => Type.some x` where elaboration can't infer).
+            // Without type: emit `.name` (dotted form; works in pattern positions
+            // and where the expected type is clear from context).
+            const head = e.type ? `${e.type}.${e.name}` : `.${e.name}`;
+            if (!e.args || e.args.length === 0)
+                return head;
+            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 `${head} ${args.join(" ")}`;
+        }
         case "arrayLiteral":
             if (e.elems.length === 0)
                 return `#[]`;
@@ -143,12 +175,19 @@ function emitExpr(e, parentPrec) {
                 return `-${e.expr.value}`;
             return `(-${emitExpr(e.expr)})`;
         case "binop": {
+            // `k in m` (map/set membership) → `m.contains k` in Lean. Dafny has
+            // native `in`; Lean uses the method form for HashMap/HashSet.
+            if (e.op === "in") {
+                const recv = emitExpr(e.right);
+                const wrap = e.right.kind === "binop" || e.right.kind === "app" || e.right.kind === "methodCall";
+                return `${wrap ? `(${recv})` : recv}.contains ${emitExpr(e.left)}`;
+            }
             const op = e.op === "arrayConcat" ? "++" : e.op;
-            const s = `${emitExpr(e.left, prec(e.op))} ${op} ${emitExpr(e.right, prec(e.op))}`;
+            const s = `${wrapQuantifier(e.left, prec(e.op))} ${op} ${emitExpr(e.right, prec(e.op))}`;
             return (parentPrec !== undefined && prec(e.op) < parentPrec) ? `(${s})` : s;
         }
         case "implies": {
-            const parts = [...e.premises.map(p => emitExpr(p)), emitExpr(e.conclusion)];
+            const parts = [...e.premises.map(p => wrapQuantifier(p)), emitExpr(e.conclusion)];
             const s = parts.join(" → ");
             return parentPrec !== undefined ? `(${s})` : s;
         }
@@ -182,8 +221,12 @@ function emitExpr(e, parentPrec) {
         case "if":
             return `if ${emitExpr(e.cond)} then ${emitExpr(e.then)} else ${emitExpr(e.else)}`;
         case "match": {
+            // 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)}`);
-            return `match ${typeof e.scrutinee === "string" ? e.scrutinee : emitExpr(e.scrutinee)} with ${arms.join(" ")}`;
+            const scrut = typeof e.scrutinee === "string" ? e.scrutinee : emitExpr(e.scrutinee);
+            return `(match ${scrut} with ${arms.join(" ")})`;
         }
         case "forall": return `∀ ${e.var} : ${tyToLean(e.type)}, ${emitExpr(e.body)}`;
         case "exists": return `∃ ${e.var} : ${tyToLean(e.type)}, ${emitExpr(e.body)}`;
@@ -191,6 +234,24 @@ function emitExpr(e, parentPrec) {
         default: throw new Error(`Unsupported Lean expression: ${e.kind}`);
     }
 }
+/** True if the IR expression emits to a Prop-valued Lean term. `transformExpr`
+ *  routes TS comparisons/logicals through `OP_MAP` (`===`→`=`, `&&`→`∧`, `!`→`¬`)
+ *  so these top-level ops land in Prop. `in` stays Bool (emits `.contains`), and
+ *  bare method calls / vars / field accesses remain at their declared type. */
+function isPropValued(e) {
+    switch (e.kind) {
+        case "binop":
+            return ["=", "≠", "≥", "≤", ">", "<", "∧", "∨"].includes(e.op);
+        case "unop":
+            return e.op === "¬";
+        case "implies":
+        case "forall":
+        case "exists":
+            return true;
+        default:
+            return false;
+    }
+}
 // ── Statement emission ──────────────────────────────────────
 function emitStmts(stmts, indent) {
     const pad = "  ".repeat(indent);
@@ -207,7 +268,18 @@ function emitStmt(s, indent) {
         case "ghostLet":
             return `${pad}let mut ${escapeName(s.name)} : ${tyToLean(s.type)} := ${emitExpr(s.value)}`;
         case "ghostAssign": return `${pad}${escapeName(s.target)} := ${emitExpr(s.value)}`;
-        case "assert": return `${pad}assertGadget (${emitExpr(s.expr)})`;
+        case "assert": {
+            if (s.assumed)
+                throw new Error("//@ assume: not supported in Lean backend.");
+            // WPGen.assert needs a Prop; bare Bool expressions (`k in m` → `.contains`,
+            // method calls, vars) lack a matching WPGen instance and silently fall back
+            // to WPGen.default, which drops the assertion. Coerce to Prop via `= true`.
+            // Top-level Prop constructs (`=`, `<`, `∧`, `¬`, `∀`, `∃`, `→`) already
+            // land in Prop — Lean auto-coerces inner Bools there.
+            const inner = emitExpr(s.expr);
+            const wrapped = isPropValued(s.expr) ? inner : `(${inner}) = true`;
+            return `${pad}assertGadget (${wrapped})`;
+        }
         case "bind": return `${pad}${escapeName(s.target)} ← ${emitExpr(s.value)}`;
         case "let-bind": return `${pad}let ${s.name} ← ${emitExpr(s.value)}`;
         case "return": return `${pad}return ${emitExpr(s.value)}`;
@@ -349,6 +421,10 @@ function emitDecl(d) {
             throw new Error(`Lean class support not yet implemented: ${d.name}`);
         case "const":
             return `def ${escapeName(d.name)} : ${tyToLean(d.type)} := ${emitExpr(d.value)}`;
+        case "extern":
+            // Lean: emit an opaque function declaration. The user is expected to
+            // provide an axiomatic body or a stub in the companion spec file.
+            throw new Error(`Lean extern support not yet implemented: ${d.name}`);
     }
 }
 /** Emit a pure expression with indented if/match blocks. */

package/tools/dist/lsc.js

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