lemmascript 0.2.0 → 0.3.0

package/tools/dist/transform.js

@@ -35,7 +35,10 @@ function mapExpr(e, f) {
         case "record": return { ...e, spread: e.spread ? r(e.spread) : null, fields: e.fields.map(fi => ({ ...fi, value: r(fi.value) })) };
         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": return { ...e, arms: e.arms.map(a => ({ ...a, body: r(a.body) })) };
+        case "match": {
+            const scr = typeof e.scrutinee === "string" ? e.scrutinee : 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) };
         case "exists": return { ...e, body: r(e.body) };
         case "let": return { ...e, value: r(e.value), body: r(e.body) };
@@ -66,6 +69,52 @@ function mapStmt(s, f) {
 function mapStmts(stmts, f) {
     return stmts.map(s => mapStmt(s, f));
 }
+/** Map over all sub-expressions in a TExpr (typed IR). */
+function mapTExpr(e, f) {
+    const hit = f(e);
+    if (hit)
+        return hit;
+    const r = (x) => mapTExpr(x, f);
+    switch (e.kind) {
+        case "var":
+        case "num":
+        case "str":
+        case "bool":
+        case "result":
+        case "havoc": return e;
+        case "binop": return { ...e, left: r(e.left), right: r(e.right) };
+        case "unop": return { ...e, expr: r(e.expr) };
+        case "call": return { ...e, fn: r(e.fn), args: e.args.map(r) };
+        case "index": return { ...e, obj: r(e.obj), idx: r(e.idx) };
+        case "field": return { ...e, obj: r(e.obj) };
+        case "record": return { ...e, spread: e.spread ? r(e.spread) : null, fields: e.fields.map(fi => ({ ...fi, value: r(fi.value) })) };
+        case "arrayLiteral": return { ...e, elems: e.elems.map(r) };
+        case "conditional": return { ...e, cond: r(e.cond), then: r(e.then), else: r(e.else) };
+        case "forall": return { ...e, body: r(e.body) };
+        case "exists": return { ...e, body: r(e.body) };
+        case "lambda": return e;
+    }
+}
+/** Map over all expressions in a TStmt tree (typed IR). */
+function mapTStmt(s, f) {
+    const r = (e) => mapTExpr(e, f);
+    switch (s.kind) {
+        case "let": return { ...s, init: r(s.init) };
+        case "assign": return { ...s, value: r(s.value) };
+        case "return": return { ...s, value: r(s.value) };
+        case "break":
+        case "continue":
+        case "throw": return s;
+        case "expr": return { ...s, expr: r(s.expr) };
+        case "if": return { ...s, cond: r(s.cond), then: s.then.map(t => mapTStmt(t, f)), else: s.else.map(t => mapTStmt(t, f)) };
+        case "while": return { ...s, cond: r(s.cond), invariants: s.invariants.map(r), body: s.body.map(t => mapTStmt(t, f)) };
+        case "switch": return { ...s, expr: r(s.expr), cases: s.cases.map(c => ({ ...c, body: c.body.map(t => mapTStmt(t, f)) })), defaultBody: s.defaultBody.map(t => mapTStmt(t, f)) };
+        case "forof": return { ...s, iterable: r(s.iterable), invariants: s.invariants.map(r), body: s.body.map(t => mapTStmt(t, f)) };
+        case "ghostLet": return { ...s, init: r(s.init) };
+        case "ghostAssign": return { ...s, value: r(s.value) };
+        case "assert": return { ...s, expr: r(s.expr) };
+    }
+}
 export const LEAN_OPTIONS = {
     backend: "lean",
     monadic: true,
@@ -75,10 +124,14 @@ export const DAFNY_OPTIONS = {
     monadic: false,
 };
 /** Active options — set before each transform call. */
-let _opts = LEAN_OPTIONS;
-/** Prefix match-bound field names to avoid capturing user variables. */
-function matchBinder(fieldName) {
-    return `_${fieldName}`;
+let _opts = DAFNY_OPTIONS;
+/** Type declarations — set once per module transform for discriminated union handling. */
+let _typeDecls = [];
+/** Prefix match-bound field names to avoid capturing user variables.
+ *  When prefix is given (the scrutinee name), include it to avoid
+ *  collisions in nested matches on different variables. */
+function matchBinder(fieldName, prefix) {
+    return prefix ? `_${prefix}_${fieldName}` : `_${fieldName}`;
 }
 const _forofCounters = new Map();
 function isNat(ty) { return ty.kind === "nat"; }
@@ -215,6 +268,11 @@ function lowerExpr(e, binds) {
                     ],
                 };
             }
+            // || undefined on optional → identity (no-op: x || undefined = x)
+            if (e.op === "||" && e.left.ty.kind === "optional" &&
+                e.right.kind === "var" && e.right.name === "undefined") {
+                return lowerExpr(e.left, binds);
+            }
             // || on optional → match Some/None with default
             if (e.op === "||" && e.left.ty.kind === "optional") {
                 const optExpr = lowerExpr(e.left, binds);
@@ -228,6 +286,43 @@ function lowerExpr(e, binds) {
                     ],
                 };
             }
+            // || on map index → if key in map then map[key] else default
+            if (e.op === "||" && e.left.kind === "index" && e.left.obj.ty.kind === "map") {
+                const map = lowerExpr(e.left.obj, binds);
+                const key = lowerExpr(e.left.idx, binds);
+                const right = lowerExpr(e.right, binds);
+                return {
+                    kind: "if",
+                    cond: { kind: "binop", op: "in", left: key, right: map },
+                    then: { kind: "index", arr: map, idx: key }, else: right,
+                };
+            }
+            // || on non-optional string/array/user → if non-empty then x else default
+            if (e.op === "||" && (e.left.ty.kind === "string" || e.left.ty.kind === "array" ||
+                (e.left.ty.kind === "user" && e.right.ty.kind === "string"))) {
+                const left = lowerExpr(e.left, binds);
+                const right = lowerExpr(e.right, binds);
+                return {
+                    kind: "if",
+                    cond: { kind: "binop", op: ">", left: { kind: "field", obj: left, field: "size" }, right: { kind: "num", value: 0 } },
+                    then: left, else: right,
+                };
+            }
+            // int + string → NatToString(int) + string (string concatenation)
+            if (e.op === "+" && _opts.backend === "dafny") {
+                const isIntL = e.left.ty.kind === "int" || e.left.ty.kind === "nat";
+                const isIntR = e.right.ty.kind === "int" || e.right.ty.kind === "nat";
+                if (isIntL && e.right.ty.kind === "string") {
+                    return { kind: "binop", op: "+",
+                        left: { kind: "app", fn: "NatToString", args: [lowerExpr(e.left, binds)] },
+                        right: lowerExpr(e.right, binds) };
+                }
+                if (e.left.ty.kind === "string" && isIntR) {
+                    return { kind: "binop", op: "+",
+                        left: lowerExpr(e.left, binds),
+                        right: { kind: "app", fn: "NatToString", args: [lowerExpr(e.right, binds)] } };
+                }
+            }
             return {
                 kind: "binop",
                 op: OP_MAP[e.op] ?? e.op,
@@ -249,6 +344,15 @@ function lowerExpr(e, binds) {
             return { kind: "index", arr: transformExpr(e.obj), idx: wrappedIdx };
         }
         case "call": {
+            // Math.abs/min/max → preamble functions
+            if (e.fn.kind === "field" && e.fn.obj.kind === "var" && e.fn.obj.name === "Math") {
+                if (e.fn.field === "abs" && e.args.length === 1)
+                    return { kind: "app", fn: "MathAbs", args: [lowerExpr(e.args[0], binds)] };
+                if (e.fn.field === "min" && e.args.length === 2)
+                    return { kind: "app", fn: "MathMin", args: e.args.map(a => lowerExpr(a, binds)) };
+                if (e.fn.field === "max" && e.args.length === 2)
+                    return { kind: "app", fn: "MathMax", args: e.args.map(a => lowerExpr(a, binds)) };
+            }
             // Math.ceil(x): CeilReal on real args, identity on int
             if (e.fn.kind === "field" && e.fn.field === "ceil" && e.fn.obj.kind === "var" && e.fn.obj.name === "Math" && e.args.length === 1) {
                 const arg = e.args[0];
@@ -296,13 +400,64 @@ function lowerExpr(e, binds) {
             const prefix = e.callKind === "spec-pure" && _opts.backend === "lean" ? "Pure." : "";
             return { kind: "app", fn: prefix + e.fn.name, args: e.args.map(a => lowerExpr(a, binds)) };
         }
-        case "record":
-            return { kind: "record", spread: e.spread ? lowerExpr(e.spread, binds) : null, fields: e.fields.map(f => ({ name: f.name, value: lowerExpr(f.value, binds) })) };
+        case "record": {
+            // Discriminated union: { kind: 'NoOp' } → constructor NoOp
+            if (e.ty.kind === "user" && !e.spread) {
+                const tyName = e.ty.name;
+                // Match base type name (strip generic args: "Result<Model, Err>" → "Result")
+                const baseName = tyName.includes("<") ? tyName.slice(0, tyName.indexOf("<")) : tyName;
+                const decl = _typeDecls.find(d => d.name === baseName && (d.kind === "discriminated-union" || d.kind === "string-union"));
+                if (decl && decl.discriminant) {
+                    const discField = e.fields.find(f => f.name === decl.discriminant);
+                    if (discField && (discField.value.kind === "str" || discField.value.kind === "bool")) {
+                        const variantName = String(discField.value.kind === "str" ? discField.value.value : discField.value.value);
+                        const variant = decl.variants?.find(v => v.name === variantName);
+                        if (variant) {
+                            const nonDiscFields = e.fields.filter(f => f.name !== decl.discriminant);
+                            if (nonDiscFields.length === 0) {
+                                return { kind: "constructor", name: variantName, type: tyName };
+                            }
+                            // Constructor with args: match variant field order
+                            const args = variant.fields.map(vf => {
+                                const ef = nonDiscFields.find(f => f.name === vf.name);
+                                return ef ? lowerExpr(ef.value, binds) : { kind: "var", name: "None" };
+                            });
+                            return { kind: "app", fn: variantName, args };
+                        }
+                    }
+                }
+            }
+            // For spread records, wrap non-optional values in Some for optional fields
+            if (e.spread) {
+                const spreadTy = e.spread.ty.kind === "optional" ? e.spread.ty.inner : e.spread.ty;
+                const structName = spreadTy.kind === "user" ? spreadTy.name : undefined;
+                const structDecl = structName ? _typeDecls.find(d => d.name === structName && d.kind === "record") : undefined;
+                const loweredFields = e.fields.map(f => {
+                    let value = lowerExpr(f.value, binds);
+                    if (structDecl?.fields) {
+                        const fieldDecl = structDecl.fields.find(sf => sf.name === f.name);
+                        if (fieldDecl) {
+                            const fieldTy = parseTsType(fieldDecl.tsType);
+                            const isUndef = f.value.kind === "var" && f.value.name === "undefined";
+                            if (fieldTy.kind === "optional" && f.value.ty.kind !== "optional" && !isUndef) {
+                                value = { kind: "app", fn: "Some", args: [value] };
+                            }
+                        }
+                    }
+                    return { name: f.name, value };
+                });
+                return { kind: "record", spread: lowerExpr(e.spread, binds), fields: loweredFields };
+            }
+            return { kind: "record", spread: null, fields: e.fields.map(f => ({ name: f.name, value: lowerExpr(f.value, binds) })) };
+        }
         case "arrayLiteral":
             if (e.ty.kind === "map" && e.elems.length === 0)
                 return { kind: "emptyMap" };
             if (e.ty.kind === "set" && e.elems.length === 0)
                 return { kind: "emptySet" };
+            // Set with initial elements: new Set([a, b]) → {a, b}
+            if (e.ty.kind === "set")
+                return { kind: "app", fn: "SetLiteral", args: e.elems.map(el => lowerExpr(el, binds)) };
             return { kind: "arrayLiteral", elems: e.elems.map(el => lowerExpr(el, binds)) };
         case "lambda":
             return { kind: "lambda", params: e.params.map(p => ({ name: p.name, type: p.ty })), body: transformStmts(e.body, []) };
@@ -314,7 +469,49 @@ function lowerExpr(e, binds) {
             const cond = lowerExpr(e.cond, binds);
             let thenExpr = lowerExpr(e.then, binds);
             let elseExpr = lowerExpr(e.else, binds);
-            // Optional ternary: wrap non-undefined branch in Some, undefined branch in None
+            // Explicit !== undefined with narrowedExpr → match Some/None on the optional expression
+            if (e.narrowedVar && e.narrowedExpr) {
+                const scrutinee = lowerExpr(e.narrowedExpr, binds);
+                const bound = matchBinder(e.narrowedVar);
+                if (bound !== e.narrowedVar) {
+                    thenExpr = replaceVar(thenExpr, e.narrowedVar, { kind: "var", name: bound });
+                }
+                const wrapSomeNone = (expr, raw) => (raw.kind === "var" && raw.name === "undefined")
+                    ? { kind: "constructor", name: ".none" }
+                    : { kind: "app", fn: "Some", args: [expr] };
+                thenExpr = wrapSomeNone(thenExpr, e.then);
+                elseExpr = wrapSomeNone(elseExpr, e.else);
+                return {
+                    kind: "match", scrutinee,
+                    arms: [
+                        { pattern: `.some ${bound}`, body: thenExpr },
+                        { pattern: ".none", body: elseExpr },
+                    ],
+                };
+            }
+            // Optional cond with narrowedVar → match Some/None (truthiness)
+            if (e.narrowedVar && e.cond.ty.kind === "optional") {
+                const bound = matchBinder(e.narrowedVar);
+                // Replace the synthetic/narrowed var with the match-bound name
+                if (bound !== e.narrowedVar) {
+                    thenExpr = replaceVar(thenExpr, e.narrowedVar, { kind: "var", name: bound });
+                }
+                // The match produces an Optional: wrap branches in Some/None.
+                // Either branch being undefined signals None; otherwise wrap in Some.
+                const wrapSomeNone = (expr, raw) => (raw.kind === "var" && raw.name === "undefined")
+                    ? { kind: "constructor", name: ".none" }
+                    : { kind: "app", fn: "Some", args: [expr] };
+                thenExpr = wrapSomeNone(thenExpr, e.then);
+                elseExpr = wrapSomeNone(elseExpr, e.else);
+                return {
+                    kind: "match", scrutinee: cond,
+                    arms: [
+                        { pattern: `.some ${bound}`, body: thenExpr },
+                        { pattern: ".none", body: elseExpr },
+                    ],
+                };
+            }
+            // Non-optional: regular if with optional wrapping
             if (e.ty.kind === "optional") {
                 if (e.then.kind === "var" && e.then.name === "undefined") {
                     thenExpr = { kind: "constructor", name: ".none" };
@@ -374,7 +571,7 @@ function ensuresToMatch(e, typeDecls) {
     if (!variant)
         return null;
     const fields = variant.fields;
-    const pattern = fields.length > 0 ? `.${variantName} ${fields.map(f => matchBinder(f.name)).join(" ")}` : `.${variantName}`;
+    const pattern = fields.length > 0 ? `.${variantName} ${fields.map(f => matchBinder(f.name, obj.name)).join(" ")}` : `.${variantName}`;
     let rhs = transformExpr(e.right);
     rhs = replaceFieldAccess(rhs, obj.name, fields);
     return { kind: "match", scrutinee: obj.name, arms: [{ pattern, body: rhs }, { pattern: "_", body: { kind: "bool", value: true } }] };
@@ -384,7 +581,7 @@ function replaceFieldAccess(e, varName, fields) {
         if (x.kind === "field" && x.obj.kind === "var" && x.obj.name === varName) {
             const f = fields.find(f => f.name === x.field);
             if (f)
-                return { kind: "var", name: matchBinder(f.name) };
+                return { kind: "var", name: matchBinder(f.name, varName) };
         }
         // If this let shadows the matched variable, stop replacing in the body
         if (x.kind === "let" && x.name === varName)
@@ -610,6 +807,17 @@ function transformStmt(s, typeDecls) {
             return [...binds, { kind: "assign", target: "_", value: expr }];
         }
         case "if": {
+            // Restructure && with optional check: extract the leftmost optional check
+            // from a && chain and nest the rest inside. Handles left-associative chains:
+            // if ((x !== undefined && b) && c) → if (x !== undefined) { if (b && c) { ... } }
+            if (s.cond.kind === "binop" && s.cond.op === "&&" && s.else.length === 0) {
+                const extracted = extractLeftmostOptional(s.cond);
+                if (extracted) {
+                    const innerIf = { kind: "if", cond: extracted.rest, then: s.then, else: [] };
+                    const outerIf = { kind: "if", cond: extracted.optCond, then: [innerIf], else: [] };
+                    return transformStmts([outerIf], typeDecls);
+                }
+            }
             // Lift from condition only (Lean rule: don't lift from branches)
             const { binds, expr: cond } = liftMethodCalls(s.cond);
             return [...binds, { kind: "if", cond, then: transformStmts(s.then, typeDecls), else: transformStmts(s.else, typeDecls) }];
@@ -708,6 +916,21 @@ function emitOptionalMatch(varName, negated, s, typeDecls, restStmts) {
 function mapStmtExprs(s, r) {
     return mapStmt(s, e => r(e));
 }
+/** Extract the leftmost optional check from a && chain, returning the check and the rest.
+ *  (x !== undefined && b) && c → { optCond: x !== undefined, rest: b && c } */
+function extractLeftmostOptional(cond) {
+    if (cond.kind !== "binop" || cond.op !== "&&")
+        return null;
+    const check = parseOptionalCheck(cond.left);
+    if (check && !check.negated)
+        return { optCond: cond.left, rest: cond.right };
+    if (cond.left.kind === "binop" && cond.left.op === "&&") {
+        const inner = extractLeftmostOptional(cond.left);
+        if (inner)
+            return { optCond: inner.optCond, rest: { ...cond, left: inner.rest } };
+    }
+    return null;
+}
 /** Detect `v !== undefined` or `undefined !== v` where v has optional type. */
 function parseOptionalCheck(cond) {
     if (cond.kind !== "binop" || (cond.op !== "!==" && cond.op !== "==="))
@@ -726,9 +949,10 @@ function emitMatchStmt(chain, typeDecls) {
     const arms = chain.cases.map(c => {
         const variant = decl?.variants?.find(v => v.name === c.variant);
         const fields = variant?.fields ?? [];
-        const pattern = fields.length > 0 ? `.${c.variant} ${fields.map(f => matchBinder(f.name)).join(" ")}` : `.${c.variant}`;
-        let body = transformStmts(c.body, typeDecls);
-        body = replaceFieldAccessInStmts(body, chain.varName, fields);
+        const pattern = fields.length > 0 ? `.${c.variant} ${fields.map(f => matchBinder(f.name, chain.varName)).join(" ")}` : `.${c.variant}`;
+        // Replace field accesses in TStmt BEFORE transforming, so optional narrowing sees simple vars
+        const replaced = replaceFieldAccessInTStmts(c.body, chain.varName, fields);
+        const body = transformStmts(replaced, typeDecls);
         return { pattern, body };
     });
     if (chain.fallthrough.length > 0)
@@ -742,15 +966,33 @@ function emitSwitchStmt(s, typeDecls) {
     const arms = s.cases.map(c => {
         const variant = decl?.variants?.find(v => v.name === c.label);
         const fields = variant?.fields ?? [];
-        const pattern = fields.length > 0 ? `.${c.label} ${fields.map(f => matchBinder(f.name)).join(" ")}` : `.${c.label}`;
-        let body = transformStmts(c.body, typeDecls);
-        body = replaceFieldAccessInStmts(body, varName, fields);
+        const pattern = fields.length > 0 ? `.${c.label} ${fields.map(f => matchBinder(f.name, varName)).join(" ")}` : `.${c.label}`;
+        // Replace field accesses in TStmt BEFORE transforming, so optional narrowing sees simple vars
+        const replaced = replaceFieldAccessInTStmts(c.body, varName, fields);
+        const body = transformStmts(replaced, typeDecls);
         return { pattern, body };
     });
     if (s.defaultBody.length > 0)
         arms.push({ pattern: "_", body: transformStmts(s.defaultBody, typeDecls) });
     return { kind: "match", scrutinee: varName, arms };
 }
+/** Replace obj.field → binder var in typed IR (before transform).
+ *  Uses the variant's declared field type since the resolve phase may not
+ *  resolve field types on discriminated unions correctly. */
+function replaceFieldAccessInTStmts(stmts, varName, fields) {
+    if (fields.length === 0)
+        return stmts;
+    return stmts.map(s => mapTStmt(s, e => {
+        if (e.kind === "field" && e.obj.kind === "var" && e.obj.name === varName) {
+            const fi = fields.find(fi => fi.name === e.field);
+            if (fi) {
+                const ty = e.ty.kind !== "unknown" ? e.ty : parseTsType(fi.tsType);
+                return { kind: "var", name: matchBinder(fi.name, varName), ty };
+            }
+        }
+        return null;
+    }));
+}
 function replaceFieldAccessInStmts(stmts, varName, fields) {
     if (fields.length === 0)
         return stmts;
@@ -758,7 +1000,7 @@ function replaceFieldAccessInStmts(stmts, varName, fields) {
         if (e.kind === "field" && e.obj.kind === "var" && e.obj.name === varName) {
             const fi = fields.find(fi => fi.name === e.field);
             if (fi)
-                return { kind: "var", name: matchBinder(fi.name) };
+                return { kind: "var", name: matchBinder(fi.name, varName) };
         }
         return null;
     };
@@ -836,11 +1078,12 @@ function transformPureSwitch(s, typeDecls) {
     const decl = typeDecls.find(d => d.name === (s.expr.ty.kind === "user" ? s.expr.ty.name : ""));
     if (!decl)
         return null;
+    const varName = s.expr.kind === "var" ? s.expr.name : undefined;
     const arms = [];
     for (const c of s.cases) {
         const variant = decl.variants?.find(v => v.name === c.label);
         const fields = variant?.fields ?? [];
-        const pattern = fields.length > 0 ? `.${c.label} ${fields.map(f => matchBinder(f.name)).join(" ")}` : `.${c.label}`;
+        const pattern = fields.length > 0 ? `.${c.label} ${fields.map(f => matchBinder(f.name, varName)).join(" ")}` : `.${c.label}`;
         let body = transformPureBody(c.body, typeDecls);
         if (!body)
             return null;
@@ -864,7 +1107,7 @@ function transformPureMatch(chain, typeDecls) {
     for (const c of chain.cases) {
         const variant = decl?.variants?.find(v => v.name === c.variant);
         const fields = variant?.fields ?? [];
-        const pattern = fields.length > 0 ? `.${c.variant} ${fields.map(f => matchBinder(f.name)).join(" ")}` : `.${c.variant}`;
+        const pattern = fields.length > 0 ? `.${c.variant} ${fields.map(f => matchBinder(f.name, chain.varName)).join(" ")}` : `.${c.variant}`;
         let body = transformPureBody(c.body, typeDecls);
         if (!body)
             return null;
@@ -896,6 +1139,7 @@ function transformTypeDecl(d) {
     else if (d.kind === "discriminated-union") {
         return {
             kind: "inductive", name: d.name,
+            typeParams: d.typeParams,
             constructors: d.variants.map(v => ({
                 name: v.name,
                 fields: v.fields.map(f => ({ name: f.name, type: parseTsType(f.tsType) })),
@@ -903,6 +1147,12 @@ function transformTypeDecl(d) {
             deriving: ["Repr", "Inhabited"],
         };
     }
+    else if (d.kind === "alias") {
+        return {
+            kind: "type-alias", name: d.name,
+            target: parseTsType(d.aliasOf),
+        };
+    }
     else {
         return {
             kind: "structure", name: d.name,
@@ -961,6 +1211,17 @@ function replaceVar(e, name, replacement) {
     });
 }
 // ── Top-level transform ──────────────────────────────────────
+/** Transform for Lean backend — same logic, Lean options. */
+export function transformModuleLean(mod, specImport) {
+    const prev = _opts;
+    _opts = LEAN_OPTIONS;
+    try {
+        return transformModule(mod, specImport);
+    }
+    finally {
+        _opts = prev;
+    }
+}
 /** Transform for Dafny backend — same logic, Dafny options. */
 export function transformModuleDafny(mod) {
     const prev = _opts;
@@ -974,6 +1235,7 @@ export function transformModuleDafny(mod) {
 }
 export function transformModule(mod, specImport) {
     _forofCounters.clear();
+    _typeDecls = mod.typeDecls;
     const typeDecls = mod.typeDecls.map(transformTypeDecl);
     // Module-level constants
     const constDecls = (mod.constants ?? []).map(c => ({
@@ -996,6 +1258,7 @@ export function transformModule(mod, specImport) {
         pureDefs.push({
             kind: "def",
             name: fn.name,
+            typeParams: fn.typeParams,
             params: fn.params.map(p => ({ name: p.name, type: p.ty })),
             returnType: fn.returnTy,
             requires: fn.requires.map(transformExpr),
@@ -1046,6 +1309,7 @@ export function transformModule(mod, specImport) {
         return {
             kind: "method",
             name: fn.name,
+            typeParams: fn.typeParams,
             params: fn.params.map(p => ({ name: p.name, type: p.ty })),
             returnType: fn.returnTy,
             requires: fn.requires.map(transformExpr),
@@ -1062,6 +1326,7 @@ export function transformModule(mod, specImport) {
             return {
                 kind: "method",
                 name: fn.name,
+                typeParams: fn.typeParams,
                 params: fn.params.map(p => ({ name: p.name, type: p.ty })),
                 returnType: fn.returnTy,
                 requires: fn.requires.map(transformExpr),

package/tools/dist/types.js

@@ -25,7 +25,14 @@ export function parseTsType(tsType) {
     const t = tsType.trim();
     // Union: T | undefined → optional<T>
     if (t.includes(" | ")) {
-        const arms = t.split(" | ").map(a => a.trim());
+        let arms = t.split(" | ").map(a => a.trim());
+        // Normalize expanded boolean literals: true | false → boolean
+        const boolLits = new Set(["true", "false"]);
+        const hasBoth = arms.includes("true") && arms.includes("false");
+        if (hasBoth) {
+            arms = arms.filter(a => !boolLits.has(a));
+            arms.unshift("boolean");
+        }
         const nonUndef = arms.filter(a => a !== "undefined");
         if (nonUndef.length === 1 && arms.length === 2) {
             return { kind: "optional", inner: parseTsType(nonUndef[0]) };
@@ -67,5 +74,11 @@ export function parseTsType(tsType) {
     const setMatch = t.match(/^Set<(.+)>$/);
     if (setMatch)
         return { kind: "set", elem: parseTsType(setMatch[1]) };
+    // Tuple [T1, T2, ...] → array of the common element type
+    const tupleMatch = t.match(/^\[(.+)\]$/);
+    if (tupleMatch) {
+        const elems = splitTypeArgs(tupleMatch[1]);
+        return { kind: "array", elem: parseTsType(elems[0]) };
+    }
     return { kind: "user", name: t };
 }