lemmascript 0.3.1 → 0.3.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "lemmascript",
-  "version": "0.3.1",
+  "version": "0.3.2",
   "description": "A verification toolchain for TypeScript — generates Lean 4 or Dafny from annotated TS",
   "type": "module",
   "bin": {

package/tools/dist/dafny-emit.js

@@ -94,6 +94,10 @@ function emitExpr(e) {
                     return `${obj}[${args[0]} := ${args[1]}]`;
                 if (e.method === "includes")
                     return `(${args[0]} in ${obj})`;
+                if (e.method === "indexOf") {
+                    needPreamble("SeqIndexOf");
+                    return `SeqIndexOf(${obj}, ${args[0]})`;
+                }
                 if (e.method === "push")
                     return `(${obj} + [${args[0]}])`;
                 if (e.method === "concat")
@@ -565,6 +569,25 @@ const CEIL_REAL = `function CeilReal(x: real): int
   if x == (x.Floor as real) then x.Floor
   else x.Floor + 1
 }`;
+const SEQ_INDEX_OF = `function SeqIndexOf<T(==)>(s: seq<T>, x: T): int
+  ensures -1 <= SeqIndexOf(s, x) < |s|
+  ensures SeqIndexOf(s, x) >= 0 ==> s[SeqIndexOf(s, x)] == x
+  ensures SeqIndexOf(s, x) == -1 ==> x !in s
+{
+  SeqIndexOfFrom(s, x, 0)
+}
+
+function SeqIndexOfFrom<T(==)>(s: seq<T>, x: T, from: nat): int
+  requires from <= |s|
+  ensures -1 <= SeqIndexOfFrom(s, x, from) < |s|
+  ensures SeqIndexOfFrom(s, x, from) >= 0 ==> s[SeqIndexOfFrom(s, x, from)] == x
+  ensures SeqIndexOfFrom(s, x, from) == -1 ==> forall i :: from <= i < |s| ==> s[i] != x
+  decreases |s| - from
+{
+  if from == |s| then -1
+  else if s[from] == x then from as int
+  else SeqIndexOfFrom(s, x, from + 1)
+}`;
 const STRING_INDEX_OF = `function StringIndexOf(s: string, sub: string): int
 {
   StringIndexOfFrom(s, sub, 0)
@@ -656,6 +679,7 @@ const PREAMBLE_CODE = [
     ["JSFloorDiv", JS_FLOOR_DIV],
     ["CeilReal", CEIL_REAL],
     ["FloorReal", FLOOR_REAL],
+    ["SeqIndexOf", SEQ_INDEX_OF],
     ["StringIndexOf", STRING_INDEX_OF],
     ["StringTrim", STRING_TRIM],
     ["StringToLower", STRING_TO_LOWER],

package/tools/dist/extract.js

@@ -196,6 +196,7 @@ function extractExpr(node) {
     if (Node.isObjectLiteralExpression(node)) {
         let spread = null;
         const fields = [];
+        const computedFields = [];
         for (const prop of node.getProperties()) {
             if (Node.isSpreadAssignment(prop)) {
                 spread = extractExpr(prop.getExpression());
@@ -205,10 +206,26 @@ function extractExpr(node) {
                 fields.push({ name, value: { kind: "var", name } });
             }
             else if (Node.isPropertyAssignment(prop)) {
+                const nameNode = prop.getNameNode();
                 const init = prop.getInitializer();
-                if (init)
+                if (init && Node.isComputedPropertyName(nameNode)) {
+                    computedFields.push({ key: extractExpr(nameNode.getExpression()), value: extractExpr(init) });
+                }
+                else if (init) {
                     fields.push({ name: prop.getName(), value: extractExpr(init) });
+                }
+            }
+        }
+        // Desugar computed keys: { ...base, [k]: v } → base.set(k, v)
+        // No spread: { [k]: v } → {}.set(k, v) (empty map base)
+        if (computedFields.length > 0) {
+            let result = spread ?? { kind: "record", spread: null, fields: [] };
+            for (const cf of computedFields) {
+                result = { kind: "call",
+                    fn: { kind: "field", obj: result, field: "set" },
+                    args: [cf.key, cf.value] };
             }
+            return result;
         }
         return { kind: "record", spread, fields };
     }
@@ -234,8 +251,9 @@ function extractExpr(node) {
             if (name === "Map" && args && args.length === 1) {
                 const argType = args[0].getType();
                 const argSymbol = argType.getSymbol()?.getName() ?? argType.getAliasSymbol()?.getName();
-                if (argSymbol === "Map") {
-                    // new Map(existingMap) — identity (Dafny maps are value types)
+                const argTypeText = _eraseGenerics(typeToString(argType));
+                if (argSymbol === "Map" || argTypeText.startsWith("Record<")) {
+                    // new Map(existingMap) or new Map(record) — identity (Dafny maps are value types)
                     return extractExpr(args[0]);
                 }
                 // new Map(entries) — map-from-array constructor
@@ -257,6 +275,17 @@ function extractExpr(node) {
     if (Node.isAsExpression(node)) {
         return extractExpr(node.getExpression());
     }
+    // delete obj[key] → map delete expression
+    if (Node.isDeleteExpression(node)) {
+        const expr = node.getExpression();
+        if (Node.isElementAccessExpression(expr)) {
+            return {
+                kind: "call",
+                fn: { kind: "field", obj: extractExpr(expr.getExpression()), field: "delete" },
+                args: [extractExpr(expr.getArgumentExpression())],
+            };
+        }
+    }
     // null → undefined (both map to None in backends)
     if (Node.isNullLiteral(node)) {
         return { kind: "var", name: "undefined" };
@@ -511,6 +540,38 @@ function extractStmts(stmts) {
                     }
                     continue;
                 }
+                // Destructuring rest: const { [k]: _, ...rest } = map → let rest = map.delete(k)
+                if (!isHavoc && Node.isObjectBindingPattern(nameNode)) {
+                    const elements = nameNode.getElements();
+                    const restEl = elements.find(el => el.getDotDotDotToken());
+                    const computedEls = elements.filter(el => {
+                        const pn = el.getPropertyNameNode();
+                        return pn && Node.isComputedPropertyName(pn);
+                    });
+                    if (restEl && computedEls.length > 0) {
+                        const initializer = d.getInitializer();
+                        if (initializer) {
+                            let deleteInit = extractExpr(initializer);
+                            for (const cel of computedEls) {
+                                const pn = cel.getPropertyNameNode();
+                                const keyExpr = extractExpr(pn.getExpression());
+                                deleteInit = { kind: "call",
+                                    fn: { kind: "field", obj: deleteInit, field: "delete" },
+                                    args: [keyExpr] };
+                            }
+                            const declType = d.getType();
+                            result.push({
+                                kind: "let",
+                                name: restEl.getName(),
+                                mutable: s.getDeclarationKind() === "let",
+                                tsType: _eraseGenerics(typeToString(declType)),
+                                init: deleteInit,
+                                line,
+                            });
+                            continue;
+                        }
+                    }
+                }
                 const declType = d.getType();
                 let init;
                 if (isHavoc && !havocKey) {
@@ -585,6 +646,27 @@ function extractStmts(stmts) {
             });
             continue;
         }
+        // for...in: for (const k in obj) → treat as forof with single key name
+        if (Node.isForInStatement(s)) {
+            const init = s.getInitializer();
+            let name = "_";
+            if (Node.isVariableDeclarationList(init)) {
+                name = init.getDeclarations()[0]?.getName() ?? "_";
+            }
+            const bodyNode = s.getStatement();
+            const bodyStmts = Node.isBlock(bodyNode) ? bodyNode.getStatements() : [bodyNode];
+            const annots = collectAnnotations(s, bodyStmts);
+            result.push({
+                kind: "forof",
+                names: [name],
+                iterable: extractExpr(s.getExpression()),
+                invariants: annots.filter(a => a.kind === "invariant").map(a => a.expr),
+                doneWith: annots.find(a => a.kind === "done_with")?.expr ?? null,
+                body: extractStmts(bodyStmts),
+                line,
+            });
+            continue;
+        }
         if (Node.isIfStatement(s)) {
             const thenNode = s.getThenStatement();
             const elseNode = s.getElseStatement();

package/tools/dist/resolve.js

@@ -293,6 +293,8 @@ function inferMethodReturnTy(fn, args, ctx) {
     else if (objTy.kind === "array") {
         if (fn.field === "includes")
             return { kind: "bool" };
+        if (fn.field === "indexOf")
+            return { kind: "int" };
         if (fn.field === "shift")
             return objTy.elem;
         if (fn.field === "push" || fn.field === "concat")
@@ -395,7 +397,7 @@ function resolveExpr(e, ctx) {
             const obj = resolveExpr(e.obj, ctx);
             const idx = resolveExpr(e.idx, ctx);
             const idxTy = obj.ty.kind === "array" ? obj.ty.elem
-                : obj.ty.kind === "map" ? obj.ty.value
+                : obj.ty.kind === "map" ? { kind: "optional", inner: obj.ty.value }
                     : { kind: "unknown" };
             return { kind: "index", obj, idx, ty: idxTy };
         }
@@ -445,6 +447,10 @@ function resolveExpr(e, ctx) {
                 if (fieldDecl) {
                     const declTy = fieldDecl.type;
                     value = coerceStr(value, declTy);
+                    // Empty {} for map-typed fields → empty map (arrayLiteral with map type → emptyMap in transform)
+                    if (value.kind === "record" && value.fields.length === 0 && !value.spread && declTy.kind === "map") {
+                        value = { kind: "arrayLiteral", elems: [], ty: declTy };
+                    }
                     // Coerce non-optional to optional: wrap in Some (only when value type is concrete)
                     if (declTy.kind === "optional" && value.ty.kind !== "optional" && value.ty.kind !== "void" && value.ty.kind !== "unknown") {
                         value = wrapSome(value, declTy);
@@ -593,8 +599,10 @@ function resolveBlock(stmts, ctx) {
 function resolveStmt(s, ctx) {
     switch (s.kind) {
         case "let": {
-            const ty = resolveTsType(s.tsType, ctx.overrides, s.name);
-            const init = coerceStr(resolveExpr(s.init, ctx), ty);
+            const declTy = resolveTsType(s.tsType, ctx.overrides, s.name);
+            const init = coerceStr(resolveExpr(s.init, ctx), declTy);
+            // Map indexing: TS says T, but access can fail → use Optional<T> from init
+            const ty = (declTy.kind !== "optional" && init.ty.kind === "optional") ? init.ty : declTy;
             // const collections are mutable in value-semantics world (TS mutates in place, Dafny/Lean reassign)
             const mutable = s.mutable || isRefMutableInTS(ty);
             return [{ kind: "let", name: s.name, ty, mutable, init }, extend(ctx.env, s.name, ty)];

package/tools/dist/transform.js

@@ -350,6 +350,9 @@ function lowerExpr(e, binds) {
             return { kind: "field", obj: transformExpr(e.obj), field: e.field };
         case "index": {
             const idx = transformExpr(e.idx);
+            if (e.obj.ty.kind === "map") {
+                return { kind: "methodCall", obj: transformExpr(e.obj), objTy: e.obj.ty, method: "get", args: [idx], monadic: false };
+            }
             const wrappedIdx = isArray(e.obj.ty) && !isNat(e.idx.ty) ? { kind: "toNat", expr: idx } : idx;
             return { kind: "index", arr: transformExpr(e.obj), idx: wrappedIdx };
         }
@@ -637,6 +640,31 @@ function transformStmts(stmts, typeDecls) {
             const varName = s.names[0];
             const varTy = s.nameTypes[0] ?? { kind: "unknown" };
             let iterExpr = transformExpr(s.iterable);
+            // Map key-only iteration: for (const k in record) → iterate keys only
+            if (s.names.length === 1 && s.iterable.ty.kind === "map") {
+                const keyName = s.names[0];
+                const keyTy = s.nameTypes[0] ?? s.iterable.ty.key ?? { kind: "unknown" };
+                const keysSeqName = `_${keyName}_keys`;
+                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 count = _forofCounters.get(keyName) ?? 0;
+                _forofCounters.set(keyName, count + 1);
+                const suffix = count === 0 ? "" : `${count + 1}`;
+                const idxName = `_${keyName}_idx${suffix}`;
+                const idx = { kind: "var", name: idxName };
+                const arrSize = { kind: "field", obj: keysVar, field: "size" };
+                const bodyStmts = transformStmts(s.body, typeDecls);
+                const letKey = { kind: "let", name: keyName, type: keyTy, mutable: false, value: { kind: "index", arr: keysVar, idx } };
+                const boundInv = { kind: "binop", op: "≤", left: idx, right: arrSize };
+                result.push({
+                    kind: "forin", idx: idxName, bound: arrSize,
+                    invariants: [boundInv, ...s.invariants.map(transformExpr)],
+                    body: [letKey, ...bodyStmts],
+                });
+                i++;
+                continue;
+            }
             // Map iteration: for (const [k, v] of map) → iterate keys, look up values
             if (s.names.length >= 2 && s.iterable.ty.kind === "map") {
                 const keyName = s.names[0], valueName = s.names[1];