lemmascript 0.3.0 → 0.3.2

package/tools/dist/resolve.js

@@ -99,22 +99,47 @@ function coerceStr(expr, targetTy) {
     return expr;
 }
 // ── Helpers ──────────────────────────────────────────────────
-/** Detect `v !== undefined` or `undefined !== v` where v: optional<T>. */
-function narrowOptional(cond, env) {
+/** Wrap a resolved expression in Some() for optional coercion. */
+function wrapSome(value, optionalTy) {
+    return {
+        kind: "call", fn: { kind: "var", name: "Some", ty: optionalTy },
+        args: [value], ty: optionalTy, callKind: "pure",
+    };
+}
+/** Detect `v !== undefined` or `undefined !== v` where v: optional<T>.
+ *  Handles simple variables, field access chains, and arbitrary expressions.
+ *  When `fieldExpr` is returned, callers must use `substituteRawExpr` to narrow.
+ *
+ *  Does NOT recurse into `&&` — callers that need to detect optional checks
+ *  inside `&&` conditions should check `cond.left` explicitly. */
+function detectOptionalCheck(cond, ctx) {
     if (cond.kind !== "binop" || (cond.op !== "!==" && cond.op !== "==="))
         return null;
-    // v !== undefined  OR  undefined !== v
-    let varName = null;
-    if (cond.left.kind === "var" && cond.right.kind === "var" && cond.right.name === "undefined")
-        varName = cond.left.name;
-    if (cond.right.kind === "var" && cond.left.kind === "var" && cond.left.name === "undefined")
-        varName = cond.right.name;
-    if (!varName)
+    // Identify the expression being checked against undefined
+    let optExpr = null;
+    if (cond.right.kind === "var" && cond.right.name === "undefined")
+        optExpr = cond.left;
+    if (cond.left.kind === "var" && cond.left.name === "undefined")
+        optExpr = cond.right;
+    if (!optExpr)
         return null;
-    const ty = lookup(env, varName);
-    if (!ty || ty.kind !== "optional")
-        return null;
-    return { varName, innerTy: ty.inner, inThen: cond.op === "!==" };
+    // Simple variable — env lookup, no substitution needed
+    if (optExpr.kind === "var") {
+        const ty = lookup(ctx.env, optExpr.name);
+        if (!ty || ty.kind !== "optional")
+            return null;
+        return { varName: optExpr.name, innerTy: ty.inner, inThen: cond.op === "!==" };
+    }
+    // Field access chain or arbitrary expression — resolve to check type, needs substitution
+    const resolved = resolveExpr(optExpr, ctx);
+    if (resolved.ty.kind === "optional") {
+        const synVar = optExpr.kind === "field" ? `_narr${_synVarCounter++}` : `_opt${_synVarCounter++}`;
+        return {
+            varName: synVar, innerTy: resolved.ty.inner, inThen: cond.op === "!==",
+            fieldExpr: optExpr, narrowedExpr: resolved,
+        };
+    }
+    return null;
 }
 /** TS reference types that become value types in Dafny/Lean — const bindings need mutable var. */
 function isRefMutableInTS(ty) {
@@ -203,10 +228,101 @@ function classifyCall(fn, ctx) {
         return "method";
     return "unknown";
 }
+// ── Call resolution helpers ─────────────────────────────────
+/** Infer lambda param types from array method context (map, filter, etc.).
+ *  Returns updated rawArgs with inferred tsType on the first lambda param. */
+function inferLambdaParamTypes(fn, rawArgs) {
+    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)];
+            return [{ ...lam, params: updatedParams }, ...rawArgs.slice(1)];
+        }
+    }
+    return rawArgs;
+}
+/** Coerce call arguments: string literals → user types, non-optional → Some, pad missing optional args. */
+function coerceCallArgs(args, fn, ctx) {
+    if (fn.kind !== "var" || !ctx.fnParams.has(fn.name))
+        return args;
+    const paramTys = ctx.fnParams.get(fn.name);
+    args = args.map((a, i) => {
+        if (i >= paramTys.length)
+            return a;
+        a = coerceStr(a, paramTys[i]);
+        if (a.ty.kind !== "optional" && paramTys[i].kind === "optional") {
+            return wrapSome(a, paramTys[i]);
+        }
+        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] });
+        }
+    }
+    return args;
+}
+/** Infer return type for collection/string method calls. */
+function inferMethodReturnTy(fn, args, ctx) {
+    if (fn.kind !== "field")
+        return { kind: "unknown" };
+    const objTy = fn.obj.ty;
+    if (objTy.kind === "map") {
+        if (fn.field === "get")
+            return ctx.inSpec ? objTy.value : { kind: "optional", inner: objTy.value };
+        if (fn.field === "has")
+            return { kind: "bool" };
+        if (fn.field === "set" || fn.field === "delete")
+            return objTy;
+    }
+    else if (objTy.kind === "set") {
+        if (fn.field === "has")
+            return { kind: "bool" };
+        if (fn.field === "add" || fn.field === "delete")
+            return objTy;
+    }
+    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")
+            return objTy;
+        if (fn.field === "filter")
+            return objTy;
+        if (fn.field === "every" || fn.field === "some")
+            return { kind: "bool" };
+        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" };
+            return { kind: "array", elem: retTy };
+        }
+    }
+    else if (objTy.kind === "string") {
+        if (fn.field === "trim" || fn.field === "toLowerCase" || fn.field === "toUpperCase")
+            return { kind: "string" };
+        if (fn.field === "includes")
+            return { kind: "bool" };
+    }
+    return { kind: "unknown" };
+}
 // ── Resolve expressions ──────────────────────────────────────
 function resolveExpr(e, ctx) {
     switch (e.kind) {
         case "var":
+            if (e.name === "undefined")
+                return { kind: "var", name: "undefined", ty: { kind: "void" } };
             return { kind: "var", name: e.name, ty: lookup(ctx.env, e.name) ?? { kind: "unknown" } };
         case "num":
             if (!Number.isInteger(e.value))
@@ -228,15 +344,18 @@ function resolveExpr(e, ctx) {
         }
         case "binop": {
             let left = resolveExpr(e.left, ctx);
-            // && narrowing: if left is "x !== undefined", narrow x for right side
+            // && narrowing: if left is "x !== undefined", narrow x for right side.
+            // Field chains are excluded — resolve can't substitute in sub-expressions;
+            // transform's emitOptionalMatch handles field chains in statement contexts.
             let rightCtx = ctx;
+            let rawRight = e.right;
             if (e.op === "&&") {
-                const narrowed = narrowOptional(e.left, ctx.env);
-                if (narrowed && narrowed.inThen) {
+                const narrowed = detectOptionalCheck(e.left, ctx);
+                if (narrowed && narrowed.inThen && !narrowed.fieldExpr) {
                     rightCtx = withEnv(ctx, extend(ctx.env, narrowed.varName, narrowed.innerTy));
                 }
             }
-            let right = resolveExpr(e.right, rightCtx);
+            let right = resolveExpr(rawRight, rightCtx);
             if (e.op === "===" || e.op === "!==") {
                 left = coerceStr(left, right.ty);
                 right = coerceStr(right, left.ty);
@@ -263,114 +382,22 @@ function resolveExpr(e, ctx) {
         }
         case "call": {
             const fn = resolveExpr(e.fn, ctx);
-            // 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
+            const rawArgs = inferLambdaParamTypes(fn, e.args);
+            // For .push() on a typed array, resolve args with element type context
             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)
-                        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] },
-                            args: [a],
-                            ty: paramTys[i],
-                            callKind: "pure",
-                        };
-                    }
-                    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
-            if (fn.kind === "field" && fn.obj.ty.kind === "map") {
-                if (fn.field === "get")
-                    ty = ctx.inSpec ? fn.obj.ty.value : { kind: "optional", inner: fn.obj.ty.value };
-                else if (fn.field === "has")
-                    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")
-                    ty = { kind: "bool" };
-                else if (fn.field === "add")
-                    ty = fn.obj.ty;
-                else if (fn.field === "delete")
-                    ty = fn.obj.ty;
-            }
-            else if (fn.kind === "field" && fn.obj.ty.kind === "array") {
-                if (fn.field === "includes")
-                    ty = { kind: "bool" };
-                else if (fn.field === "shift")
-                    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")
-                    ty = { kind: "string" };
-                else if (fn.field === "toLowerCase")
-                    ty = { kind: "string" };
-                else if (fn.field === "toUpperCase")
-                    ty = { kind: "string" };
-                else if (fn.field === "includes")
-                    ty = { kind: "bool" };
-            }
+            const args = coerceCallArgs(rawArgs.map(a => resolveExpr(a, argCtx)), fn, ctx);
+            const ty = inferMethodReturnTy(fn, args, ctx);
             return { kind: "call", fn, args, ty, callKind: classifyCall(e.fn, ctx) };
         }
         case "index": {
             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 };
         }
@@ -391,7 +418,17 @@ function resolveExpr(e, ctx) {
                 if (decl?.kind === "record") {
                     const f = decl.fields?.find(f => f.name === e.field);
                     if (f)
-                        ty = resolveTsType(f.tsType, ctx.overrides);
+                        ty = f.type;
+                }
+                // Also resolve fields from discriminated-union variants
+                if (ty.kind === "unknown" && decl?.kind === "discriminated-union" && decl.variants) {
+                    for (const variant of decl.variants) {
+                        const f = variant.fields.find(f => f.name === e.field);
+                        if (f) {
+                            ty = f.type;
+                            break;
+                        }
+                    }
                 }
             }
             return { kind: "field", obj, field: e.field, ty, isDiscriminant };
@@ -408,15 +445,15 @@ function resolveExpr(e, ctx) {
                 let value = resolveExpr(f.value, fieldCtx);
                 const fieldDecl = decl?.fields?.find(df => df.name === f.name);
                 if (fieldDecl) {
-                    const declTy = parseTsType(fieldDecl.tsType);
+                    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 = {
-                            kind: "call",
-                            fn: { kind: "var", name: "Some", ty: declTy },
-                            args: [value], ty: declTy, callKind: "pure",
-                        };
+                        value = wrapSome(value, declTy);
                     }
                 }
                 return { name: f.name, value };
@@ -461,13 +498,11 @@ function resolveExpr(e, ctx) {
         }
         case "conditional": {
             const cond = resolveExpr(e.cond, 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;
+            // Phase 1: Optional truthiness — cond itself is optional (e.g. opt ? X : Y)
             if (cond.ty.kind === "optional") {
                 const innerTy = cond.ty.inner;
                 if (e.cond.kind === "var") {
@@ -480,24 +515,18 @@ function resolveExpr(e, ctx) {
                     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.
+            // Phase 2: Explicit check — v !== undefined (simple vars, field chains,
+            // complex expressions all handled uniformly by detectOptionalCheck)
             if (!narrowedVar) {
-                const narrowed = narrowOptional(e.cond, ctx.env);
+                const narrowed = detectOptionalCheck(e.cond, ctx)
+                    // Phase 3: && with optional check — (v !== undefined && ...) ? ... : ...
+                    ?? (e.cond.kind === "binop" && e.cond.op === "&&" ? detectOptionalCheck(e.cond.left, ctx) : null);
                 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));
+                    if (narrowed.fieldExpr) {
+                        narrowedExprResolved = narrowed.narrowedExpr ?? resolveExpr(narrowed.fieldExpr, ctx);
+                        rawThen = substituteRawExpr(e.then, narrowed.fieldExpr, { kind: "var", name: narrowed.varName });
                     }
                 }
             }
@@ -506,8 +535,16 @@ function resolveExpr(e, ctx) {
             then_ = coerceStr(then_, else_.ty);
             else_ = coerceStr(else_, then_.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") {
+            // When one branch is undefined, result is optional
+            if (then_.ty.kind === "void" && else_.ty.kind !== "void" && else_.ty.kind !== "unknown") {
+                ty = { kind: "optional", inner: else_.ty };
+            }
+            else if (else_.ty.kind === "void" && then_.ty.kind !== "void" && then_.ty.kind !== "unknown") {
+                ty = { kind: "optional", inner: then_.ty };
+            }
+            // When narrowedExpr is set AND a branch is void, the match produces Optional
+            const hasVoidBranch = then_.ty.kind === "void" || else_.ty.kind === "void";
+            if (narrowedExprResolved && hasVoidBranch && ty.kind !== "optional") {
                 ty = { kind: "optional", inner: ty };
             }
             return { kind: "conditional", cond, then: then_, else: else_, ty, narrowedVar, narrowedExpr: narrowedExprResolved };
@@ -547,14 +584,25 @@ function resolveBlock(stmts, ctx) {
         const [typed, nextEnv] = resolveStmt(s, withEnv(ctx, env));
         result.push(typed);
         env = nextEnv;
+        // Flow narrowing: if (x === undefined) { return } narrows x for rest of block.
+        // Field chains are excluded — resolve can't substitute in statement lists;
+        // transform's emitOptionalMatch handles field chains in statement contexts.
+        if (s.kind === "if" && s.then.length > 0 && s.then[s.then.length - 1].kind === "return" && s.else.length === 0) {
+            const narrowed = detectOptionalCheck(s.cond, withEnv(ctx, env));
+            if (narrowed && !narrowed.inThen && !narrowed.fieldExpr) {
+                env = extend(env, narrowed.varName, narrowed.innerTy);
+            }
+        }
     }
     return result;
 }
 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)];
@@ -569,11 +617,7 @@ function resolveStmt(s, ctx) {
             // 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",
-                };
+                value = wrapSome(value, ctx.returnTy);
             }
             return [{ kind: "return", value }, ctx.env];
         }
@@ -584,23 +628,20 @@ function resolveStmt(s, ctx) {
         case "expr":
             return [{ kind: "expr", expr: resolveExpr(s.expr, ctx) }, ctx.env];
         case "if": {
-            // Narrow optional<T> → T when checking !== undefined or undefined !==
+            // Narrow optional<T> → T when checking !== undefined or undefined !==.
+            // Also checks left side of && conditions: if (x !== undefined && ...) { ... }
+            // Field chains are excluded — resolve can't substitute in statement bodies;
+            // transform's emitOptionalMatch handles field chains in statement contexts.
             let thenCtx = ctx, elseCtx = ctx;
-            const narrowed = narrowOptional(s.cond, ctx.env);
-            if (narrowed) {
+            const narrowed = detectOptionalCheck(s.cond, ctx)
+                ?? (s.cond.kind === "binop" && s.cond.op === "&&" ? detectOptionalCheck(s.cond.left, ctx) : null);
+            if (narrowed && !narrowed.fieldExpr) {
                 const env = extend(ctx.env, narrowed.varName, narrowed.innerTy);
                 if (narrowed.inThen)
                     thenCtx = withEnv(ctx, env);
                 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": {
@@ -847,21 +888,28 @@ function containsReturn(stmts) {
     return false;
 }
 // ── Resolve function / module ────────────────────────────────
-function resolveFunction(fn, typeDecls, pureFns, fnParams = new Map()) {
+function resolveFunction(fn, typeDecls, pureFns, fnParams = new Map(), opts) {
     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");
     let env = null;
+    if (opts?.thisBinding)
+        env = extend(env, opts.thisBinding.name, opts.thisBinding.ty);
     for (const p of params)
         env = extend(env, p.name, p.ty);
     const baseCtx = { env, typeDecls, overrides, allowResult: false, returnTy, pureFns, fnParams, inSpec: false, inLambda: false };
     const requiresCtx = { ...baseCtx, inSpec: true };
     const ensuresCtx = { ...baseCtx, allowResult: true, inSpec: true };
+    // Apply type parameter constraints from //@ type T (==) annotations
+    const typeParams = fn.typeParams.map(tp => {
+        const constraint = overrides.get(tp);
+        return constraint ? `${tp}${constraint}` : tp;
+    });
     return {
-        name: fn.name, typeParams: fn.typeParams, params, returnTy,
+        name: fn.name, typeParams, params, returnTy,
         requires: resolveSpecs(fn.requires, requiresCtx),
         ensures: resolveSpecs(fn.ensures, ensuresCtx),
-        isPure: pureFns.has(fn.name),
+        isPure: opts?.forcePure !== undefined ? opts.forcePure : pureFns.has(fn.name),
         body: resolveBlock(fn.body, baseCtx),
     };
 }
@@ -869,31 +917,31 @@ function resolveClass(cls, typeDecls, pureFns, fnParams = new Map()) {
     const fields = cls.fields.map(f => ({ name: f.name, ty: parseTsType(f.tsType) }));
     // Create a synthetic record type for 'this' so field access resolves
     const thisType = { kind: "user", name: cls.name };
-    const thisDecl = { name: cls.name, kind: "record", fields: cls.fields.map(f => ({ name: f.name, tsType: f.tsType })) };
+    const thisDecl = { name: cls.name, kind: "record", fields: cls.fields.map(f => ({ name: f.name, tsType: f.tsType, type: parseTsType(f.tsType) })) };
     const allTypeDecls = [...typeDecls, thisDecl];
-    const methods = cls.methods.map(fn => {
-        // Add 'this' to the environment
-        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");
-        let env = null;
-        env = extend(env, "this", thisType);
-        for (const p of params)
-            env = extend(env, p.name, p.ty);
-        const baseCtx = { env, typeDecls: allTypeDecls, overrides, allowResult: false, returnTy, pureFns, fnParams, inSpec: false, inLambda: false };
-        const requiresCtx = { ...baseCtx, inSpec: true };
-        const ensuresCtx = { ...baseCtx, allowResult: true, inSpec: true };
-        return {
-            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)
-            body: resolveBlock(fn.body, baseCtx),
-        };
-    });
+    const methods = cls.methods.map(fn => resolveFunction(fn, allTypeDecls, pureFns, fnParams, {
+        thisBinding: { name: "this", ty: thisType },
+        forcePure: false, // class methods are never pure (they access this)
+    }));
     return { name: cls.name, fields, methods };
 }
+/** Pre-compute Ty on all TypeDeclInfo fields/variants/aliases.
+ *  Called once per module so consumers can read field.type instead of re-parsing tsType. */
+function precomputeFieldTypes(typeDecls) {
+    for (const d of typeDecls) {
+        if (d.fields)
+            for (const f of d.fields)
+                f.type = parseTsType(f.tsType);
+        if (d.variants)
+            for (const v of d.variants)
+                for (const f of v.fields)
+                    f.type = parseTsType(f.tsType);
+        if (d.aliasOf && !d.aliasOfTy)
+            d.aliasOfTy = parseTsType(d.aliasOf);
+    }
+}
 export function resolveModule(raw) {
+    precomputeFieldTypes(raw.typeDecls);
     const pureFns = computePureFns(raw.functions);
     // Pre-compute function parameter types for optional coercion
     const fnParams = new Map();