lemmascript 0.2.0 → 0.3.0

package/tools/dist/lean-emit.js

@@ -51,7 +51,7 @@ function escapeName(name) {
 const PREC = {
     "→": 1, "∨": 2, "∧": 3,
     "=": 4, "≠": 4, "≥": 4, "≤": 4, ">": 4, "<": 4,
-    "+": 5, "-": 5, "*": 6, "/": 6, "%": 6,
+    "+": 5, "-": 5, "++": 5, "arrayConcat": 5, "*": 6, "/": 6, "%": 6,
 };
 function prec(op) { return PREC[op] ?? 10; }
 // ── Method call → Lean syntax ───────────────────────────────
@@ -143,7 +143,8 @@ function emitExpr(e, parentPrec) {
                 return `-${e.expr.value}`;
             return `(-${emitExpr(e.expr)})`;
         case "binop": {
-            const s = `${emitExpr(e.left, prec(e.op))} ${e.op} ${emitExpr(e.right, prec(e.op))}`;
+            const op = e.op === "arrayConcat" ? "++" : e.op;
+            const s = `${emitExpr(e.left, prec(e.op))} ${op} ${emitExpr(e.right, prec(e.op))}`;
             return (parentPrec !== undefined && prec(e.op) < parentPrec) ? `(${s})` : s;
         }
         case "implies": {
@@ -317,6 +318,9 @@ function emitDecl(d) {
                 lines.push(`deriving ${d.deriving.join(", ")}`);
             return lines.join("\n");
         }
+        case "type-alias": {
+            return `abbrev ${d.name} := ${tyToLean(d.target)}`;
+        }
         case "def": {
             const params = d.params.map(p => `(${escapeName(p.name)} : ${tyToLean(p.type)})`).join(" ");
             return `def ${d.name} ${params} : ${tyToLean(d.returnType)} :=\n${emitPureExpr(d.body, 1)}`;

package/tools/dist/lsc.js

@@ -9,7 +9,7 @@ import { existsSync } from "fs";
 import path from "path";
 import { extractModule } from "./extract.js";
 import { resolveModule } from "./resolve.js";
-import { transformModule, transformModuleDafny } from "./transform.js";
+import { transformModuleLean, transformModuleDafny } from "./transform.js";
 import { emitLeanFile } from "./lean-emit.js";
 import { emitDafnyFile } from "./dafny-emit.js";
 import { dafnyGen, dafnyCheckDiff, dafnyVerify, dafnyRegen } from "./dafny-commands.js";
@@ -17,7 +17,7 @@ import { leanGen, leanCheck } from "./lean-commands.js";
 function main() {
     const args = process.argv.slice(2);
     const backendIdx = args.findIndex(a => a.startsWith("--backend="));
-    let backend = "lean";
+    let backend = "dafny";
     if (backendIdx >= 0) {
         const val = args[backendIdx].split("=")[1];
         if (val !== "lean" && val !== "dafny") {
@@ -43,8 +43,25 @@ function main() {
         console.error(`File not found: ${absPath}`);
         process.exit(1);
     }
-    const project = new Project({ compilerOptions: { strict: true, target: ScriptTarget.ESNext, lib: ["lib.esnext.d.ts"] } });
+    // Find nearest tsconfig.json for import resolution; fall back to bare options
+    function findTsConfig(from) {
+        let dir = path.dirname(from);
+        while (true) {
+            const candidate = path.join(dir, "tsconfig.json");
+            if (existsSync(candidate))
+                return candidate;
+            const parent = path.dirname(dir);
+            if (parent === dir)
+                return undefined;
+            dir = parent;
+        }
+    }
+    const tsConfigFilePath = findTsConfig(absPath);
+    const project = tsConfigFilePath
+        ? new Project({ tsConfigFilePath })
+        : 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) {
@@ -98,7 +115,7 @@ function main() {
     // ── Lean backend ──────────────────────────────────────────
     const specPath = path.join(dir, `${base}.spec.lean`);
     const specImport = existsSync(specPath) ? `«${base}.spec»` : undefined;
-    const { typesFile, defFile } = transformModule(typed, specImport);
+    const { typesFile, defFile } = transformModuleLean(typed, specImport);
     const typesPath = typesFile ? path.join(dir, `${base}.types.lean`) : null;
     const typesText = typesFile ? emitLeanFile(typesFile) : null;
     const defPath = path.join(dir, `${base}.def.lean`);

package/tools/dist/resolve.js

@@ -6,6 +6,72 @@
  */
 import { parseTsType } from "./types.js";
 import { parseExpr } from "./specparser.js";
+// ── Raw expression substitution ─────────────────────────────
+let _synVarCounter = 0;
+/**
+ * Structural equality for raw field-access chains (var and field nodes only).
+ * Exact within a single expression scope — raw IR has no bindings that could
+ * cause name collisions (those are introduced by resolve, which runs after).
+ */
+function rawExprEquals(a, b) {
+    if (a.kind === "var" && b.kind === "var")
+        return a.name === b.name;
+    if (a.kind === "field" && b.kind === "field")
+        return a.field === b.field && rawExprEquals(a.obj, b.obj);
+    if (a.kind === "call" && b.kind === "call")
+        return rawExprEquals(a.fn, b.fn) && a.args.length === b.args.length && a.args.every((arg, i) => rawExprEquals(arg, b.args[i]));
+    if (a.kind === "index" && b.kind === "index")
+        return rawExprEquals(a.obj, b.obj) && rawExprEquals(a.idx, b.idx);
+    return false;
+}
+/** Return the root variable name of a field-access chain, or null. */
+function rawChainRoot(e) {
+    if (e.kind === "var")
+        return e.name;
+    if (e.kind === "field")
+        return rawChainRoot(e.obj);
+    return null;
+}
+/**
+ * Replace all occurrences of `target` in `expr` with `replacement`.
+ * Only matches field-access chains (see rawExprEquals). Stops at lambda
+ * boundaries that shadow the chain's root variable.
+ */
+function substituteRawExpr(expr, target, replacement) {
+    if (rawExprEquals(expr, target))
+        return replacement;
+    const root = rawChainRoot(target);
+    const sub = (e) => substituteRawExpr(e, target, replacement);
+    switch (expr.kind) {
+        case "var":
+        case "num":
+        case "str":
+        case "bool":
+        case "result":
+        case "havoc":
+        case "emptyCollection":
+            return expr;
+        case "binop": return { ...expr, left: sub(expr.left), right: sub(expr.right) };
+        case "unop": return { ...expr, expr: sub(expr.expr) };
+        case "call": return { ...expr, fn: sub(expr.fn), args: expr.args.map(sub) };
+        case "field": return { ...expr, obj: sub(expr.obj) };
+        case "index": return { ...expr, obj: sub(expr.obj), idx: sub(expr.idx) };
+        case "record":
+            return { ...expr, spread: expr.spread ? sub(expr.spread) : null,
+                fields: expr.fields.map(f => ({ ...f, value: sub(f.value) })) };
+        case "arrayLiteral": return { ...expr, elems: expr.elems.map(sub) };
+        case "conditional": return { ...expr, cond: sub(expr.cond), then: sub(expr.then), else: sub(expr.else) };
+        case "nonNull": return { ...expr, expr: sub(expr.expr) };
+        case "forall":
+        case "exists":
+            return { ...expr, body: sub(expr.body) };
+        case "lambda":
+            // Don't cross lambda boundaries that shadow the chain's root variable
+            if (root && expr.params.some(p => p.name === root))
+                return expr;
+            return { ...expr, body: Array.isArray(expr.body) ? expr.body : sub(expr.body) };
+    }
+}
 function lookup(env, name) {
     if (!env)
         return undefined;
@@ -162,18 +228,28 @@ function resolveExpr(e, ctx) {
         }
         case "binop": {
             let left = resolveExpr(e.left, ctx);
-            let right = resolveExpr(e.right, ctx);
+            // && narrowing: if left is "x !== undefined", narrow x for right side
+            let rightCtx = ctx;
+            if (e.op === "&&") {
+                const narrowed = narrowOptional(e.left, ctx.env);
+                if (narrowed && narrowed.inThen) {
+                    rightCtx = withEnv(ctx, extend(ctx.env, narrowed.varName, narrowed.innerTy));
+                }
+            }
+            let right = resolveExpr(e.right, rightCtx);
             if (e.op === "===" || e.op === "!==") {
                 left = coerceStr(left, right.ty);
                 right = coerceStr(right, left.ty);
             }
             let ty = { kind: "unknown" };
-            if (["===", "!==", ">=", "<=", ">", "<"].includes(e.op))
+            if (["===", "!==", ">=", "<=", ">", "<", "in"].includes(e.op))
                 ty = { kind: "bool" };
             else if (e.op === "&&")
                 ty = right.ty;
-            else if (e.op === "||" && left.ty.kind === "optional")
-                ty = left.ty.inner;
+            else if (e.op === "||" && left.ty.kind === "optional") {
+                // || undefined is identity for optionals — keep the optional type
+                ty = (e.right.kind === "var" && e.right.name === "undefined") ? left.ty : left.ty.inner;
+            }
             else if (e.op === "||")
                 ty = right.ty;
             else if (["+", "-", "*", "/", "%"].includes(e.op)) {
@@ -187,12 +263,41 @@ function resolveExpr(e, ctx) {
         }
         case "call": {
             const fn = resolveExpr(e.fn, ctx);
-            let args = e.args.map(a => resolveExpr(a, ctx));
-            // Coerce non-optional args to Option when callee expects optional param: wrap in Some
+            // Infer lambda param types from array method context (map, filter, etc.)
+            let rawArgs = e.args;
+            if (fn.kind === "field" && fn.obj.ty.kind === "array" &&
+                ["map", "filter", "every", "some", "find"].includes(fn.field) &&
+                rawArgs.length >= 1 && rawArgs[0].kind === "lambda" &&
+                rawArgs[0].params.length >= 1 && !rawArgs[0].params[0].tsType) {
+                const elemTy = fn.obj.ty.elem;
+                const tsType = elemTy.kind === "user" ? elemTy.name
+                    : elemTy.kind === "string" ? "string"
+                        : elemTy.kind === "int" || elemTy.kind === "nat" ? "number"
+                            : elemTy.kind === "bool" ? "boolean" : undefined;
+                if (tsType) {
+                    const lam = rawArgs[0];
+                    const updatedParams = [{ ...lam.params[0], tsType }, ...lam.params.slice(1)];
+                    rawArgs = [{ ...lam, params: updatedParams }, ...rawArgs.slice(1)];
+                }
+            }
+            // For .push() on a typed array, resolve the argument with element type context
+            // so record expressions can match fields and coerce types
+            let argCtx = ctx;
+            if (fn.kind === "field" && fn.obj.ty.kind === "array" && fn.field === "push" &&
+                fn.obj.ty.elem.kind === "user") {
+                argCtx = { ...ctx, returnTy: fn.obj.ty.elem };
+            }
+            let args = rawArgs.map(a => resolveExpr(a, argCtx));
+            // Coerce args: string literals to user types, non-optional to Option, pad missing optional args
             if (fn.kind === "var" && ctx.fnParams.has(fn.name)) {
                 const paramTys = ctx.fnParams.get(fn.name);
                 args = args.map((a, i) => {
-                    if (i < paramTys.length && a.ty.kind !== "optional" && paramTys[i].kind === "optional") {
+                    if (i >= paramTys.length)
+                        return a;
+                    // Coerce string literal to user type (e.g., 'MissingList' → Err constructor)
+                    a = coerceStr(a, paramTys[i]);
+                    // Wrap non-optional in Some when callee expects optional param
+                    if (a.ty.kind !== "optional" && paramTys[i].kind === "optional") {
                         return {
                             kind: "call",
                             fn: { kind: "var", name: "Some", ty: paramTys[i] },
@@ -203,6 +308,12 @@ function resolveExpr(e, ctx) {
                     }
                     return a;
                 });
+                // Pad missing optional args with None
+                for (let i = args.length; i < paramTys.length; i++) {
+                    if (paramTys[i].kind === "optional") {
+                        args.push({ kind: "var", name: "undefined", ty: paramTys[i] });
+                    }
+                }
             }
             let ty = { kind: "unknown" };
             // Infer return types for collection methods
@@ -213,6 +324,8 @@ function resolveExpr(e, ctx) {
                     ty = { kind: "bool" };
                 else if (fn.field === "set")
                     ty = fn.obj.ty;
+                else if (fn.field === "delete")
+                    ty = fn.obj.ty;
             }
             else if (fn.kind === "field" && fn.obj.ty.kind === "set") {
                 if (fn.field === "has")
@@ -229,6 +342,17 @@ function resolveExpr(e, ctx) {
                     ty = fn.obj.ty.elem;
                 else if (fn.field === "push")
                     ty = fn.obj.ty;
+                else if (fn.field === "concat")
+                    ty = fn.obj.ty;
+                else if (fn.field === "map" && args.length >= 1 && args[0].kind === "lambda") {
+                    const retTy = args[0].body.length > 0 && args[0].body[0].kind === "return"
+                        ? args[0].body[0].value.ty : { kind: "unknown" };
+                    ty = { kind: "array", elem: retTy };
+                }
+                else if (fn.field === "filter")
+                    ty = fn.obj.ty;
+                else if (fn.field === "every" || fn.field === "some")
+                    ty = { kind: "bool" };
             }
             else if (fn.kind === "field" && fn.obj.ty.kind === "string") {
                 if (fn.field === "trim")
@@ -245,7 +369,10 @@ function resolveExpr(e, ctx) {
         case "index": {
             const obj = resolveExpr(e.obj, ctx);
             const idx = resolveExpr(e.idx, ctx);
-            return { kind: "index", obj, idx, ty: obj.ty.kind === "array" ? obj.ty.elem : { kind: "unknown" } };
+            const idxTy = obj.ty.kind === "array" ? obj.ty.elem
+                : obj.ty.kind === "map" ? obj.ty.value
+                    : { kind: "unknown" };
+            return { kind: "index", obj, idx, ty: idxTy };
         }
         case "field": {
             const obj = resolveExpr(e.obj, ctx);
@@ -275,11 +402,23 @@ function resolveExpr(e, ctx) {
             // Infer record type: from spread, or from return type context
             const recordTy = ty.kind === "user" ? ty : ctx.returnTy.kind === "user" ? ctx.returnTy : null;
             const decl = recordTy ? ctx.typeDecls.find(d => d.name === recordTy.name && d.kind === "record") : undefined;
+            // Clear returnTy for field values — it applies to THIS record, not nested ones
+            const fieldCtx = recordTy ? { ...ctx, returnTy: { kind: "unknown" } } : ctx;
             const fields = e.fields.map(f => {
-                let value = resolveExpr(f.value, ctx);
+                let value = resolveExpr(f.value, fieldCtx);
                 const fieldDecl = decl?.fields?.find(df => df.name === f.name);
-                if (fieldDecl)
-                    value = coerceStr(value, parseTsType(fieldDecl.tsType));
+                if (fieldDecl) {
+                    const declTy = parseTsType(fieldDecl.tsType);
+                    value = coerceStr(value, 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 = {
+                            kind: "call",
+                            fn: { kind: "var", name: "Some", ty: declTy },
+                            args: [value], ty: declTy, callKind: "pure",
+                        };
+                    }
+                }
                 return { name: f.name, value };
             });
             return { kind: "record", spread, fields, ty: recordTy ?? ty };
@@ -289,12 +428,12 @@ function resolveExpr(e, ctx) {
                 throw new Error("\\result is only valid in ensures");
             return { kind: "result", ty: ctx.returnTy };
         case "forall": {
-            const varTy = e.varType === "nat" ? { kind: "nat" }
+            const varTy = e.varType !== "int" ? parseTsType(e.varType)
                 : inferQuantVarType(e.var, e.body, ctx) ?? { kind: "int" };
             return { kind: "forall", var: e.var, varTy, body: resolveExpr(e.body, withEnv(ctx, extend(ctx.env, e.var, varTy))), ty: { kind: "bool" } };
         }
         case "exists": {
-            const varTy = e.varType === "nat" ? { kind: "nat" }
+            const varTy = e.varType !== "int" ? parseTsType(e.varType)
                 : inferQuantVarType(e.var, e.body, ctx) ?? { kind: "int" };
             return { kind: "exists", var: e.var, varTy, body: resolveExpr(e.body, withEnv(ctx, extend(ctx.env, e.var, varTy))), ty: { kind: "bool" } };
         }
@@ -322,16 +461,61 @@ function resolveExpr(e, ctx) {
         }
         case "conditional": {
             const cond = resolveExpr(e.cond, ctx);
-            let then_ = resolveExpr(e.then, ctx);
+            // Optional truthiness: opt ? X : Y
+            // Narrow the optional to its inner type in the then-branch so that
+            // field accesses resolve correctly (e.g. entry.decision.field).
+            let narrowedVar;
+            let narrowedExprResolved;
+            let thenCtx = ctx;
+            let rawThen = e.then;
+            if (cond.ty.kind === "optional") {
+                const innerTy = cond.ty.inner;
+                if (e.cond.kind === "var") {
+                    narrowedVar = e.cond.name;
+                    thenCtx = withEnv(ctx, extend(ctx.env, e.cond.name, innerTy));
+                }
+                else {
+                    narrowedVar = `_opt${_synVarCounter++}`;
+                    rawThen = substituteRawExpr(e.then, e.cond, { kind: "var", name: narrowedVar });
+                    thenCtx = withEnv(ctx, extend(ctx.env, narrowedVar, innerTy));
+                }
+            }
+            // Explicit optional check: x !== undefined ? expr(x) : undefined
+            // Narrow x to its inner type in the then-branch.
+            if (!narrowedVar) {
+                const narrowed = narrowOptional(e.cond, ctx.env);
+                if (narrowed && narrowed.inThen) {
+                    narrowedVar = narrowed.varName;
+                    thenCtx = withEnv(ctx, extend(ctx.env, narrowed.varName, narrowed.innerTy));
+                }
+                // Handle complex optional expressions: f() !== undefined ? f().field : undefined
+                if (!narrowedVar && e.cond.kind === "binop" && e.cond.op === "!==" &&
+                    e.cond.right.kind === "var" && e.cond.right.name === "undefined") {
+                    const optExpr = e.cond.left;
+                    const resolvedOpt = resolveExpr(optExpr, ctx);
+                    if (resolvedOpt.ty.kind === "optional") {
+                        narrowedVar = `_opt${_synVarCounter++}`;
+                        narrowedExprResolved = resolvedOpt;
+                        rawThen = substituteRawExpr(e.then, optExpr, { kind: "var", name: narrowedVar });
+                        thenCtx = withEnv(ctx, extend(ctx.env, narrowedVar, resolvedOpt.ty.inner));
+                    }
+                }
+            }
+            let then_ = resolveExpr(rawThen, thenCtx);
             let else_ = resolveExpr(e.else, ctx);
             then_ = coerceStr(then_, else_.ty);
             else_ = coerceStr(else_, then_.ty);
-            const ty = then_.ty.kind !== "unknown" ? then_.ty : else_.ty;
-            return { kind: "conditional", cond, then: then_, else: else_, ty };
+            let ty = then_.ty.kind !== "unknown" ? then_.ty : else_.ty;
+            // When narrowedExpr is set, the transform will emit a match producing Optional
+            if (narrowedExprResolved && ty.kind !== "optional") {
+                ty = { kind: "optional", inner: ty };
+            }
+            return { kind: "conditional", cond, then: then_, else: else_, ty, narrowedVar, narrowedExpr: narrowedExprResolved };
         }
         case "emptyCollection": {
             const ty = parseTsType(e.tsType);
-            return { kind: "arrayLiteral", elems: [], ty };
+            const elems = e.initElems ? e.initElems.map(el => resolveExpr(el, ctx)) : [];
+            return { kind: "arrayLiteral", elems, ty };
         }
         case "havoc":
             return { kind: "havoc", ty: resolveTsType(e.tsType, ctx.overrides) };
@@ -379,8 +563,20 @@ function resolveStmt(s, ctx) {
             const targetTy = lookup(ctx.env, s.target) ?? { kind: "unknown" };
             return [{ kind: "assign", target: s.target, value: coerceStr(resolveExpr(s.value, ctx), targetTy) }, ctx.env];
         }
-        case "return":
-            return [{ kind: "return", value: coerceStr(resolveExpr(s.value, ctx), ctx.returnTy) }, ctx.env];
+        case "return": {
+            let value = coerceStr(resolveExpr(s.value, ctx), ctx.returnTy);
+            // Wrap non-optional return value in Some when function returns optional
+            // Skip if already optional, void, or undefined (which maps to None)
+            const isUndef = value.kind === "var" && value.name === "undefined";
+            if (ctx.returnTy.kind === "optional" && value.ty.kind !== "optional" && !isUndef) {
+                value = {
+                    kind: "call",
+                    fn: { kind: "var", name: "Some", ty: ctx.returnTy },
+                    args: [value], ty: ctx.returnTy, callKind: "pure",
+                };
+            }
+            return [{ kind: "return", value }, ctx.env];
+        }
         case "break":
             return [{ kind: "break" }, ctx.env];
         case "continue":
@@ -398,6 +594,13 @@ function resolveStmt(s, ctx) {
                 else
                     elseCtx = withEnv(ctx, env);
             }
+            // Also narrow from left side of && condition: if (x !== undefined && ...) { ... }
+            if (!narrowed && s.cond.kind === "binop" && s.cond.op === "&&") {
+                const leftNarrowed = narrowOptional(s.cond.left, ctx.env);
+                if (leftNarrowed && leftNarrowed.inThen) {
+                    thenCtx = withEnv(ctx, extend(ctx.env, leftNarrowed.varName, leftNarrowed.innerTy));
+                }
+            }
             return [{ kind: "if", cond: resolveExpr(s.cond, ctx), then: resolveBlock(s.then, thenCtx), else: resolveBlock(s.else, elseCtx) }, ctx.env];
         }
         case "while": {
@@ -483,7 +686,7 @@ function isSyntacticallyPure(stmts) {
             case "while":
             case "forof": return false;
             case "let":
-                if (s.mutable)
+                if (s.mutable || s.init.kind === "havoc")
                     return false;
                 break;
             case "if":
@@ -645,9 +848,6 @@ function containsReturn(stmts) {
 }
 // ── Resolve function / module ────────────────────────────────
 function resolveFunction(fn, typeDecls, pureFns, fnParams = new Map()) {
-    if (hasReturnInLoop(fn.body)) {
-        throw new Error(`${fn.name}: return inside a loop is not supported.`);
-    }
     const overrides = new Map(fn.typeAnnotations.map(a => [a.name, a.type]));
     const params = fn.params.map(p => ({ name: p.name, ty: resolveTsType(p.tsType, overrides, p.name) }));
     const returnTy = resolveTsType(fn.returnType, overrides, "\\result");
@@ -658,7 +858,7 @@ function resolveFunction(fn, typeDecls, pureFns, fnParams = new Map()) {
     const requiresCtx = { ...baseCtx, inSpec: true };
     const ensuresCtx = { ...baseCtx, allowResult: true, inSpec: true };
     return {
-        name: fn.name, params, returnTy,
+        name: fn.name, typeParams: fn.typeParams, params, returnTy,
         requires: resolveSpecs(fn.requires, requiresCtx),
         ensures: resolveSpecs(fn.ensures, ensuresCtx),
         isPure: pureFns.has(fn.name),
@@ -684,7 +884,7 @@ function resolveClass(cls, typeDecls, pureFns, fnParams = new Map()) {
         const requiresCtx = { ...baseCtx, inSpec: true };
         const ensuresCtx = { ...baseCtx, allowResult: true, inSpec: true };
         return {
-            name: fn.name, params, returnTy,
+            name: fn.name, typeParams: fn.typeParams, params, returnTy,
             requires: resolveSpecs(fn.requires, requiresCtx),
             ensures: resolveSpecs(fn.ensures, ensuresCtx),
             isPure: false, // class methods are never pure (they access this)

package/tools/dist/specparser.js

@@ -129,6 +129,11 @@ class Parser {
     parseCmp() {
         const left = this.parseAdd();
         const t = this.peek();
+        // 'in' as infix membership operator (set/seq/map): x in S
+        if (t?.type === "ident" && t.value === "in") {
+            this.advance();
+            return { kind: "binop", op: "in", left, right: this.parseAdd() };
+        }
         if (t?.type === "op" && ["===", "!==", "==", "!=", ">=", "<=", ">", "<"].includes(t.value)) {
             this.advance();
             // Normalize == to ===, != to !== so downstream sees one spelling
@@ -252,8 +257,6 @@ class Parser {
                 let varType = "int";
                 if (this.match("punc", ":")) {
                     const ty = this.expect("ident").value;
-                    if (ty !== "nat" && ty !== "int")
-                        throw new Error(`Unknown type '${ty}'`);
                     varType = ty;
                 }
                 this.expect("punc", ",");