lemmascript 0.5.18 → 0.5.19

package/tools/dist/peephole.js

@@ -1,4 +1,4 @@
-import { patternCtor, patternBinders } from "./ir.js";
+import { patternCtor, patternBinders, usesName, usesNameInStmts } from "./ir.js";
 // ── Generic walkers (same shape as transform.ts) ─────────────
 function mapExpr(e, f) {
     const hit = f(e);
@@ -8,6 +8,7 @@ function mapExpr(e, f) {
     switch (e.kind) {
         case "var":
         case "num":
+        case "bigint":
         case "bool":
         case "str":
         case "constructor":
@@ -31,7 +32,7 @@ function mapExpr(e, f) {
         case "arrayLiteral": return { ...e, elems: e.elems.map(r) };
         case "if": return { ...e, cond: r(e.cond), then: r(e.then), else: r(e.else) };
         case "match": {
-            const scr = typeof e.scrutinee === "string" ? e.scrutinee : r(e.scrutinee);
+            const scr = r(e.scrutinee);
             return { ...e, scrutinee: scr, arms: e.arms.map(a => ({ ...a, body: r(a.body) })) };
         }
         case "forall": return { ...e, body: r(e.body) };
@@ -70,7 +71,7 @@ function getSomeNoneArms(arms) {
  *  Bind once (let-expression) rather than substitute, so the verifier doesn't
  *  re-derive `k in m` at every use of v inside sb. */
 function ruleMatchOnMapGetExpr(e) {
-    if (e.kind !== "match" || typeof e.scrutinee === "string")
+    if (e.kind !== "match")
         return null;
     const get = isMapGet(e.scrutinee);
     if (!get)
@@ -130,15 +131,14 @@ function ruleLetMatchOnMapGetExpr(e) {
     if (e.body.kind !== "match")
         return null;
     const m = e.body;
-    const matchOnX = (typeof m.scrutinee === "string" && m.scrutinee === e.name) ||
-        (typeof m.scrutinee !== "string" && m.scrutinee.kind === "var" && m.scrutinee.name === e.name);
+    const matchOnX = m.scrutinee.kind === "var" && m.scrutinee.name === e.name;
     if (!matchOnX)
         return null;
     const arms = getSomeNoneArms(m.arms);
     if (!arms)
         return null;
     // x must not appear in arm bodies (otherwise the binding is needed)
-    if (containsVarRefExpr(arms.someArm.body, e.name) || containsVarRefExpr(arms.noneArm.body, e.name))
+    if (usesName(arms.someArm.body, e.name) || usesName(arms.noneArm.body, e.name))
         return null;
     const idx = { kind: "index", arr: get.obj, idx: get.key };
     const someBody = arms.binder
@@ -147,19 +147,6 @@ function ruleLetMatchOnMapGetExpr(e) {
     const has = { kind: "methodCall", obj: get.obj, objTy: get.objTy, method: "has", args: [get.key], monadic: false };
     return { kind: "if", cond: has, then: someBody, else: arms.noneArm.body };
 }
-function containsVarRefExpr(e, name) {
-    let found = false;
-    mapExpr(e, x => {
-        if (found)
-            return x;
-        if (x.kind === "var" && x.name === name) {
-            found = true;
-            return x;
-        }
-        return null;
-    });
-    return found;
-}
 function isBool(e, v) {
     return e.kind === "bool" && e.value === v;
 }
@@ -187,7 +174,7 @@ let EXPR_RULES = [...MAP_GET_RULES, ...BOOL_RULES];
  *  Bind once (var declaration) rather than substitute — substituting would
  *  re-evaluate m[k] at every use, changing semantics if the body mutates m. */
 function ruleMatchOnMapGetStmt(s) {
-    if (s.kind !== "match" || typeof s.scrutinee === "string")
+    if (s.kind !== "match")
         return null;
     const get = isMapGet(s.scrutinee);
     if (!get)
@@ -205,75 +192,6 @@ function ruleMatchOnMapGetStmt(s) {
 }
 const STMT_RULES = [ruleMatchOnMapGetStmt];
 // ── Variable use detection ───────────────────────────────────
-/** Conservative reference check: does any expression in this stmt mention `name`?
- *  Doesn't track shadowing — worst case, we miss an inlining opportunity.
- *  Used to gate let-inlining (only inline if the var is not used anywhere after). */
-function containsVarRefStmt(s, name) {
-    let found = false;
-    const checkExpr = (e) => {
-        if (found)
-            return;
-        mapExpr(e, x => {
-            if (x.kind === "var" && x.name === name) {
-                found = true;
-                return x;
-            }
-            return null;
-        });
-    };
-    const walk = (st) => {
-        if (found)
-            return;
-        switch (st.kind) {
-            case "let":
-            case "assign":
-            case "bind":
-            case "let-bind":
-            case "return":
-            case "ghostLet":
-            case "ghostAssign":
-                checkExpr(st.value);
-                return;
-            case "assert":
-                checkExpr(st.expr);
-                return;
-            case "break":
-            case "continue": return;
-            case "if":
-                checkExpr(st.cond);
-                st.then.forEach(walk);
-                st.else.forEach(walk);
-                return;
-            case "match":
-                if (typeof st.scrutinee === "string") {
-                    if (st.scrutinee === name) {
-                        found = true;
-                        return;
-                    }
-                }
-                else {
-                    checkExpr(st.scrutinee);
-                }
-                st.arms.forEach(a => a.body.forEach(walk));
-                return;
-            case "while":
-                checkExpr(st.cond);
-                st.invariants.forEach(checkExpr);
-                st.body.forEach(walk);
-                return;
-            case "forin":
-                checkExpr(st.bound);
-                st.invariants.forEach(checkExpr);
-                st.body.forEach(walk);
-                return;
-        }
-    };
-    walk(s);
-    return found;
-}
-function containsVarRefStmts(stmts, name) {
-    return stmts.some(s => containsVarRefStmt(s, name));
-}
 // ── Statement-list rules (pairs of adjacent stmts) ──────────
 /** Pair rule: let x = m.get(k); match x { Some(v) => sb, None => nb }
  *  → if k in m { var v := m[k]; sb } else { nb }
@@ -287,14 +205,13 @@ function tryLetMatchOnMapGet(s1, s2, restStmts) {
         return null;
     if (s2.kind !== "match")
         return null;
-    const matchOnX = (typeof s2.scrutinee === "string" && s2.scrutinee === s1.name) ||
-        (typeof s2.scrutinee !== "string" && s2.scrutinee.kind === "var" && s2.scrutinee.name === s1.name);
+    const matchOnX = s2.scrutinee.kind === "var" && s2.scrutinee.name === s1.name;
     if (!matchOnX)
         return null;
     const arms = getSomeNoneArms(s2.arms);
     if (!arms)
         return null;
-    if (containsVarRefStmts(restStmts, s1.name))
+    if (usesNameInStmts(restStmts, s1.name))
         return null;
     const idx = { kind: "index", arr: get.obj, idx: get.key };
     const valTy = get.objTy.kind === "map" ? get.objTy.value : { kind: "unknown" };
@@ -354,6 +271,7 @@ function rewriteChildrenExpr(e) {
     switch (e.kind) {
         case "var":
         case "num":
+        case "bigint":
         case "bool":
         case "str":
         case "constructor":
@@ -377,7 +295,7 @@ function rewriteChildrenExpr(e) {
         case "arrayLiteral": return { ...e, elems: e.elems.map(r) };
         case "if": return { ...e, cond: r(e.cond), then: r(e.then), else: r(e.else) };
         case "match": {
-            const scr = typeof e.scrutinee === "string" ? e.scrutinee : r(e.scrutinee);
+            const scr = r(e.scrutinee);
             return { ...e, scrutinee: scr, arms: e.arms.map(a => ({ ...a, body: r(a.body) })) };
         }
         case "forall": return { ...e, body: r(e.body) };
@@ -418,7 +336,7 @@ function rewriteChildrenStmt(s) {
         case "continue": return s;
         case "if": return { ...s, cond: re(s.cond), then: rs(s.then), else: rs(s.else) };
         case "match": {
-            const scr = typeof s.scrutinee === "string" ? s.scrutinee : re(s.scrutinee);
+            const scr = re(s.scrutinee);
             return { ...s, scrutinee: scr, arms: s.arms.map(a => ({ ...a, body: rs(a.body) })) };
         }
         case "while": return { ...s, cond: re(s.cond), invariants: s.invariants.map(re), body: rs(s.body) };

package/tools/dist/rawir.js

@@ -7,4 +7,18 @@
  * Layer 1: structured (no strings for expressions)
  * Layer 2 (planned): add Ty to each node
  */
-export {};
+// ── Expressions ──────────────────────────────────────────────
+/** Source text of a BigInt literal → the canonical decimal string stored in a
+ *  `bigint` node. Shared by the body extractor and the spec parser so both
+ *  sides of a function (code and `//@ ` annotations) agree exactly.
+ *
+ *  A BigInt literal must never pass through `Number`/`parseInt`: `9007199254740993n`
+ *  and `9007199254740992n` are distinct values that collapse to the same double.
+ *  Hence the string payload — it also keeps the raw IR `JSON.stringify`-able,
+ *  which `lsc extract` relies on. */
+export function normalizeBigIntLiteral(text) {
+    const withoutSuffix = text.endsWith("n") ? text.slice(0, -1) : text;
+    // BigInt() understands decimal, hex, binary, and octal; numeric separators
+    // are source syntax and must be stripped first.
+    return BigInt(withoutSuffix.replace(/_/g, "")).toString(10);
+}