55dceee | plum | pyrossh

git clone https://git.pyrossh.dev/plum

A statically typed, imperative programming language inspired by rust, python

55dceee — Peter John 2026-10-25T22:50:52+05:30

feat(codegen)!: compile erased generics; stop monomorphizing

Files changed (5) hide show

plum-checker/src/lib.rs +66 -25
plum-checker/tests/checker_tests.rs +8 -0
plum-cli/src/main.rs +7 -1
plum-wasm-codegen/src/lib.rs +1179 -1207
plum-wasm-codegen/tests/codegen_tests.rs +107 -7

plum-checker/src/lib.rs CHANGED Viewed

@@ -25,6 +25,14 @@ pub struct TypedInfo {
     pub expr_types: HashMap<usize, PlumType>,
 }
+/// Both operands of a binary/compare operator have the same type, so an
+/// unresolved inference variable on one side takes the other side's type.
+fn bindAcross(a: &PlumType, b: &PlumType) {
+    let mut scratch = Binds::new();
+    bindMatch(a, b, &mut scratch);
+    bindMatch(b, a, &mut scratch);
+}
 fn freshVar() -> PlumType {
     FRESH.with(|c| {
         let n = c.get();
@@ -225,7 +233,7 @@ fn appSubst(generics: &[String], args: &[PlumType]) -> BTreeMap<String, PlumType
 /// A variant's payload field types with the enum's generics replaced by the
 /// type arguments of `ty` (when it is a `TApp`).
-fn variantFields(info: &EnumVariantInfo, ty: &PlumType) -> Vec<PlumType> {
+pub fn variantFields(info: &EnumVariantInfo, ty: &PlumType) -> Vec<PlumType> {
     match ty {
         PlumType::TApp(_, args) if args.len() == info.generics.len() => {
             let s = appSubst(&info.generics, args);
@@ -288,7 +296,7 @@ fn recordType(expr: &ast::Expr, ty: &PlumType) {
 }
 /// Base name of a nominal type (`TNamed`/`TApp`).
-fn nominalName(t: &PlumType) -> Option<&str> {
+pub fn nominalName(t: &PlumType) -> Option<&str> {
     match t {
         PlumType::TNamed(n) | PlumType::TApp(n, _) => Some(n),
         _ => None,
@@ -2522,6 +2530,9 @@ fn checkCallArgs(
                     format!("{} arg {}: {}", label, i, err)
                 }
             })?;
+            // An argument whose own type still has unresolved variables (an unused
+            // closure parameter, an empty literal) learns them from the parameter.
+            bindMatch(&actual, &want, binds);
         }
     }
     Ok(())
@@ -2563,7 +2574,8 @@ fn tryParts(ty: &PlumType, ctx: &CheckCtx) -> Option<(PlumType, Option<PlumType>
 fn inferMethodCall(
     obj_ty: &PlumType,
+    name: &str,
-    call: &ast::FnCall,
+    args: &[ast::Arg],
     env: &TypeEnv,
     ctx: &CheckCtx,
     expected: Option<&PlumType>,
@@ -2575,19 +2587,19 @@ fn inferMethodCall(
             let Some(tr) = key.strip_prefix(&prefix) else {
                 continue;
             };
-            let Some(sch) = env.get(&format!("{}{}:{}", TRAIT_KEY, tr, call.name)) else {
+            let Some(sch) = env.get(&format!("{}{}:{}", TRAIT_KEY, tr, name)) else {
                 continue;
             };
             if let PlumType::TFun(params, ret) = &*sch.body {
                 let mut binds = Binds::new();
-                let label = format!("method '{}.{}'", p, call.name);
+                let label = format!("method '{}.{}'", p, name);
-                checkCallArgs(&label, params, &call.args, params.len(), env, ctx, &mut binds)?;
+                checkCallArgs(&label, params, args, params.len(), env, ctx, &mut binds)?;
                 return Ok(substVars(ret, &binds));
             }
         }
         return Err(format!(
             "'{}' has no method '{}' (add a bound)",
-            p, call.name
+            p, name
         ));
     }
     let Some(class_name) = methodReceiverName(obj_ty) else {
@@ -2597,20 +2609,24 @@ fn inferMethodCall(
     // the "union" enum that bare-wraps it instead (`enum Number = | Int | Float`).
     let class_name = if ctx
         .methods
-        .contains_key(&(class_name.clone(), call.name.clone()))
+        .contains_key(&(class_name.to_string(), name.to_string()))
     {
         class_name
     } else {
         ctx.enum_variants
             .get(class_name.as_str())
-            .map(|info| info.enum_name.clone())
+            .map(|info| info.enum_name.to_string())
             .filter(|enum_name| {
                 ctx.methods
-                    .contains_key(&(enum_name.clone(), call.name.clone()))
+                    .contains_key(&(enum_name.to_string(), name.to_string()))
             })
             .unwrap_or(class_name)
     };
-    let Some(sig) = ctx.methods.get(&(class_name.clone(), call.name.clone())) else {
+    let Some(sig) = ctx.methods.get(&(class_name.to_string(), name.to_string())) else {
+        // A trait-typed value only has the methods its trait declares.
+        if isTraitName(&class_name, ctx) {
+            return Err(format!("trait '{}' has no method '{}'", class_name, name));
+        }
         // Unmodeled method (e.g. builtin/std): allow, codegen will catch.
         return Ok(PlumType::TVar("_".to_string()));
     };
@@ -2632,11 +2648,11 @@ fn inferMethodCall(
     }
     let required = ctx
         .min_required
-        .get(&(Some(class_name.clone()), call.name.clone()))
+        .get(&(Some(class_name.to_string()), name.to_string()))
         .copied()
         .unwrap_or(params.len());
-    let label = format!("method '{}.{}'", class_name, call.name);
+    let label = format!("method '{}.{}'", class_name, name);
-    checkCallArgs(&label, &params, &call.args, required, env, ctx, &mut binds)?;
+    checkCallArgs(&label, &params, args, required, env, ctx, &mut binds)?;
     Ok(substVars(&ret, &binds))
 }
@@ -2837,7 +2853,7 @@ fn inferExprInner(
                         resolved_from_usage
                             .get(p)
                             .cloned()
-                            .unwrap_or_else(|| PlumType::TVar(format!("_closure_{}", p)))
+                            .unwrap_or_else(freshVar)
                     });
                     closure_env.insert(p.clone(), TypeScheme::mono(t.clone()));
                     t
@@ -2856,13 +2872,37 @@ fn inferExprInner(
                                 closure_env.insert(name.clone(), TypeScheme::mono(ty));
                             }
                         }
+                    } else {
+                        // Walk every other statement (`if`, loops, `match`, plain
+                        // calls) so the types of the expressions inside are
+                        // recorded for codegen. Errors are deliberately dropped:
+                        // the closure's params may still be unresolved here.
+                        let _ = checkStmt(
+                            stmt,
+                            &mut closure_env,
+                            &PlumType::TVar("_".into()),
+                            "closure",
+                            (0, 0),
+                            ctx,
+                        );
                     }
                 }
             }
             let body_ty = match &cl.body.stmts.last() {
                 Some(ast::Stmt::Expr(e, ..)) => inferExprWith(e, &closure_env, ctx, exp_ret)?,
                 Some(ast::Stmt::Return(Some(e))) => inferExprWith(e, &closure_env, ctx, exp_ret)?,
+                Some(last) => {
+                    let _ = checkStmt(
+                        last,
+                        &mut closure_env,
+                        &PlumType::TVar("_".into()),
+                        "closure",
+                        (0, 0),
+                        ctx,
+                    );
+                    PlumType::TUnit
+                }
-                _ => PlumType::TUnit,
+                None => PlumType::TUnit,
             };
             Ok(PlumType::TFun(param_types, Box::new(body_ty)))
         }
@@ -2876,6 +2916,7 @@ fn inferExprInner(
             let lt = inferExpr(&b.left, env, ctx)?;
             let rt = inferExpr(&b.right, env, ctx)?;
             unify(&lt, &rt, ctx).map_err(|e| format!("binary op: {}", e))?;
+            bindAcross(&lt, &rt);
             if matches!(lt, PlumType::TVar(_)) && !matches!(rt, PlumType::TVar(_)) {
                 return Ok(rt);
             }
@@ -2902,6 +2943,7 @@ fn inferExprInner(
                 return Ok(PlumType::TBool);
             }
             unify(&lt, &rt, ctx).map_err(|e| format!("compare op: {}", e))?;
+            bindAcross(&lt, &rt);
             Ok(PlumType::TBool)
         }
         ast::Expr::Ternary(t) => {
@@ -2972,14 +3014,11 @@ fn inferExprInner(
                     .methods
                     .contains_key(&(call.name.clone(), "init".to_string()))
             {
+                // The receiver is a temporary (never recorded); the ARGUMENTS stay
-                let synthetic = ast::Expr::Attribute(Box::new(ast::AttributeExpr {
+                // the original nodes so their types are recorded for codegen.
-                    object: ast::Expr::TypeName(call.name.clone()),
+                let receiver = ast::Expr::TypeName(call.name.clone());
-                    attr: ast::AttrKind::Method(ast::FnCall {
-                        name: "init".to_string(),
-                        args: call.args.clone(),
-                    }),
-                }));
-                return inferExprWith(&synthetic, env, ctx, expected);
+                let obj_ty = inferExprInner(&receiver, env, ctx, None)?;
+                return inferMethodCall(&obj_ty, "init", &call.args, env, ctx, expected);
             }
             if let Some(info) = ctx.enum_variants.get(&call.name) {
                 if call.args.len() != info.field_types.len() {
@@ -3075,7 +3114,9 @@ fn inferExprInner(
                         field_name, other
                     )),
                 },
+                ast::AttrKind::Method(call) => {
-                ast::AttrKind::Method(call) => inferMethodCall(&obj_ty, call, env, ctx, expected),
+                    inferMethodCall(&obj_ty, &call.name, &call.args, env, ctx, expected)
+                }
             }
         }
     }

plum-checker/tests/checker_tests.rs CHANGED Viewed

@@ -2089,6 +2089,14 @@ fn unbounded_tparam_method_error() {
     );
 }
+#[test]
+fn trait_typed_receiver_undeclared_method_error() {
+    let src = "trait Shape =\n  area() -> Float\n\nfun f(s: Shape) -> Float =\n  s.bogus()\n";
+    assert!(
+        errText(checkSource(&parseClean(src))).contains("trait 'Shape' has no method 'bogus'")
+    );
+}
 #[test]
 fn bounded_ok() {
     let src = "\

plum-cli/src/main.rs CHANGED Viewed

@@ -181,7 +181,13 @@ fn compileToTestWasm(
         anyhow::bail!(messages.join("\n"));
     }
+    let compiled = plum_wasm_codegen::compileTestSource(&ast)
-    plum_wasm_codegen::compileTestSource(&ast).map_err(|e| anyhow::anyhow!("codegen error: {e}"))
+        .map_err(|e| anyhow::anyhow!("codegen error: {e}"))?;
+    // Debug aid: `PLUM_DUMP_WASM=out.wasm plum test file.plum` keeps the module.
+    if let Some(path) = std::env::var_os("PLUM_DUMP_WASM") {
+        let _ = fs::write(path, &compiled.0);
+    }
+    Ok(compiled)
 }
 fn cmdCompile(

plum-wasm-codegen/src/lib.rs CHANGED Viewed

@@ -314,6 +314,11 @@ pub struct FuncSig {
     /// TRAILING ones compiled from here (see `compileCallArgs`). Always
     /// `vec![]` for an `extern fun` (the checker rejects a default there).
     pub param_defaults: Vec<Option<ast::Expr>>,
+    /// The DECLARED (generic, un-instantiated) param types, excluding any
+    /// implicit receiver, and the declared return type. A `TParam` slot is
+    /// erased to `ref null $Obj`, so the caller boxes/unboxes against these.
+    pub decl_params: Vec<PlumType>,
+    pub decl_ret: PlumType,
 }
 /// Everything codegen needs to know about one closure *literal* found in the program.
@@ -332,20 +337,26 @@ pub struct ClosureInfo {
     /// order) — assigned once all closures are discovered, alongside every other
     /// closure's env type and the shared closure-value struct, in one `rec` group.
     pub env_type_idx: u32,
-    /// Closure param val types (NOT including the implicit leading env pointer).
-    pub param_vts: Vec<ValType>,
     /// Closure param plum types (for the closure body's own type env).
     pub param_ptypes: Vec<PlumType>,
-    /// Closure return val type (`None` for a `Unit`-returning closure).
+    /// Closure return plum type.
-    pub ret_vt: Option<ValType>,
+    pub ret_ptype: PlumType,
     /// Free variables captured by value, in a stable (first-appearance) order; the
     /// index into this vec IS the variable's field index in the env struct.
     pub free_vars: Vec<(String, PlumType)>,
 }
-/// Key for deduplicating `call_indirect` function-type indices: the full wasm
+/// Closure ABI (the "erased" calling convention): EVERY closure, whatever its
-/// signature (leading env-ptr param included) of a closure.
+/// Plum signature, compiles to the wasm function type `(env: anyref, a1: anyref,
+/// ..., an: anyref) -> anyref`, so a closure value is callable from any
+/// `fn(...)`-typed slot (including a generic `fn(T) -> U` one) through a single
+/// `call_indirect` type per arity. A primitive argument/result is boxed at that
+/// edge (`$BoxI64`/`$BoxF64`/`$BoxI32`) and unboxed again inside the closure body
+/// (prologue) / at the call site (result); reference values pass as-is, and a
+/// `Unit` result is a null `anyref`. This keeps one wasm function per closure
+/// literal and needs no per-instantiation thunk: the "thunk" work is done in the
+/// closure's own prologue and the call site's epilogue.
-type ClosureSigKey = (Vec<ValType>, Option<ValType>);
+type ClosureSigKey = usize;
 /// Global, read-only lookup tables shared by every function body being compiled.
 pub struct CompileCtx<'a> {
@@ -361,8 +372,11 @@ pub struct CompileCtx<'a> {
     /// The AST of each discovered closure literal, keyed the same way, so its body can
     /// be compiled in a second pass after all closures are registered.
     pub closure_asts: HashMap<usize, &'a ast::Closure>,
-    /// Closure wasm signature -> function-type index, for `call_indirect` at call sites.
+    /// Closure arity -> the erased `call_indirect` function-type index.
     pub closure_call_types: HashMap<ClosureSigKey, u32>,
+    /// Instantiated type of every expression of the (un-monomorphized) source,
+    /// keyed by expression address — from `plum_checker::typedSource`.
+    pub types: HashMap<usize, PlumType>,
     /// Top-level function name -> global index holding its zero-capture "trampoline"
     /// closure struct `{table_idx, env=null}`, for using a plain named function
     /// wherever a `fn(...)`-typed value is expected (e.g. `each(double)`). Since the
@@ -377,6 +391,10 @@ pub struct CompileCtx<'a> {
     /// content equality (1/0) — see the comment on its registration site for
     /// why `==`/`!=` on `Str` needs this instead of plain `ref.eq`.
     pub string_eq_func: u32,
+    /// Shared runtime helper `(a: ref null $Obj, b: ref null $Obj) -> i32`: `==` on
+    /// two erased (`TParam`-typed) values — identity, else by value for boxed
+    /// `Int`/`Float`/`Byte` and content for `Str`.
+    pub dyn_eq_func: u32,
     /// Shared runtime helper `(n: i64) -> ref Str`: allocates a new `array<i8>`
     /// holding `n`'s decimal representation, for interpolating an `Int`.
     pub int_to_string_func: u32,
@@ -417,11 +435,17 @@ struct LocalCtx<'a> {
     variadic_for_scratch: HashMap<usize, u32>,
     func_ids: &'a HashMap<String, u32>,
     func_sigs: &'a HashMap<String, FuncSig>,
+    types: &'a HashMap<usize, PlumType>,
+    /// Name -> the plum type each local was DECLARED with (so its wasm
+    /// representation is `plumTypeToValtype` of this), as opposed to the
+    /// type of a particular use of it.
+    local_decl_types: HashMap<String, PlumType>,
     closures: &'a HashMap<usize, ClosureInfo>,
     closure_call_types: &'a HashMap<ClosureSigKey, u32>,
     named_fn_values: &'a HashMap<String, u32>,
     string_concat_func: u32,
     string_eq_func: u32,
+    dyn_eq_func: u32,
     int_to_string_func: u32,
     methods: &'a MethodEnv,
     enum_variants: &'a EnumVariants,
@@ -433,15 +457,6 @@ struct LocalCtx<'a> {
     /// statements in order, mirroring `plum-checker`'s own env evolution — needed
     /// to resolve `Attribute`/`ClassCall` targets and pick the right load/store width.
     type_env: RefCell<TypeEnv>,
-    /// Local name -> the exact wasm `call_indirect` signature of the closure literal
-    /// assigned to it (populated when compiling that `Stmt::Assign`, straight from
-    /// the already-correct `ClosureInfo` the discovery pass computed). Exists so
-    /// `compileClosureCall` doesn't have to re-derive the signature via
-    /// `plum_checker::inferExpr` on the closure a second time — which, unlike the
-    /// discovery pass, doesn't have `resolveClosureParamTypesFromUsage`'s fix
-    /// and would fall back to its old TVar-defaults-to-Int behavior, disagreeing
-    /// with the (now correct) signature the closure's body was actually compiled with.
-    closure_local_sigs: RefCell<HashMap<String, ClosureSigKey>>,
     /// How many wasm structured blocks (`if`/`else`) currently lie between the
     /// point being compiled and its NEAREST ENCLOSING LOOP's own `block`/`loop`
     /// pair — used by `Stmt::Break`/`Stmt::Continue` to compute the right `br`
@@ -457,9 +472,15 @@ struct LocalCtx<'a> {
     /// The declared return type of the function being compiled (`None` inside a
     /// closure body) — `?` builds the OUTER function's `Err` variant from it.
     ret_type: Option<PlumType>,
+    /// Whether this body is a closure literal's: `return` then yields an erased
+    /// (`anyref`) value per the closure ABI instead of `ret_type`'s own repr.
+    in_closure: bool,
     /// Match-subject scratch local -> its tag-union type, for subjects whose
     /// static type is a `TTags` (their `Name`/`Class` arms test `$Tag.id`).
     match_subject_types: RefCell<HashMap<u32, PlumType>>,
+    /// Match-subject scratch local -> the subject's full plum type (type arguments
+    /// included), so constructor patterns can instantiate their payload types.
+    subject_ptypes: RefCell<HashMap<u32, PlumType>>,
 }
 fn fnKey(f: &ast::Fn) -> String {
@@ -492,6 +513,12 @@ fn fnWasmParamTypes(f: &ast::Fn, gc_types: &GcTypeRegistry) -> Vec<ValType> {
     param_types
 }
+/// A single uppercase letter is the grammar's only spelling of a generic parameter.
+fn isGenericName(name: &str) -> bool {
+    let mut chars = name.chars();
+    matches!((chars.next(), chars.next()), (Some(c), None) if c.is_ascii_uppercase())
+}
 fn paramTypeName(pt: &ast::ParamType) -> &str {
     match pt {
         ast::ParamType::Type(t) => t.name.as_str(),
@@ -531,6 +558,24 @@ thread_local! {
         const { RefCell::new(std::collections::BTreeMap::new()) };
 }
+/// A variant's payload field types as instantiated by `subject_ty`'s type
+/// arguments. A field whose argument the checker could not resolve (matching
+/// through a bare `Parcel` annotation) keeps its declared, erased type, so a
+/// binding of it stays a `ref null $Obj` instead of guessing a representation.
+fn instFields(info: &EnumVariantInfo, subject_ty: &PlumType) -> Vec<PlumType> {
+    plum_checker::variantFields(info, subject_ty)
+        .into_iter()
+        .zip(info.field_types.iter())
+        .map(|(inst, decl)| match inst {
+            PlumType::TVar(_) => decl.clone(),
+            other => other,
+        })
+        .collect()
+}
+/// Largest closure arity with a pre-registered erased `call_indirect` type.
+const MAX_CLOSURE_ARITY: usize = 8;
 /// Import key of the `plum::crash(Str)` host function in `func_ids`.
 const CRASH_FN_KEY: &str = "__crash";
@@ -572,55 +617,25 @@ fn tagId(name: &str) -> i32 {
     })
 }
-/// Collects every tag name inside every `[...]` tag-union segment of `s`
+/// Collects every tag name appearing anywhere inside `ty` (tag-union keys and,
-/// (a canonical type or mangled name), recursing into payload types.
+/// recursively, their payload types and every type argument).
-fn collectTagNames(s: &str, out: &mut std::collections::BTreeSet<String>) {
+fn collectTagNamesTy(ty: &PlumType, out: &mut std::collections::BTreeSet<String>) {
-    let chars: Vec<char> = s.chars().collect();
-    let mut i = 0;
-    while i < chars.len() {
-        if chars[i] == '[' && chars.get(i + 1) != Some(&']') {
-            let start = i;
-            let mut depth = 0;
-            while i < chars.len() {
-                match chars[i] {
-                    '[' => depth += 1,
-                    ']' => depth -= 1,
-                    _ => {}
-                }
-                i += 1;
-                if depth == 0 {
-                    break;
-                }
-            }
-            let inner: String = chars[start + 1..i.saturating_sub(1)].iter().collect();
-            let mut item = String::new();
-            let mut d = 0;
-            let mut items = Vec::new();
-            for ch in inner.chars() {
-                match ch {
+    match ty {
-                    '(' | '[' => d += 1,
-                    ')' | ']' => d -= 1,
-                    _ => {}
-                }
-                if ch == ',' && d == 0 {
-                    items.push(std::mem::take(&mut item));
+        PlumType::TTags(tags) => {
-                } else {
-                    item.push(ch);
-                }
-            }
-            items.push(item);
-            for it in items {
+            for (name, payload) in tags {
-                let name = it.split('(').next().unwrap_or("").trim().to_string();
-                if !name.is_empty() {
-                    out.insert(name);
+                out.insert(name.clone());
-                }
-                if let Some(pos) = it.find('(') {
+                if let Some(p) = payload {
-                    collectTagNames(&it[pos + 1..], out);
+                    collectTagNamesTy(p, out);
                 }
             }
-        } else {
-            i += 1;
         }
+        PlumType::TApp(_, args) => args.iter().for_each(|a| collectTagNamesTy(a, out)),
+        PlumType::TFun(ps, r) => {
+            ps.iter().for_each(|p| collectTagNamesTy(p, out));
+            collectTagNamesTy(r, out);
+        }
+        PlumType::TVariadic(i) => collectTagNamesTy(i, out),
+        _ => {}
     }
 }
@@ -636,21 +651,53 @@ fn boxTagPayload(ty: &PlumType, body: &mut Vec<u8>, ctx: &LocalCtx) {
     }
 }
-/// Boxes the primitive on top of the stack (`ty`) into its `$Box*` struct when
+/// Converts the value on top of the stack from representation `from` to `to`
-/// it flows into a slot whose wasm type is `expected` and `ty` itself is not a
-/// reference — i.e. an `Int`/`Float`/`Byte` entering a trait-typed (`$Obj`) slot.
+/// (the erased-generics edge conversions): a primitive entering a reference slot
+/// (`ref null $Obj` / `anyref`) is boxed; a reference leaving such a slot for a
+/// primitive is cast to the matching box and unboxed; a reference leaving the
+/// erased supertype for a concrete struct/enum/tag type is `ref.cast` down.
+/// Identical representations and upcasts emit nothing.
-fn boxIfPrimitiveIntoObj(ty: &PlumType, expected: ValType, body: &mut Vec<u8>, ctx: &LocalCtx) {
+fn coerceVt(from: ValType, to: ValType, body: &mut Vec<u8>, g: &GcTypeRegistry) {
-    let ValType::Ref(rt) = expected else { return };
+    if from == to {
-    if rt.heap_type != HeapType::Concrete(ctx.gc_types.obj_type_idx) {
         return;
     }
+    match (from, to) {
+        (ValType::I64, ValType::Ref(_)) => Instruction::Call(g.box_i64_fn).encode(body),
+        (ValType::F64, ValType::Ref(_)) => Instruction::Call(g.box_f64_fn).encode(body),
+        (ValType::I32, ValType::Ref(_)) => Instruction::Call(g.box_i32_fn).encode(body),
-    if matches!(ty, PlumType::TInt | PlumType::TFloat | PlumType::TByte) {
+        (ValType::Ref(_), prim @ (ValType::I64 | ValType::F64 | ValType::I32)) => {
+            let idx = match prim {
-        boxTagPayload(ty, body, ctx);
+                ValType::I64 => g.box_i64_idx,
+                ValType::F64 => g.box_f64_idx,
+                _ => g.box_i32_idx,
+            };
+            Instruction::RefCastNonNull(HeapType::Concrete(idx)).encode(body);
+            Instruction::StructGet {
+                struct_type_index: idx,
+                field_index: fld(0),
+            }
+            .encode(body);
+        }
+        (ValType::Ref(f), ValType::Ref(t)) => {
+            // Only a downcast out of the erased supertype (`$Obj`) or an abstract
+            // ref (`anyref`) needs an instruction; anything else is an upcast.
+            let from_erased = match f.heap_type {
+                HeapType::Concrete(fi) => fi == g.obj_type_idx,
+                _ => true,
+            };
+            if let HeapType::Concrete(ti) = t.heap_type {
+                if from_erased && !matches!(f.heap_type, HeapType::Concrete(fi) if fi == ti) {
+                    Instruction::RefCastNullable(t.heap_type).encode(body);
+                }
+            }
+        }
+        _ => {}
     }
 }
-/// Compiles `expr` and, if it is a primitive flowing into a trait-typed slot of
+/// Compiles `expr` and converts its value to representation `expected` (when given):
+/// boxes a primitive flowing into an erased (`ref null $Obj`) slot, casts an
-/// wasm type `expected`, boxes it.
+/// erased value down to the concrete type a slot expects.
 fn compileExprAs(
     expr: &ast::Expr,
     expected: Option<ValType>,
@@ -659,15 +706,52 @@ fn compileExprAs(
     state: &mut ModuleState,
 ) -> Result<(), String> {
     compileExpr(expr, body, ctx, state)?;
-    if let Some(vt @ ValType::Ref(rt)) = expected {
+    if let Some(vt) = expected {
-        if rt.heap_type == HeapType::Concrete(ctx.gc_types.obj_type_idx) {
-            let ty = inferLocalType(expr, ctx);
+        let own = plumTypeToValtype(&inferLocalType(expr, ctx));
-            boxIfPrimitiveIntoObj(&ty, vt, body, ctx);
+        coerceVt(own, vt, body, ctx.gc_types);
-        }
     }
     Ok(())
 }
+/// The variant of enum `decl` that bare-wraps the primitive type `actual`
+/// (`enum Number = | Int | Float`), if `decl` names such an enum.
+fn primitiveWrapVariant(decl: &PlumType, actual: &PlumType, ctx: &LocalCtx) -> Option<String> {
+    if !matches!(actual, PlumType::TInt | PlumType::TFloat) {
+        return None;
+    }
+    let enum_name = plum_checker::nominalName(decl)?;
+    ctx.enum_variants
+        .iter()
+        .find(|(_, info)| {
+            info.enum_name == enum_name
+                && info.field_names.is_empty()
+                && info.field_types == [actual.clone()]
+        })
+        .map(|(n, _)| n.clone())
+}
+/// Like `compileExprAs`, for a slot whose DECLARED plum type is `decl`: a bare
+/// `Int`/`Float` flowing into a `Number`-like union enum is wrapped in the
+/// matching variant (the old monomorphizer's `wrapPrimitiveAgainstExpected`).
+fn compileExprInto(
+    expr: &ast::Expr,
+    decl: &PlumType,
+    body: &mut Vec<u8>,
+    ctx: &LocalCtx,
+    state: &mut ModuleState,
+) -> Result<(), String> {
+    let actual = inferLocalType(expr, ctx);
+    if let Some(variant) = primitiveWrapVariant(decl, &actual, ctx) {
+        if let Some(&vidx) = ctx.gc_types.variant_type_idx.get(&variant) {
+            Instruction::I32Const(typeIdOf(ctx.gc_types, &variant)).encode(body);
+            compileExpr(expr, body, ctx, state)?;
+            Instruction::StructNew(vidx).encode(body);
+            return Ok(());
+        }
+    }
+    compileExprAs(expr, Some(plumTypeToValtype(decl)), body, ctx, state)
+}
 /// Inverse of `boxTagPayload`: an `anyref` payload on the stack becomes a `ty` value.
 fn unboxTagPayload(ty: &PlumType, body: &mut Vec<u8>, ctx: &LocalCtx) {
     let unbox = |idx: u32, body: &mut Vec<u8>| {
@@ -771,6 +855,8 @@ fn astTypeToWasm(name: &str) -> Option<ValType> {
         other if other.starts_with('[') && !other.starts_with("[]") => {
             Some(withGcTypes(|r| gcRef(r.tag_type_idx)))
         }
+        // A generic parameter (`T`) is erased to the common `$Obj` supertype.
+        other if isGenericName(other) => Some(plumTypeToValtype(&PlumType::TParam(other.to_string()))),
         other => Some(plumTypeToValtype(&PlumType::TNamed(other.to_string()))),
     }
 }
@@ -853,7 +939,8 @@ fn plumTypeToValtype(t: &PlumType) -> ValType {
         // existing "not modeled as a concrete shape here" treatment.
         PlumType::TTags(_) => withGcTypes(|r| gcRef(r.tag_type_idx)),
         PlumType::TFun(_, _) | PlumType::TVariadic(_) => ValType::Ref(RefType::ANYREF),
+        PlumType::TParam(_) => withGcTypes(|r| gcRef(r.obj_type_idx)),
-        PlumType::TVar(_) | PlumType::TParam(_) | PlumType::TUnit => ValType::I64,
+        PlumType::TVar(_) | PlumType::TUnit => ValType::I64,
     }
 }
@@ -948,7 +1035,7 @@ fn typeIdOf(r: &GcTypeRegistry, name: &str) -> i32 {
 /// compiler intrinsics rather than compiled `todo` bodies (see
 /// `compileIntrinsicFnBody`).
 fn isArraySpecialization(name: &str) -> bool {
-    name == "Array" || name.starts_with("Array$")
+    name == "Array"
 }
 /// Resolves a plum type to the wasm-gc `ValType` its values are represented as, given
@@ -1008,7 +1095,8 @@ fn plumTypeToGcValtype(t: &PlumType, registry: &GcTypeRegistry) -> ValType {
         // yet-meaningful placeholder in the meantime, since nothing consumes it yet.
         PlumType::TTags(_) => gcRef(registry.tag_type_idx),
         PlumType::TFun(_, _) | PlumType::TVariadic(_) => ValType::Ref(RefType::ANYREF),
+        PlumType::TParam(_) => gcRef(registry.obj_type_idx),
-        PlumType::TVar(_) | PlumType::TParam(_) | PlumType::TUnit => ValType::I64,
+        PlumType::TVar(_) | PlumType::TUnit => ValType::I64,
     }
 }
@@ -1051,9 +1139,6 @@ fn buildGcTypeRegistry(
     let mut enum_super_type_idx: HashMap<String, u32> = HashMap::new();
     let mut variant_type_idx: HashMap<String, u32> = HashMap::new();
     let mut array_ref_slot: Option<u32> = None;
-    let mut erased_enum_super: HashMap<String, u32> = HashMap::new();
-    let mut erased_variant_idx: HashMap<String, u32> = HashMap::new();
-    let mut erased_enum_id: HashMap<String, i32> = HashMap::new();
     // `Bool` is an ordinary enum now (`type Bool = | True | False` in
     // `libs/std/Bool.plum`) — registered exactly like any other enum
@@ -1094,32 +1179,6 @@ fn buildGcTypeRegistry(
             }
             continue;
         }
-        // Specializations that differ only in their tag-union segments
-        // (`Try$Int$[A]` / `Try$Int$[A,B]`) share ONE set of wasm types — every
-        // tag value is the same `$Tag` struct — so a later one is aliased onto
-        // the first one's slots instead of getting its own.
-        let erased_enum = plum_checker::erasedEnumName(enum_name);
-        if let Some(existing_super) = erased_enum_super.get(&erased_enum) {
-            enum_super_type_idx.insert(enum_name.clone(), *existing_super);
-            // Shares the first specialization's wasm types, and so its typeId.
-            if let Some(first_id) = erased_enum_id.get(&erased_enum).copied() {
-                type_ids.insert(enum_name.clone(), first_id);
-                for vname in variant_names {
-                    type_ids.insert(vname.clone(), first_id);
-                }
-            }
-            for vname in variant_names {
-                let ev = plum_checker::erasedEnumName(vname);
-                if let Some(idx) = erased_variant_idx.get(&ev) {
-                    variant_type_idx.insert(vname.clone(), *idx);
-                    continue;
-                }
-                variant_type_idx.insert(vname.clone(), slots.len() as u32);
-                erased_variant_idx.insert(ev, slots.len() as u32);
-                slots.push(Slot::Variant(vname.clone()));
-            }
-            continue;
-        }
         let this_id = match enum_name.as_str() {
             "Str" => TYPE_ID_STR,
             "Buffer" => TYPE_ID_BUFFER,
@@ -1133,13 +1192,10 @@ fn buildGcTypeRegistry(
         for vname in variant_names {
             type_ids.insert(vname.clone(), this_id);
         }
-        erased_enum_id.insert(erased_enum.clone(), this_id);
         enum_super_type_idx.insert(enum_name.clone(), slots.len() as u32);
-        erased_enum_super.insert(erased_enum, slots.len() as u32);
         slots.push(Slot::EnumSuper(enum_name.clone()));
         for vname in variant_names {
             variant_type_idx.insert(vname.clone(), slots.len() as u32);
-            erased_variant_idx.insert(plum_checker::erasedEnumName(vname), slots.len() as u32);
             slots.push(Slot::Variant(vname.clone()));
         }
         // A RECORD-shaped enum (the `type X = ...` replacement, e.g. `enum Cat =
@@ -1347,21 +1403,6 @@ fn boxSubType(vt: ValType, obj_type_idx: u32) -> SubType {
     }
 }
-/// Maps an `ast::ParamType::Fn(params, ret)` to the wasm signature of the *closure
-/// function* it compiles to: an implicit leading `env: anyref`, then one param per
-/// declared param type, returning `ret`'s val type (or nothing for `Unit`).
-fn fnParamTypeToWasmSig(
-    params: &[ast::Type],
-    ret: &Option<Box<ast::Type>>,
-) -> (Vec<ValType>, Option<ValType>) {
-    let mut vts = vec![ValType::Ref(RefType::ANYREF)]; // env pointer
-    for p in params {
-        vts.push(astTypeToWasm(&p.name).unwrap_or(ValType::I32));
-    }
-    let ret_vt = ret.as_ref().and_then(|t| astTypeToWasm(&t.name));
-    (vts, ret_vt)
-}
 fn blockTypeFor(result_vt: Option<ValType>) -> BlockType {
     result_vt.map(BlockType::Result).unwrap_or(BlockType::Empty)
 }
@@ -1414,6 +1455,16 @@ fn checkCtxOf<'a>(
 /// already accepted by `plum_checker::checkSource`, so a failure here would indicate
 /// codegen is being driven directly on unchecked input (as some tests do).
 fn inferLocalType(expr: &ast::Expr, ctx: &LocalCtx) -> PlumType {
+    // The checker's instantiated type for this exact expression node, if any;
+    // synthesized nodes (desugarings built during codegen) fall back to
+    // re-inference against the local type env.
+    if let Some(t) = ctx.types.get(&(expr as *const ast::Expr as usize)) {
+        return t.clone();
+    }
+    inferFallbackType(expr, ctx)
+}
+fn inferFallbackType(expr: &ast::Expr, ctx: &LocalCtx) -> PlumType {
     let env = ctx.type_env.borrow();
     let cctx = checkCtxOf(
         ctx.methods,
@@ -1425,6 +1476,14 @@ fn inferLocalType(expr: &ast::Expr, ctx: &LocalCtx) -> PlumType {
 }
 pub fn compileSource(source: &ast::Source) -> Result<Vec<u8>, String> {
+    compileSourceInner(source, &[]).map(|(bytes, _)| bytes)
+}
+/// Like `compileSource`, also returning the key of every compiled function
+/// (`name` or `Receiver::method`) — one entry per source function, since a
+/// generic function/method compiles exactly once however many types it is
+/// instantiated at.
+pub fn compileSourceWithFunctions(source: &ast::Source) -> Result<(Vec<u8>, Vec<String>), String> {
     compileSourceInner(source, &[])
 }
@@ -1446,7 +1505,7 @@ pub fn compileTestSource(source: &ast::Source) -> Result<(Vec<u8>, Vec<String>),
         .iter()
         .map(|(_, export_name)| export_name["test#".len()..].to_string())
         .collect();
-    let wasm = compileSourceInner(&desugared, &extra_exports)?;
+    let (wasm, _) = compileSourceInner(&desugared, &extra_exports)?;
     Ok((wasm, names))
 }
@@ -1616,26 +1675,35 @@ fn desugarAssertStmt(stmt: &ast::Stmt) -> ast::Stmt {
 fn compileSourceInner(
     source: &ast::Source,
     extra_exports: &[(String, String)],
-) -> Result<Vec<u8>, String> {
+) -> Result<(Vec<u8>, Vec<String>), String> {
+    // The source is compiled as written (generics erased, not specialized): the
+    // checker's per-expression instantiated types drive every box/unbox decision.
-    let source = &plum_checker::monomorphize::monomorphizeSource(source)?;
+    let typed = plum_checker::typedSource(source).map_err(|errs| {
+        errs.iter()
+            .map(|e| format!("type error: {}", e.message))
+            .collect::<Vec<_>>()
+            .join("\n")
+    })?;
+    let types = typed.expr_types;
-    let (global_env, methods, enum_variants, enum_params) = plum_checker::buildGlobalTables(source);
+    let (global_env, methods, enum_variants, enum_params) = plum_checker::buildTables(source, true);
     let min_required = plum_checker::buildMinRequiredArgs(source);
     // Intern every tag name the program's types mention, in sorted order.
     {
         let mut names = std::collections::BTreeSet::new();
-        for (k, info) in &enum_variants {
+        for info in enum_variants.values() {
-            collectTagNames(k, &mut names);
-            collectTagNames(&info.enum_name, &mut names);
             for t in &info.field_types {
-                collectTagNames(&t.to_string(), &mut names);
+                collectTagNamesTy(t, &mut names);
             }
         }
         for scheme in global_env.values() {
-            collectTagNames(&scheme.body.to_string(), &mut names);
+            collectTagNamesTy(&scheme.body, &mut names);
         }
         for t in methods.values() {
-            collectTagNames(&t.to_string(), &mut names);
+            collectTagNamesTy(t, &mut names);
+        }
+        for t in types.values() {
+            collectTagNamesTy(t, &mut names);
         }
         CURRENT_TAG_IDS.with(|c| {
             *c.borrow_mut() = names
@@ -1726,6 +1794,12 @@ fn compileSourceInner(
                     params: param_types,
                     ret,
                     param_defaults: Vec::new(),
+                    decl_params: f.params.iter().map(|p| paramPlumType(&p.ty)).collect(),
+                    decl_ret: f
+                        .returns
+                        .as_ref()
+                        .map(plum_checker::plumTypeFromAstG)
+                        .unwrap_or(PlumType::TUnit),
                 },
             );
         }
@@ -1814,9 +1888,14 @@ fn compileSourceInner(
     }
     CURRENT_GC_TYPES.with(|c| *c.borrow_mut() = Some(gc_types.clone()));
+    // Closure ABI (see `ClosureSigKey`): one erased `call_indirect` type per arity,
-    // Closure wasm signature -> function-type index, deduped so every closure/call site
+    // `(env, anyref * n) -> anyref`, shared by every closure and call site.
-    // of the same shape shares one `call_indirect` type.
     let mut closure_call_types: HashMap<ClosureSigKey, u32> = HashMap::new();
+    for arity in 0..=MAX_CLOSURE_ARITY {
+        let params = vec![ValType::Ref(RefType::ANYREF); arity + 1];
+        let t = module.addType(&params, &[ValType::Ref(RefType::ANYREF)]);
+        closure_call_types.insert(arity, t);
+    }
     // Register every function AND method signature up front (methods get an implicit
     // leading `self: pointer` param and are keyed as "Receiver::method").
@@ -1846,23 +1925,14 @@ fn compileSourceInner(
                     params: param_types,
                     ret,
                     param_defaults,
+                    decl_params: f.params.iter().map(|p| paramPlumType(&p.ty)).collect(),
+                    decl_ret: f
+                        .returns
+                        .as_ref()
+                        .map(plum_checker::plumTypeFromAstG)
+                        .unwrap_or(PlumType::TUnit),
                 },
             );
-            // Any `fn(...) -> ...`-typed param is callable via `call_indirect`; register
-            // its wasm signature (leading env-ptr param included) so call sites can
-            // resolve a consistent type index even if no matching closure literal exists.
-            for p in &f.params {
-                if let ast::ParamType::Fn(params, ret) = &p.ty {
-                    let (sig_params, ret_vt) = fnParamTypeToWasmSig(params, ret);
-                    let sig_key: ClosureSigKey = (sig_params.clone(), ret_vt);
-                    if !closure_call_types.contains_key(&sig_key) {
-                        let results: Vec<ValType> = ret_vt.into_iter().collect();
-                        let tidx = module.addType(&sig_params, &results);
-                        closure_call_types.insert(sig_key, tidx);
-                    }
-                }
-            }
         }
     }
@@ -1908,21 +1978,12 @@ fn compileSourceInner(
     let mut raw_closures: Vec<RawClosure> = Vec::new();
     let mut named_fn_refs: HashSet<String> = HashSet::new();
     for f in &fns {
-        let mut env = global_env.clone();
-        if let Some(recv) = &f.type_param {
-            env.insert(
-                "self".to_string(),
-                TypeScheme::mono(plum_checker::plumTypeFromName(recv)),
-            );
-        }
         let mut locals: HashSet<String> = HashSet::new();
         for p in &f.params {
-            env.insert(p.name.clone(), TypeScheme::mono(paramPlumType(&p.ty)));
             locals.insert(p.name.clone());
         }
         let mut walker = ClosureWalker {
-            env,
-            cctx: checkCtxOf(&methods, &enum_variants, &enum_params, &min_required),
+            types: &types,
             fn_decls: &fn_decls,
             found: Vec::new(),
             locals,
@@ -1930,7 +1991,7 @@ fn compileSourceInner(
         };
         match &f.body {
             ast::FnBody::Block(block) => walker.walkBlock(block),
-            ast::FnBody::Expr(e) => walker.walkExpr(e, None),
+            ast::FnBody::Expr(e) => walker.walkExpr(e),
             // `fns` excludes every `extern fun` (no body to discover closures in).
             ast::FnBody::Extern => unreachable!("extern fns are excluded from `fns`"),
         }
@@ -1990,18 +2051,10 @@ fn compileSourceInner(
     let mut closures: HashMap<usize, ClosureInfo> = HashMap::new();
     let mut closure_asts: HashMap<usize, &ast::Closure> = HashMap::new();
     for (i, rc) in raw_closures.iter().enumerate() {
-        let mut sig_params = vec![ValType::Ref(RefType::ANYREF)]; // env pointer
-        sig_params.extend(rc.param_vts.iter().copied());
-        let sig_key: ClosureSigKey = (sig_params.clone(), rc.ret_vt);
+        let arity = rc.closure.params.len();
-        let type_idx = match closure_call_types.get(&sig_key) {
+        let type_idx = *closure_call_types
-            Some(t) => *t,
+            .get(&arity)
-            None => {
-                let results: Vec<ValType> = rc.ret_vt.into_iter().collect();
+            .ok_or_else(|| format!("codegen: closures with {} params are not supported", arity))?;
-                let t = module.addType(&sig_params, &results);
-                closure_call_types.insert(sig_key, t);
-                t
-            }
-        };
         let func_idx = module.addFunction(type_idx, &[]);
         let table_idx = module.addTableElement(func_idx);
         closures.insert(
@@ -2010,9 +2063,8 @@ fn compileSourceInner(
                 func_idx,
                 table_idx,
                 env_type_idx: closure_type_indices[i + 1],
-                param_vts: rc.param_vts.clone(),
                 param_ptypes: rc.param_ptypes.clone(),
-                ret_vt: rc.ret_vt,
+                ret_ptype: rc.ret_ptype.clone(),
                 free_vars: rc.free_vars.clone(),
             },
         );
@@ -2021,10 +2073,11 @@ fn compileSourceInner(
     // Register a zero-capture "trampoline" closure for every top-level function
     // referenced as a bare value (e.g. `each(double)`): a real wasm function with the
-    // closure calling convention `(env, ...real_params) -> ret` that ignores its env
+    // erased closure ABI `(env, anyref...) -> anyref` that ignores its env, unboxes
+    // each argument to the real function's parameter representation, forwards to the
-    // and forwards straight to the real function, plus a funcref-table entry for it.
+    // real function and boxes its result, plus a funcref-table entry for it. Since
-    // Since it never captures anything, its `{table_idx, env=null}` closure struct is
+    // it never captures anything, its `{table_idx, env=null}` closure struct is a
-    // a compile-time constant — like every payload-free enum variant, built once by
+    // compile-time constant — like every payload-free enum variant, built once by
     // the shared `start` function and stored in its own global.
     let mut named_fn_values: HashMap<String, u32> = HashMap::new();
     for name in &named_fn_refs {
@@ -2034,26 +2087,22 @@ fn compileSourceInner(
         let real_func_idx = *func_ids
             .get(name)
             .expect("named fn ref must be a registered top-level function");
-        let mut sig_params = vec![ValType::Ref(RefType::ANYREF)]; // env pointer
-        sig_params.extend(sig.params.iter().copied());
+        let arity = sig.params.len();
-        let sig_key: ClosureSigKey = (sig_params.clone(), sig.ret);
-        let type_idx = match closure_call_types.get(&sig_key) {
+        let type_idx = *closure_call_types
-            Some(t) => *t,
+            .get(&arity)
-            None => {
-                let results: Vec<ValType> = sig.ret.into_iter().collect();
+            .ok_or_else(|| format!("codegen: function '{}' has too many params to use as a value", name))?;
-                let t = module.addType(&sig_params, &results);
-                closure_call_types.insert(sig_key, t);
-                t
-            }
-        };
         let mut tbody = Vec::new();
         tbody.push(0u8); // no locals beyond the params already in the signature
-        for i in 0..sig.params.len() {
+        for (i, vt) in sig.params.iter().enumerate() {
             Instruction::LocalGet((i + 1) as u32).encode(&mut tbody); // local 0 is env, ignored
+            coerceVt(ValType::Ref(RefType::ANYREF), *vt, &mut tbody, &gc_types);
         }
         Instruction::Call(real_func_idx).encode(&mut tbody);
+        match sig.ret {
+            Some(rvt) => coerceVt(rvt, ValType::Ref(RefType::ANYREF), &mut tbody, &gc_types),
+            None => Instruction::RefNull(HeapType::ANY).encode(&mut tbody),
+        }
         Instruction::End.encode(&mut tbody);
         let func_idx = module.addFunction(type_idx, &tbody);
         let table_idx = module.addTableElement(func_idx);
@@ -2084,6 +2133,7 @@ fn compileSourceInner(
     // (unconditionally, for simplicity) since they're cheap and self-contained.
     let string_concat_func = registerStringConcatHelper(&mut module, gc_types.byte_array_type_idx);
     let string_eq_func = registerStringEqHelper(&mut module, gc_types.byte_array_type_idx);
+    let dyn_eq_func = registerDynEqHelper(&mut module, &gc_types, string_eq_func);
     let int_to_string_func = registerIntToStringHelper(&mut module, gc_types.byte_array_type_idx);
     let ctx = CompileCtx {
@@ -2097,9 +2147,11 @@ fn compileSourceInner(
         closures,
         closure_asts,
         closure_call_types,
+        types,
         named_fn_values,
         string_concat_func,
         string_eq_func,
+        dyn_eq_func,
         int_to_string_func,
         gc_types,
         singleton_globals,
@@ -2163,7 +2215,14 @@ fn compileSourceInner(
         module.addExport(export_name, ExportKind::Func, idx);
     }
+    let mut fn_keys: Vec<String> = ctx
+        .func_ids
+        .keys()
+        .filter(|k| k.as_str() != CRASH_FN_KEY)
+        .cloned()
+        .collect();
+    fn_keys.sort();
-    Ok(module.finish())
+    Ok((module.finish(), fn_keys))
 }
 /// `(payload) -> ref $Box*`: allocates a box with its header typeId set.
@@ -2337,6 +2396,98 @@ fn registerDynDispatchers(
     gc_types.dyn_fns.extend(registered);
 }
+/// Registers `__dyn_eq(a: ref null $Obj, b: ref null $Obj) -> i32`, the `==` of two
+/// erased (`TParam`-typed) values: reference identity first, then — for two
+/// values of the same `typeId` — payload equality for boxed `Int`/`Float`/`Byte`
+/// and byte-for-byte content equality for `Str`. Everything else (class/enum
+/// instances) is identity, exactly like `==` on a concrete reference type.
+fn registerDynEqHelper(module: &mut WasmModule, g: &GcTypeRegistry, string_eq_func: u32) -> u32 {
+    let obj = g.obj_type_idx;
+    let mut b = vec![0u8];
+    let tid = |b: &mut Vec<u8>, local: u32| {
+        Instruction::LocalGet(local).encode(b);
+        Instruction::StructGet {
+            struct_type_index: obj,
+            field_index: 0,
+        }
+        .encode(b);
+    };
+    let i32r = BlockType::Result(ValType::I32);
+    Instruction::LocalGet(0).encode(&mut b);
+    Instruction::LocalGet(1).encode(&mut b);
+    Instruction::RefEq.encode(&mut b);
+    Instruction::If(i32r).encode(&mut b);
+    Instruction::I32Const(1).encode(&mut b);
+    Instruction::Else.encode(&mut b);
+    // either null -> not equal
+    Instruction::LocalGet(0).encode(&mut b);
+    Instruction::RefIsNull.encode(&mut b);
+    Instruction::LocalGet(1).encode(&mut b);
+    Instruction::RefIsNull.encode(&mut b);
+    Instruction::I32Or.encode(&mut b);
+    Instruction::If(i32r).encode(&mut b);
+    Instruction::I32Const(0).encode(&mut b);
+    Instruction::Else.encode(&mut b);
+    // different dynamic types -> not equal
+    tid(&mut b, 0);
+    tid(&mut b, 1);
+    Instruction::I32Ne.encode(&mut b);
+    Instruction::If(i32r).encode(&mut b);
+    Instruction::I32Const(0).encode(&mut b);
+    Instruction::Else.encode(&mut b);
+    let mut ends = 0;
+    for (id, box_idx, eq) in [
+        (TYPE_ID_BOX_I64, g.box_i64_idx, Instruction::I64Eq),
+        (TYPE_ID_BOX_F64, g.box_f64_idx, Instruction::F64Eq),
+        (TYPE_ID_BOX_I32, g.box_i32_idx, Instruction::I32Eq),
+    ] {
+        tid(&mut b, 0);
+        Instruction::I32Const(id).encode(&mut b);
+        Instruction::I32Eq.encode(&mut b);
+        Instruction::If(i32r).encode(&mut b);
+        for local in [0, 1] {
+            Instruction::LocalGet(local).encode(&mut b);
+            Instruction::RefCastNonNull(HeapType::Concrete(box_idx)).encode(&mut b);
+            Instruction::StructGet {
+                struct_type_index: box_idx,
+                field_index: fld(0),
+            }
+            .encode(&mut b);
+        }
+        eq.encode(&mut b);
+        Instruction::Else.encode(&mut b);
+        ends += 1;
+    }
+    match g.class_type_idx.get("Str") {
+        Some(&str_idx) => {
+            tid(&mut b, 0);
+            Instruction::I32Const(TYPE_ID_STR).encode(&mut b);
+            Instruction::I32Eq.encode(&mut b);
+            Instruction::If(i32r).encode(&mut b);
+            for local in [0, 1] {
+                Instruction::LocalGet(local).encode(&mut b);
+                Instruction::RefCastNonNull(HeapType::Concrete(str_idx)).encode(&mut b);
+            }
+            Instruction::Call(string_eq_func).encode(&mut b);
+            Instruction::Else.encode(&mut b);
+            Instruction::I32Const(0).encode(&mut b);
+            Instruction::End.encode(&mut b);
+        }
+        None => Instruction::I32Const(0).encode(&mut b),
+    }
+    for _ in 0..ends {
+        Instruction::End.encode(&mut b);
+    }
+    // close: type-id-ne `if`, null `if`, identity `if`
+    Instruction::End.encode(&mut b);
+    Instruction::End.encode(&mut b);
+    Instruction::End.encode(&mut b);
+    Instruction::End.encode(&mut b);
+    let obj_ref = gcRef(obj);
+    let t = module.addType(&[obj_ref, obj_ref], &[ValType::I32]);
+    module.addFunction(t, &b)
+}
 /// Registers `__string_concat(a: ref Str, b: ref Str) -> ref Str`, a hand-written
 /// runtime helper backing string interpolation. Unwraps both `Str` params down
 /// to their raw `array<i8>`s (`unwrapStrToBytes`) — which each track their own
@@ -2938,18 +3089,19 @@ fn compileArrayIntrinsicFnBody(f: &ast::Fn) -> Option<Vec<u8>> {
     }
 }
-/// The `PlumType` of a declared parameter, including `fn(...)`-typed params as `TFun`.
+/// The `PlumType` of a declared parameter, including `fn(...)`-typed params as `TFun`;
+/// a single-letter generic name is a `TParam`.
 fn paramPlumType(pt: &ast::ParamType) -> PlumType {
     match pt {
-        ast::ParamType::Type(t) => plum_checker::plumTypeFromAst(t),
+        ast::ParamType::Type(t) => plum_checker::plumTypeFromAstG(t),
         ast::ParamType::Variadic(t) => {
-            PlumType::TVariadic(Box::new(plum_checker::plumTypeFromAst(t)))
+            PlumType::TVariadic(Box::new(plum_checker::plumTypeFromAstG(t)))
         }
         ast::ParamType::Fn(params, ret) => {
-            let param_types = params.iter().map(plum_checker::plumTypeFromAst).collect();
+            let param_types = params.iter().map(plum_checker::plumTypeFromAstG).collect();
             let ret_ty = ret
                 .as_ref()
-                .map(|r| plum_checker::plumTypeFromAst(r))
+                .map(|r| plum_checker::plumTypeFromAstG(r))
                 .unwrap_or(PlumType::TUnit);
             PlumType::TFun(param_types, Box::new(ret_ty))
         }
@@ -2961,20 +3113,25 @@ fn paramPlumType(pt: &ast::ParamType) -> PlumType {
 struct RawClosure<'a> {
     ptr: usize,
     closure: &'a ast::Closure,
-    param_vts: Vec<ValType>,
     param_ptypes: Vec<PlumType>,
-    ret_vt: Option<ValType>,
+    ret_ptype: PlumType,
     free_vars: Vec<(String, PlumType)>,
 }
+fn argExprOf(arg: &ast::Arg) -> &ast::Expr {
+    match arg {
+        ast::Arg::Positional(e) => e,
+        ast::Arg::Keyword { value, .. } => value,
+        ast::Arg::Pair { value, .. } => value,
+    }
+}
-/// Walks a function body (maintaining an evolving type env, exactly like `Collector`)
+/// Walks a function body to find every closure literal and the free variables it
+/// captures. A closure's Plum signature is the checker's instantiated `TFun` type
-/// to find every closure literal and determine its concrete signature and captured
+/// of the literal (`types`); its wasm signature is the erased closure ABI
-/// free variables. A closure passed directly as a `fn(...)`-typed call argument takes
-/// its signature from that declared param type; any other closure (e.g. one assigned to
-/// a local) falls back to the checker's inference of the closure expression itself.
+/// (`ClosureSigKey`), independent of those types.
-struct ClosureWalker<'a, 'c> {
+struct ClosureWalker<'a, 't> {
-    env: TypeEnv,
-    cctx: plum_checker::CheckCtx<'c>,
+    types: &'t HashMap<usize, PlumType>,
     fn_decls: &'a HashMap<String, &'a ast::Fn>,
     found: Vec<RawClosure<'a>>,
     /// Local names bound in the function currently being walked (params, assign
@@ -2989,7 +3146,7 @@ struct ClosureWalker<'a, 'c> {
     named_fn_refs: HashSet<String>,
 }
-impl<'a, 'c> ClosureWalker<'a, 'c> {
+impl<'a, 't> ClosureWalker<'a, 't> {
     fn walkBlock(&mut self, block: &'a ast::Block) {
         for s in &block.stmts {
             self.walkStmt(s);
@@ -3000,27 +3157,24 @@ impl<'a, 'c> ClosureWalker<'a, 'c> {
         match stmt {
             ast::Stmt::Assign(a) => {
                 for (target, value) in a.targets.iter().zip(a.values.iter()) {
-                    self.walkExpr(value, None);
+                    self.walkExpr(value);
                     match target {
                         ast::AssignTarget::Var(name) => {
-                            let ty = plum_checker::inferExpr(value, &self.env, &self.cctx)
-                                .unwrap_or(PlumType::TInt);
-                            self.env.insert(name.clone(), TypeScheme::mono(ty));
                             self.locals.insert(name.clone());
                         }
                         ast::AssignTarget::Field(object, _) => {
-                            self.walkExpr(object, None);
+                            self.walkExpr(object);
                         }
                     }
                 }
             }
-            ast::Stmt::Return(Some(e)) => self.walkExpr(e, None),
+            ast::Stmt::Return(Some(e)) => self.walkExpr(e),
             ast::Stmt::Return(None) => {}
             ast::Stmt::If(i) => {
-                self.walkExpr(&i.condition, None);
+                self.walkExpr(&i.condition);
                 self.walkBlock(&i.body);
                 for ei in &i.else_ifs {
-                    self.walkExpr(&ei.condition, None);
+                    self.walkExpr(&ei.condition);
                     self.walkBlock(&ei.body);
                 }
                 if let Some(e) = &i.else_ {
@@ -3028,125 +3182,80 @@ impl<'a, 'c> ClosureWalker<'a, 'c> {
                 }
             }
             ast::Stmt::While(w) => {
-                self.walkExpr(&w.condition, None);
+                self.walkExpr(&w.condition);
                 self.walkBlock(&w.body);
             }
             ast::Stmt::For(f) => {
-                self.walkExpr(&f.iter, None);
+                self.walkExpr(&f.iter);
-                let elem_ty = match plum_checker::inferExpr(&f.iter, &self.env, &self.cctx) {
-                    Ok(PlumType::TVariadic(elem)) => *elem,
-                    _ => PlumType::TInt,
-                };
                 for v in &f.vars {
-                    self.env
-                        .insert(v.clone(), TypeScheme::mono(elem_ty.clone()));
                     self.locals.insert(v.clone());
                 }
                 self.walkBlock(&f.body);
             }
-            ast::Stmt::Expr(e, ..) => self.walkExpr(e, None),
+            ast::Stmt::Expr(e, ..) => self.walkExpr(e),
-            ast::Stmt::Assert(c) => self.walkExpr(&c.cond, None),
+            ast::Stmt::Assert(c) => self.walkExpr(&c.cond),
             ast::Stmt::Match(m) => {
                 for s in &m.subjects {
-                    self.walkExpr(s, None);
+                    self.walkExpr(s);
                 }
                 for case in &m.cases {
+                    if let Some(g) = &case.guard {
+                        self.walkExpr(g);
+                    }
                     self.walkBlock(&case.body);
                 }
             }
             ast::Stmt::Break | ast::Stmt::Continue | ast::Stmt::Todo => {}
-            ast::Stmt::Crash(e) => self.walkExpr(e, None),
+            ast::Stmt::Crash(e) => self.walkExpr(e),
         }
     }
-    /// `expected_fn` carries the declared `fn(params) -> ret` type when this expression is
-    /// a call argument in a `fn`-typed parameter position, giving a closure literal its
-    /// concrete signature.
-    fn walkExpr(&mut self, expr: &'a ast::Expr, expected_fn: Option<PlumType>) {
+    fn walkExpr(&mut self, expr: &'a ast::Expr) {
         match expr {
-            ast::Expr::Closure(cl) => self.recordClosure(cl, expected_fn),
+            ast::Expr::Closure(cl) => self.recordClosure(expr, cl),
             ast::Expr::Binary(b) => {
-                self.walkExpr(&b.left, None);
+                self.walkExpr(&b.left);
-                self.walkExpr(&b.right, None);
+                self.walkExpr(&b.right);
             }
             ast::Expr::Bool(b) => {
-                self.walkExpr(&b.left, None);
+                self.walkExpr(&b.left);
-                self.walkExpr(&b.right, None);
+                self.walkExpr(&b.right);
             }
             ast::Expr::Compare(c) => {
-                self.walkExpr(&c.left, None);
+                self.walkExpr(&c.left);
-                self.walkExpr(&c.right, None);
+                self.walkExpr(&c.right);
             }
-            ast::Expr::Not(inner) => self.walkExpr(inner, None),
+            ast::Expr::Not(inner) => self.walkExpr(inner),
-            ast::Expr::Try(inner) => self.walkExpr(inner, None),
+            ast::Expr::Try(inner) => self.walkExpr(inner),
-            ast::Expr::Unary(u) => self.walkExpr(&u.operand, None),
+            ast::Expr::Unary(u) => self.walkExpr(&u.operand),
-            ast::Expr::Paren(inner) => self.walkExpr(inner, None),
+            ast::Expr::Paren(inner) => self.walkExpr(inner),
             ast::Expr::Ternary(t) => {
-                self.walkExpr(&t.condition, None);
+                self.walkExpr(&t.condition);
-                self.walkExpr(&t.then, None);
+                self.walkExpr(&t.then);
-                self.walkExpr(&t.else_, None);
+                self.walkExpr(&t.else_);
             }
             ast::Expr::Elvis(e) => {
-                self.walkExpr(&e.left, None);
+                self.walkExpr(&e.left);
-                self.walkExpr(&e.right, None);
+                self.walkExpr(&e.right);
             }
             ast::Expr::FnCall(call) => {
-                let callee = self.fn_decls.get(&call.name).copied();
-                for (i, arg) in call.args.iter().enumerate() {
-                    let arg_expr = argExprOf(arg);
+                for arg in &call.args {
-                    let expected = callee
-                        .and_then(|f| f.params.get(i))
-                        .and_then(|p| match &p.ty {
-                            ast::ParamType::Fn(params, ret) => Some(PlumType::TFun(
-                                params.iter().map(plum_checker::plumTypeFromAst).collect(),
-                                Box::new(
-                                    ret.as_deref()
-                                        .map(plum_checker::plumTypeFromAst)
-                                        .unwrap_or(PlumType::TUnit),
-                                ),
-                            )),
-                            _ => None,
-                        });
-                    self.walkExpr(arg_expr, expected);
+                    self.walkExpr(argExprOf(arg));
                 }
             }
             ast::Expr::ClassCall(call) => {
                 for fa in &call.fields {
-                    self.walkExpr(&fa.value, None);
+                    self.walkExpr(&fa.value);
+                }
+                if let Some(sp) = &call.spread {
+                    self.walkExpr(sp);
                 }
             }
             ast::Expr::Attribute(a) => {
-                self.walkExpr(&a.object, None);
+                self.walkExpr(&a.object);
                 if let ast::AttrKind::Method(call) = &a.attr {
-                    // Unlike the `FnCall` arm above (which can look a callee up
-                    // directly by bare name in `fn_decls`), a method's signature
-                    // must be resolved via its RECEIVER's type first — `ctx.methods`
-                    // is keyed `(class_name, method_name)`, and two unrelated
-                    // classes' methods sharing a bare name (`List.each`/`Map.each`)
-                    // would otherwise be ambiguous. Without this lookup, a closure
-                    // argument to ANY method fell back to guessing its param types
-                    // from how they're used in its OWN body (see `recordClosure`'s
-                    // fallback arm) — which silently defaults a non-numeric param
-                    // (e.g. `reduce`'s `Str` accumulator) to `Int`, miscompiling the
-                    // closure with the wrong signature entirely.
-                    let method_sig = plum_checker::inferExpr(&a.object, &self.env, &self.cctx)
-                        .ok()
-                        .and_then(|obj_ty| plum_checker::methodReceiverName(&obj_ty))
-                        .and_then(|class_name| {
-                            self.cctx
-                                .methods
-                                .get(&(class_name, call.name.clone()))
-                                .cloned()
-                        });
-                    for (i, arg) in call.args.iter().enumerate() {
+                    for arg in &call.args {
-                        let expected = match &method_sig {
-                            Some(PlumType::TFun(params, _)) => params
-                                .get(i)
-                                .cloned()
-                                .filter(|p| matches!(p, PlumType::TFun(_, _))),
-                            _ => None,
-                        };
-                        self.walkExpr(argExprOf(arg), expected);
+                        self.walkExpr(argExprOf(arg));
                     }
                 }
             }
@@ -3165,14 +3274,10 @@ impl<'a, 'c> ClosureWalker<'a, 'c> {
             }
             ast::Expr::String(s) => {
                 // A `"{...}"` interpolation can embed an arbitrary expression,
-                // including a closure literal passed straight to a method call
+                // including a closure literal passed straight to a method call.
-                // (`"{l.any(|x| x % 2 == 0)}"`) — walk into it like any other
-                // sub-expression, or such a closure is never discovered by this
-                // pre-pass and codegen later traps with "closure literal was not
-                // discovered by the discovery pre-pass".
                 for part in &s.parts {
                     if let ast::StringPart::Interp(e) = part {
-                        self.walkExpr(e, None);
+                        self.walkExpr(e);
                     }
                 }
             }
@@ -3181,301 +3286,40 @@ impl<'a, 'c> ClosureWalker<'a, 'c> {
         }
     }
-    fn recordClosure(&mut self, cl: &'a ast::Closure, expected_fn: Option<PlumType>) {
+    fn recordClosure(&mut self, expr: &'a ast::Expr, cl: &'a ast::Closure) {
-        let (param_vts, param_ptypes, ret_vt) = match expected_fn {
+        let (param_ptypes, ret_ptype) = match self.types.get(&(expr as *const ast::Expr as usize)) {
-            Some(PlumType::TFun(params, ret)) => {
+            Some(PlumType::TFun(ps, r)) if ps.len() == cl.params.len() => (ps.clone(), (**r).clone()),
-                let param_vts = params.iter().map(plumTypeToValtype).collect();
-                let ret_vt = match *ret {
-                    PlumType::TUnit => None,
-                    other => Some(plumTypeToValtype(&other)),
-                };
-                (param_vts, params, ret_vt)
-            }
-            _ => {
-                // Not a direct `fn`-typed call argument (e.g. assigned to a local
+            // No usable checker type (never expected for checked source): treat
-                // first, then called/passed on later): the checker's own closure
-                // inference (`plum_checker::inferExpr` on `Expr::Closure`) gives
-                // each param a fresh `TVar` and never actually unifies it against
+            // every param as an Int and the result as Unit.
-                // how the param is used in the body — `unify` is a no-op for any
-                // `TVar` — so a param that's genuinely Float or a class/pointer
-                // silently comes back as an unresolved `TVar`, which
-                // `plumTypeToValtype` then defaults to `Int`. If the closure is
-                // later called at its real (non-Int) type, the wasm function actually
-                // compiled for its body (built from this wrong, Int-assumed signature)
-                // won't match the `call_indirect` type the real call site expects —
-                // a mismatch `call_indirect` only traps on at runtime, not at compile
-                // or validation time.
-                //
-                // Fix: resolve each param's type from a direct usage in the body
-                // first (see `resolveClosureParamTypesFromUsage`) — e.g. `cb = |v|
-                // x + v` with a captured `Float` `x` resolves `v` to `Float` from that
-                // `Binary` op — then infer the return type against an env where the
-                // params are already bound concretely (bypassing the checker's
-                // Closure-inference arm entirely, since it always re-binds params to
-                // fresh TVars regardless of what's already in the env passed to it).
-                let resolved_params = resolveClosureParamTypesFromUsage(cl, &self.env, &self.cctx);
-                let param_ptypes: Vec<PlumType> = cl
-                    .params
-                    .iter()
-                    .map(|p| resolved_params.get(p).cloned().unwrap_or(PlumType::TInt))
+            _ => (vec![PlumType::TInt; cl.params.len()], PlumType::TUnit),
-                    .collect();
-                let param_vts: Vec<ValType> = param_ptypes.iter().map(plumTypeToValtype).collect();
-                let mut body_env = self.env.clone();
-                for (p, ty) in cl.params.iter().zip(param_ptypes.iter()) {
-                    body_env.insert(p.clone(), TypeScheme::mono(ty.clone()));
-                }
-                let ret_ty = match cl.body.stmts.last() {
-                    Some(ast::Stmt::Expr(e, ..)) => {
-                        plum_checker::inferExpr(e, &body_env, &self.cctx).ok()
-                    }
-                    Some(ast::Stmt::Return(Some(e))) => {
-                        plum_checker::inferExpr(e, &body_env, &self.cctx).ok()
-                    }
-                    _ => Some(PlumType::TUnit),
-                };
-                let ret_vt = match ret_ty {
-                    Some(PlumType::TUnit) => None,
-                    Some(PlumType::TVar(_)) | None => Some(ValType::I64), // unresolved: preserve prior Int-default behavior
-                    Some(other) => Some(plumTypeToValtype(&other)),
-                };
-                (param_vts, param_ptypes, ret_vt)
-            }
         };
-        let free_vars = collectFreeVars(cl, &self.env, self.fn_decls);
+        let free_vars = collectFreeVars(cl, self.types, self.fn_decls);
         self.found.push(RawClosure {
             ptr: cl as *const ast::Closure as usize,
             closure: cl,
-            param_vts,
+            param_ptypes,
-            param_ptypes: param_ptypes.clone(),
-            ret_vt,
+            ret_ptype,
             free_vars,
         });
         // Recurse into this closure's own body to find any closure literals nested
-        // inside it (`|v| |w| v + w`, or a closure literal used inside a `match`/`if`
-        // within this one's body). Each nested closure gets registered exactly like a
-        // top-level one, seeing this closure's own params as locals in scope — which
+        // inside it, seeing this closure's own params as locals in scope.
-        // is also what makes its free-variable analysis correctly capture a name from
-        // *this* closure's scope (rather than silently missing it): once discovery
-        // finishes, `ctx.closures` holds every closure at every depth before any body
-        // is compiled, so the single fixed "compile each registered closure" pass in
-        // `compileSource` already handles arbitrary nesting with no further changes.
-        let saved_env = self.env.clone();
         let saved_locals = self.locals.clone();
-        for (p, ty) in cl.params.iter().zip(param_ptypes.iter()) {
+        for p in &cl.params {
-            self.env.insert(p.clone(), TypeScheme::mono(ty.clone()));
             self.locals.insert(p.clone());
         }
         self.walkBlock(&cl.body);
-        self.env = saved_env;
         self.locals = saved_locals;
     }
 }
-fn argExprOf(arg: &ast::Arg) -> &ast::Expr {
-    match arg {
-        ast::Arg::Positional(e) => e,
-        ast::Arg::Keyword { value, .. } => value,
-        ast::Arg::Pair { value, .. } => value,
-    }
-}
-/// Resolves as many of a closure's param types as possible from how they're actually
-/// used in its body — e.g. `|v| x + v` with a captured `Float` `x` resolves `v` to
-/// `Float` from that `Binary` op, or `|v| helper(v)` where `helper`'s declared param
-/// type is concrete resolves `v` to that. A param never used in a way that pins down
-/// a concrete type simply doesn't appear in the returned map (callers fall back to
-/// `Int`, matching the prior default). This is intentionally a shallow, best-effort
-/// scan — not full unification — scoped to fixing the specific `call_indirect`
-/// signature-mismatch gap this exists for, not replacing the checker's inference.
-fn resolveClosureParamTypesFromUsage(
-    cl: &ast::Closure,
-    env: &TypeEnv,
-    cctx: &plum_checker::CheckCtx,
-) -> HashMap<String, PlumType> {
-    let params: std::collections::HashSet<String> = cl.params.iter().cloned().collect();
-    let mut resolved: HashMap<String, PlumType> = HashMap::new();
-    for stmt in &cl.body.stmts {
-        scanStmtForParamTypes(stmt, &params, env, cctx, &mut resolved);
-    }
-    resolved
-}
-fn scanStmtForParamTypes(
-    stmt: &ast::Stmt,
-    params: &std::collections::HashSet<String>,
-    env: &TypeEnv,
-    cctx: &plum_checker::CheckCtx,
-    resolved: &mut HashMap<String, PlumType>,
-) {
-    match stmt {
-        ast::Stmt::Assign(a) => {
-            for v in &a.values {
-                scanExprForParamTypes(v, params, env, cctx, resolved);
-            }
-        }
-        ast::Stmt::Return(Some(e)) | ast::Stmt::Expr(e, ..) => {
-            scanExprForParamTypes(e, params, env, cctx, resolved);
-        }
-        ast::Stmt::Assert(c) => {
-            scanExprForParamTypes(&c.cond, params, env, cctx, resolved);
-        }
-        ast::Stmt::If(i) => {
-            scanExprForParamTypes(&i.condition, params, env, cctx, resolved);
-            for s in &i.body.stmts {
-                scanStmtForParamTypes(s, params, env, cctx, resolved);
-            }
-            for ei in &i.else_ifs {
-                scanExprForParamTypes(&ei.condition, params, env, cctx, resolved);
-                for s in &ei.body.stmts {
-                    scanStmtForParamTypes(s, params, env, cctx, resolved);
-                }
-            }
-            if let Some(e) = &i.else_ {
-                for s in &e.stmts {
-                    scanStmtForParamTypes(s, params, env, cctx, resolved);
-                }
-            }
-        }
-        ast::Stmt::While(w) => {
-            scanExprForParamTypes(&w.condition, params, env, cctx, resolved);
-            for s in &w.body.stmts {
-                scanStmtForParamTypes(s, params, env, cctx, resolved);
-            }
-        }
-        ast::Stmt::For(f) => {
-            scanExprForParamTypes(&f.iter, params, env, cctx, resolved);
-            for s in &f.body.stmts {
-                scanStmtForParamTypes(s, params, env, cctx, resolved);
-            }
-        }
-        _ => {}
-    }
-}
-fn scanExprForParamTypes(
-    expr: &ast::Expr,
-    params: &std::collections::HashSet<String>,
-    env: &TypeEnv,
-    cctx: &plum_checker::CheckCtx,
-    resolved: &mut HashMap<String, PlumType>,
-) {
-    match expr {
-        ast::Expr::Binary(b) => {
-            tryResolveParamFromPair(&b.left, &b.right, params, env, cctx, resolved);
-            scanExprForParamTypes(&b.left, params, env, cctx, resolved);
-            scanExprForParamTypes(&b.right, params, env, cctx, resolved);
-        }
-        ast::Expr::Compare(c) => {
-            tryResolveParamFromPair(&c.left, &c.right, params, env, cctx, resolved);
-            scanExprForParamTypes(&c.left, params, env, cctx, resolved);
-            scanExprForParamTypes(&c.right, params, env, cctx, resolved);
-        }
-        ast::Expr::Bool(b) => {
-            scanExprForParamTypes(&b.left, params, env, cctx, resolved);
-            scanExprForParamTypes(&b.right, params, env, cctx, resolved);
-        }
-        ast::Expr::Not(inner) => scanExprForParamTypes(inner, params, env, cctx, resolved),
-        ast::Expr::Unary(u) => scanExprForParamTypes(&u.operand, params, env, cctx, resolved),
-        ast::Expr::Paren(inner) => scanExprForParamTypes(inner, params, env, cctx, resolved),
-        ast::Expr::Ternary(t) => {
-            scanExprForParamTypes(&t.condition, params, env, cctx, resolved);
-            scanExprForParamTypes(&t.then, params, env, cctx, resolved);
-            scanExprForParamTypes(&t.else_, params, env, cctx, resolved);
-        }
-        ast::Expr::Elvis(e) => {
-            scanExprForParamTypes(&e.left, params, env, cctx, resolved);
-            scanExprForParamTypes(&e.right, params, env, cctx, resolved);
-        }
-        ast::Expr::FnCall(call) => {
-            if let Ok(PlumType::TFun(param_types, _)) = plum_checker::lookup(env, &call.name) {
-                for (arg, expected) in call.args.iter().zip(param_types.iter()) {
-                    let arg_expr = argExprOf(arg);
-                    if let ast::Expr::Var(n) = arg_expr {
-                        if params.contains(n)
-                            && !resolved.contains_key(n)
-                            && !matches!(expected, PlumType::TVar(_))
-                        {
-                            resolved.insert(n.clone(), expected.clone());
-                        }
-                    }
-                }
-            }
-            for arg in &call.args {
-                scanExprForParamTypes(argExprOf(arg), params, env, cctx, resolved);
-            }
-        }
-        ast::Expr::ClassCall(call) => {
-            for fa in &call.fields {
-                scanExprForParamTypes(&fa.value, params, env, cctx, resolved);
-            }
-        }
-        ast::Expr::Attribute(a) => {
-            // `c.field` on a bare, unresolved param implies `c`'s type is whichever
-            // enum declares a variant with that field name — ambiguous if more than
-            // one variant has a field by that name, but resolvable in the common case.
-            if let ast::AttrKind::Field(field_name) = &a.attr {
-                if let ast::Expr::Var(n) = &a.object {
-                    if params.contains(n) && !resolved.contains_key(n) {
-                        let mut matches = cctx.enum_variants.values().filter(|info| {
-                            info.field_names.iter().any(|fname| fname == field_name)
-                        });
-                        if let (Some(info), None) = (matches.next(), matches.next()) {
-                            resolved.insert(n.clone(), PlumType::TNamed(info.enum_name.clone()));
-                        }
-                    }
-                }
-            }
-            scanExprForParamTypes(&a.object, params, env, cctx, resolved);
-            if let ast::AttrKind::Method(call) = &a.attr {
-                for arg in &call.args {
-                    scanExprForParamTypes(argExprOf(arg), params, env, cctx, resolved);
-                }
-            }
-        }
-        _ => {}
-    }
-}
-/// If either side of a `Binary`/`Compare` operand pair is a bare reference to an
-/// unresolved param and the *other* side has a concrete (non-`TVar`) inferred type,
-/// binds the param to that type.
-fn tryResolveParamFromPair(
-    left: &ast::Expr,
-    right: &ast::Expr,
-    params: &std::collections::HashSet<String>,
-    env: &TypeEnv,
-    cctx: &plum_checker::CheckCtx,
-    resolved: &mut HashMap<String, PlumType>,
-) {
-    if let ast::Expr::Var(n) = left {
-        if params.contains(n) && !resolved.contains_key(n) {
-            if let Ok(ty) = plum_checker::inferExpr(right, env, cctx) {
-                if !matches!(ty, PlumType::TVar(_)) {
-                    resolved.insert(n.clone(), ty);
-                }
-            }
-        }
-    }
-    if let ast::Expr::Var(n) = right {
-        if params.contains(n) && !resolved.contains_key(n) {
-            if let Ok(ty) = plum_checker::inferExpr(left, env, cctx) {
-                if !matches!(ty, PlumType::TVar(_)) {
-                    resolved.insert(n.clone(), ty);
-                }
-            }
-        }
-    }
-}
 /// Determines a closure's captured free variables: every `Var` referenced in its body
 /// that is neither one of the closure's own params nor assigned locally inside the body,
 /// in first-appearance order. Each free variable's type is looked up in the *enclosing*
 /// scope's type env.
 fn collectFreeVars(
     cl: &ast::Closure,
-    env: &TypeEnv,
+    env: &HashMap<usize, PlumType>,
     fn_decls: &HashMap<String, &ast::Fn>,
 ) -> Vec<(String, PlumType)> {
     let mut bound: std::collections::HashSet<String> = cl.params.iter().cloned().collect();
@@ -3545,7 +3389,7 @@ fn fvCollectRefsBlock(
     bound: &std::collections::HashSet<String>,
     seen: &mut std::collections::HashSet<String>,
     free: &mut Vec<(String, PlumType)>,
-    env: &TypeEnv,
+    env: &HashMap<usize, PlumType>,
     fn_decls: &HashMap<String, &ast::Fn>,
 ) {
     for s in &block.stmts {
@@ -3606,7 +3450,7 @@ fn fvCollectRefsExpr(
     bound: &std::collections::HashSet<String>,
     seen: &mut std::collections::HashSet<String>,
     free: &mut Vec<(String, PlumType)>,
-    env: &TypeEnv,
+    env: &HashMap<usize, PlumType>,
     fn_decls: &HashMap<String, &ast::Fn>,
 ) {
     match expr {
@@ -3616,10 +3460,22 @@ fn fvCollectRefsExpr(
             // reference (see `named_fn_values`), not loaded from an enclosing local.
             let is_named_fn_ref = fn_decls.get(name).is_some_and(|f| f.type_param.is_none());
             if !is_named_fn_ref && !bound.contains(name) && seen.insert(name.clone()) {
+                let ty = env
+                    .get(&(expr as *const ast::Expr as usize))
+                    .cloned()
-                let ty = plum_checker::lookup(env, name).unwrap_or(PlumType::TInt);
+                    .unwrap_or(PlumType::TInt);
                 free.push((name.clone(), ty));
             }
         }
+        ast::Expr::Self_ => {
+            if !bound.contains("self") && seen.insert("self".to_string()) {
+                let ty = env
+                    .get(&(expr as *const ast::Expr as usize))
+                    .cloned()
+                    .unwrap_or(PlumType::TInt);
+                free.push(("self".to_string(), ty));
+            }
+        }
         ast::Expr::Binary(b) => {
             fvCollectRefsExpr(&b.left, bound, seen, free, env, fn_decls);
             fvCollectRefsExpr(&b.right, bound, seen, free, env, fn_decls);
@@ -3654,9 +3510,19 @@ fn fvCollectRefsExpr(
             for fa in &call.fields {
                 fvCollectRefsExpr(&fa.value, bound, seen, free, env, fn_decls);
             }
+            if let Some(sp) = &call.spread {
+                fvCollectRefsExpr(sp, bound, seen, free, env, fn_decls);
+            }
         }
+        ast::Expr::String(sx) => {
+            for part in &sx.parts {
+                if let ast::StringPart::Interp(e) = part {
+                    fvCollectRefsExpr(e, bound, seen, free, env, fn_decls);
+                }
+            }
+        }
-        ast::Expr::Attribute(a) => {
+        ast::Expr::Attribute(a) => {
-            fvCollectRefsExpr(&a.object, bound, seen, free, env, fn_decls);
+            fvCollectRefsExpr(&a.object, bound, seen, free, env, fn_decls);
             if let ast::AttrKind::Method(call) = &a.attr {
                 for arg in &call.args {
                     fvCollectRefsExpr(argExprOf(arg), bound, seen, free, env, fn_decls);
@@ -3690,8 +3556,9 @@ fn fvCollectRefsExpr(
 /// its inferred type, (2) how many `ClassCall` scratch temporaries it needs, and (3)
 /// the subject type for every `match` statement (for its own scratch temporary).
 struct Collector<'a> {
-    env: TypeEnv,
+    /// The checker's instantiated type of every expression.
-    cctx: plum_checker::CheckCtx<'a>,
+    types: &'a HashMap<usize, PlumType>,
+    enum_variants: &'a EnumVariants,
     named: Vec<(String, PlumType)>,
     named_set: std::collections::HashSet<String>,
     /// One scratch-local type per subject (usually one, more for `match a, b, ...`).
@@ -3723,9 +3590,16 @@ struct Collector<'a> {
 impl<'a> Collector<'a> {
     fn bind(&mut self, name: &str, ty: PlumType) {
         if self.named_set.insert(name.to_string()) {
-            self.named.push((name.to_string(), ty.clone()));
+            self.named.push((name.to_string(), ty));
         }
+    }
+    /// The checker's type of `expr` (`Int` if the node was never recorded).
+    fn ty(&self, expr: &ast::Expr) -> PlumType {
+        self.types
-        self.env.insert(name.to_string(), TypeScheme::mono(ty));
+            .get(&(expr as *const ast::Expr as usize))
+            .cloned()
+            .unwrap_or(PlumType::TInt)
     }
     /// Binds every `Name` sub-pattern anywhere inside `pat` (at any nesting depth) to
@@ -3748,7 +3622,7 @@ impl<'a> Collector<'a> {
         match pat {
             ast::CasePattern::Name(n) => {
                 let is_variant = n.chars().next().map(|c| c.is_uppercase()).unwrap_or(false)
-                    && self.cctx.enum_variants.contains_key(n);
+                    && self.enum_variants.contains_key(n);
                 if !is_variant {
                     self.bind(n, ty.clone());
                 }
@@ -3759,8 +3633,10 @@ impl<'a> Collector<'a> {
                 self.next_nested_class_slot += 1;
                 self.nested_class_scratch.insert(key, slot);
                 self.nested_class_scratch_types.push(name.clone());
-                if let Some(info) = self.cctx.enum_variants.get(name) {
+                if let Some(info) = self.enum_variants.get(name) {
+                    // The payload types as instantiated by the matched value's type
+                    // arguments (`Ok(v)` against `Try[Int, E]` binds `v: Int`).
-                    let field_types = info.field_types.clone();
+                    let field_types = instFields(info, ty);
                     for (f, fty) in fields.iter().zip(field_types.iter()) {
                         self.collectPattern(f, fty);
                     }
@@ -3783,23 +3659,7 @@ impl<'a> Collector<'a> {
                     self.walkExpr(value);
                     match target {
                         ast::AssignTarget::Var(name) => {
-                            let ty = if matches!(value, ast::Expr::Closure(_)) {
+                            let ty = self.ty(value);
-                                // The checker's own closure inference (`inferExpr` on
-                                // `Expr::Closure`) infers the return type by recursively
-                                // inferring the body's tail expression with each param bound
-                                // to a fresh, unconstrained `TVar` — e.g. a captured/param
-                                // attribute access (`c.age`) on a `TVar`-typed object isn't a
-                                // known class, so it errors out entirely, and this call site
-                                // then silently defaults to `TInt` — the *wrong* wasm local
-                                // width for what's actually always an `i32` pointer. All that
-                                // actually matters here is the local's wasm width, and every
-                                // closure value is an i32 pointer regardless of its
-                                // parameter/return types, so skip inference entirely.
-                                PlumType::TFun(Vec::new(), Box::new(PlumType::TUnit))
-                            } else {
-                                plum_checker::inferExpr(value, &self.env, &self.cctx)
-                                    .unwrap_or(PlumType::TInt)
-                            };
                             self.bind(name, ty);
                         }
                         ast::AssignTarget::Field(object, _) => {
@@ -3827,8 +3687,7 @@ impl<'a> Collector<'a> {
             }
             ast::Stmt::For(f) => {
                 self.walkExpr(&f.iter);
-                let iter_ty = plum_checker::inferExpr(&f.iter, &self.env, &self.cctx)
+                let iter_ty = self.ty(&f.iter);
-                    .unwrap_or(PlumType::TInt);
                 if let PlumType::TVariadic(elem) = &iter_ty {
                     let idx = self.next_variadic_for_slot;
                     self.next_variadic_for_slot += 1;
@@ -3852,13 +3711,12 @@ impl<'a> Collector<'a> {
                     .iter()
                     .map(|s| {
                         self.walkExpr(s);
-                        plum_checker::inferExpr(s, &self.env, &self.cctx).unwrap_or(PlumType::TInt)
+                        self.ty(s)
                     })
                     .collect();
                 self.match_scratch
                     .insert(m as *const ast::Match as usize, subject_types.clone());
                 for case in &m.cases {
-                    let saved = self.env.clone();
                     for (pat, subject_ty) in case.patterns.iter().zip(subject_types.iter()) {
                         self.collectPattern(pat, subject_ty);
                     }
@@ -3866,7 +3724,6 @@ impl<'a> Collector<'a> {
                         self.walkExpr(g);
                     }
                     self.walkBlock(&case.body);
-                    self.env = saved;
                 }
             }
             ast::Stmt::Break | ast::Stmt::Continue | ast::Stmt::Todo => {}
@@ -3906,12 +3763,8 @@ impl<'a> Collector<'a> {
             // in each branch, not by declaring this local pre-narrowed.
             ast::Expr::Try(inner) => {
                 let key = expr as *const ast::Expr as usize;
+                let ty = self.ty(inner);
-                let ty = plum_checker::inferExpr(inner, &self.env, &self.cctx)
+                let name = plum_checker::nominalName(&ty).unwrap_or("").to_string();
-                    .unwrap_or(PlumType::TVar("_".to_string()));
-                let name = match &ty {
-                    PlumType::TNamed(n) => n.clone(),
-                    _ => String::new(),
-                };
                 let slot = self.next_nested_class_slot;
                 self.next_nested_class_slot += 1;
                 self.nested_class_scratch.insert(key, slot);
@@ -3931,12 +3784,8 @@ impl<'a> Collector<'a> {
             // `return`.
             ast::Expr::Elvis(e) => {
                 let key = expr as *const ast::Expr as usize;
+                let ty = self.ty(&e.left);
-                let ty = plum_checker::inferExpr(&e.left, &self.env, &self.cctx)
+                let name = plum_checker::nominalName(&ty).unwrap_or("").to_string();
-                    .unwrap_or(PlumType::TVar("_".to_string()));
-                let name = match &ty {
-                    PlumType::TNamed(n) => n.clone(),
-                    _ => String::new(),
-                };
                 let slot = self.next_nested_class_slot;
                 self.next_nested_class_slot += 1;
                 self.nested_class_scratch.insert(key, slot);
@@ -3994,39 +3843,24 @@ fn compileFnBody(
 ) -> Result<Vec<u8>, String> {
     let mut body = Vec::new();
+    // Fallback type env (only consulted for synthesized nodes the checker never
+    // saw): globals, `self`, and the params under their DECLARED (generic) types.
     let mut base_env = ctx.global_env.clone();
+    let mut decl_types: HashMap<String, PlumType> = HashMap::new();
     if let Some(recv) = &f.type_param {
-        base_env.insert(
-            "self".to_string(),
-            TypeScheme::mono(plum_checker::plumTypeFromName(recv)),
+        let self_ty = plum_checker::plumTypeFromName(recv);
+        base_env.insert("self".to_string(), TypeScheme::mono(self_ty.clone()));
-        );
+        decl_types.insert("self".to_string(), self_ty);
     }
     for p in &f.params {
-        let ty = match &p.ty {
+        let ty = paramPlumType(&p.ty);
-            ast::ParamType::Type(t) => plum_checker::plumTypeFromAst(t),
-            ast::ParamType::Variadic(t) => {
-                PlumType::TVariadic(Box::new(plum_checker::plumTypeFromAst(t)))
-            }
-            ast::ParamType::Fn(params, ret) => {
-                let param_types = params.iter().map(plum_checker::plumTypeFromAst).collect();
-                let ret_ty = ret
-                    .as_ref()
-                    .map(|r| plum_checker::plumTypeFromAst(r))
-                    .unwrap_or(PlumType::TUnit);
-                PlumType::TFun(param_types, Box::new(ret_ty))
-            }
-        };
-        base_env.insert(p.name.clone(), TypeScheme::mono(ty));
+        base_env.insert(p.name.clone(), TypeScheme::mono(ty.clone()));
+        decl_types.insert(p.name.clone(), ty);
     }
     let mut collector = Collector {
-        env: base_env.clone(),
-        cctx: checkCtxOf(
-            &ctx.methods,
+        types: &ctx.types,
-            &ctx.enum_variants,
+        enum_variants: &ctx.enum_variants,
-            &ctx.enum_params,
-            &ctx.min_required,
-        ),
         named: Vec::new(),
         named_set: Default::default(),
         match_scratch: HashMap::new(),
@@ -4043,6 +3877,9 @@ fn compileFnBody(
         // `main() -> Int = each(|v| v)`), which needs construction scratch slots.
         collector.walkExpr(e);
     }
+    for (name, ty) in &collector.named {
+        decl_types.entry(name.clone()).or_insert_with(|| ty.clone());
+    }
     // ---- assign local indices: [self?][params][named...][classcall scratch...][match scratch...] ----
     let mut locals: HashMap<String, u32> = HashMap::new();
     let mut groups: Vec<ValType> = Vec::new();
@@ -4118,11 +3955,14 @@ fn compileFnBody(
         variadic_for_scratch: collector.variadic_for_scratch,
         func_ids: &ctx.func_ids,
         func_sigs: &ctx.func_sigs,
+        types: &ctx.types,
+        local_decl_types: decl_types,
         closures: &ctx.closures,
         closure_call_types: &ctx.closure_call_types,
         named_fn_values: &ctx.named_fn_values,
         string_concat_func: ctx.string_concat_func,
         string_eq_func: ctx.string_eq_func,
+        dyn_eq_func: ctx.dyn_eq_func,
         int_to_string_func: ctx.int_to_string_func,
         methods: &ctx.methods,
         enum_variants: &ctx.enum_variants,
@@ -4131,10 +3971,11 @@ fn compileFnBody(
         gc_types: &ctx.gc_types,
         singleton_globals: &ctx.singleton_globals,
         type_env: RefCell::new(base_env),
-        closure_local_sigs: RefCell::new(HashMap::new()),
         loop_extra_depth: Cell::new(0),
+        in_closure: false,
-        ret_type: f.returns.as_ref().map(|r| plum_checker::plumTypeFromAst(r)),
+        ret_type: f.returns.as_ref().map(plum_checker::plumTypeFromAstG),
         match_subject_types: RefCell::new(HashMap::new()),
+        subject_ptypes: RefCell::new(HashMap::new()),
     };
     let result_vt = retTypeToWasm(f.returns.as_ref());
@@ -4382,47 +4223,36 @@ fn compileStmt(
             for (target, value) in a.targets.iter().zip(a.values.iter()) {
                 match target {
                     ast::AssignTarget::Var(name) => {
-                        // See the matching comment in `Collector::walkStmt`: the checker's
-                        // closure inference is unreliable (can error out entirely depending
-                        // on the body), but every closure value is an i32 pointer regardless
-                        // of its real signature, so don't bother inferring it at all here.
-                        let vty = if matches!(value, ast::Expr::Closure(_)) {
-                            PlumType::TFun(Vec::new(), Box::new(PlumType::TUnit))
-                        } else {
-                            inferLocalType(value, ctx)
+                        let vty = inferLocalType(value, ctx);
-                        };
                         compileExpr(value, body, ctx, state)?;
                         let idx = ctx
                             .locals
                             .get(name)
                             .copied()
                             .ok_or_else(|| format!("undeclared local '{}'", name))?;
+                        // Convert to the representation the local was declared with
+                        // (differs only across an erased/instantiated edge).
+                        if let Some(decl) = ctx.local_decl_types.get(name) {
+                            coerceVt(
+                                plumTypeToValtype(&vty),
+                                plumTypeToValtype(decl),
+                                body,
+                                ctx.gc_types,
+                            );
+                        }
                         Instruction::LocalSet(idx).encode(body);
                         ctx.type_env
                             .borrow_mut()
                             .insert(name.clone(), TypeScheme::mono(vty));
-                        // If this assigns a closure *literal*, remember its exact, already-
-                        // correct signature (computed by the discovery pass) so a later call
-                        // to it doesn't have to re-derive one — see `closure_local_sigs`.
-                        if let ast::Expr::Closure(cl) = value {
-                            let key = cl.as_ref() as *const ast::Closure as usize;
-                            if let Some(info) = ctx.closures.get(&key) {
-                                let mut sig_params = vec![ValType::Ref(RefType::ANYREF)];
-                                sig_params.extend(info.param_vts.iter().copied());
-                                ctx.closure_local_sigs
-                                    .borrow_mut()
-                                    .insert(name.clone(), (sig_params, info.ret_vt));
-                            }
-                        }
                     }
                     ast::AssignTarget::Field(object, field_name) => {
                         let obj_ty = inferLocalType(object, ctx);
-                        let class_name = match &obj_ty {
+                        let class_name = match plum_checker::nominalName(&obj_ty) {
-                            PlumType::TNamed(n) => n.clone(),
+                            Some(n) => n.to_string(),
-                            other => {
+                            None => {
                                 return Err(format!(
                                     "codegen: cannot assign field '{}' on non-class type {}",
-                                    field_name, other
+                                    field_name, obj_ty
                                 ))
                             }
                         };
@@ -4456,7 +4286,7 @@ fn compileStmt(
                                         )
                                     })?;
                                 compileExpr(object, body, ctx, state)?;
-                                compileExpr(value, body, ctx, state)?;
+                                compileExprInto(value, &params[field_idx].1, body, ctx, state)?;
                                 Instruction::StructSet {
                                     struct_type_index: super_type_idx,
                                     field_index: fld(field_idx),
@@ -4487,7 +4317,7 @@ fn compileStmt(
                                 compileExpr(object, body, ctx, state)?;
                                 Instruction::RefCastNonNull(HeapType::Concrete(variant_type_idx))
                                     .encode(body);
-                                compileExpr(value, body, ctx, state)?;
+                                compileExprInto(value, &info.field_types[field_idx], body, ctx, state)?;
                                 Instruction::StructSet {
                                     struct_type_index: variant_type_idx,
                                     field_index: fld(field_idx),
@@ -4500,10 +4330,23 @@ fn compileStmt(
             }
         }
         ast::Stmt::Return(Some(e)) => {
+            match &ctx.ret_type {
+                Some(rt) => compileExprInto(e, rt, body, ctx, state)?,
+                None => compileExpr(e, body, ctx, state)?,
+            }
+            if ctx.in_closure {
+                // Closure ABI: the result leaves as an `anyref`.
-            compileExprAs(e, ctx.ret_type.as_ref().map(plumTypeToValtype), body, ctx, state)?;
+                let rt_vt = ctx.ret_type.as_ref().map(plumTypeToValtype);
+                if let Some(vt) = rt_vt {
+                    coerceVt(vt, ValType::Ref(RefType::ANYREF), body, ctx.gc_types);
+                }
+            }
             Instruction::Return.encode(body);
         }
         ast::Stmt::Return(None) => {
+            if ctx.in_closure {
+                Instruction::RefNull(HeapType::ANY).encode(body);
+            }
             Instruction::Return.encode(body);
         }
         ast::Stmt::If(if_) => {
@@ -4681,12 +4524,13 @@ fn compileStmt(
 fn exprHasResult(expr: &ast::Expr, ctx: &LocalCtx) -> bool {
     match expr {
         ast::Expr::FnCall(call) => {
-            if ctx.locals.contains_key(&call.name) {
+            if ctx.locals.contains_key(&call.name)
+                && matches!(
+                    ctx.local_decl_types.get(&call.name),
-                if let PlumType::TFun(_, ret) =
+                    Some(PlumType::TFun(_, _))
-                    inferLocalType(&ast::Expr::Var(call.name.clone()), ctx)
+                )
-                {
+            {
-                    return !matches!(*ret, PlumType::TUnit);
+                return !closureCallReturnsUnit(&call.name, ctx);
-                }
             }
             ctx.func_sigs
                 .get(&call.name)
@@ -4695,17 +4539,38 @@ fn exprHasResult(expr: &ast::Expr, ctx: &LocalCtx) -> bool {
         }
         ast::Expr::Attribute(attr) => match &attr.attr {
             ast::AttrKind::Method(call) => {
+                let obj_ty = inferLocalType(&attr.object, ctx);
+                // A call on an erased or trait-typed receiver dispatches through a
+                // trait method whose declared return type decides.
+                let trait_owner = match &obj_ty {
+                    PlumType::TParam(_) => dynOwnerForMethod(&call.name, call.args.len(), ctx),
+                    t => plum_checker::nominalName(t)
+                        .filter(|n| {
+                            ctx.gc_types.class_type_idx.get(*n)
+                                == Some(&ctx.gc_types.obj_type_idx)
+                        })
+                        .map(|n| {
+                            if ctx.methods.contains_key(&(n.to_string(), call.name.clone())) {
+                                n.to_string()
+                            } else {
+                                dynOwnerForMethod(&call.name, call.args.len(), ctx)
+                                    .unwrap_or_else(|| n.to_string())
+                            }
+                        }),
+                };
+                if let Some(owner) = trait_owner {
+                    return match ctx.methods.get(&(owner, call.name.clone())) {
+                        Some(PlumType::TFun(_, ret)) => !matches!(**ret, PlumType::TUnit),
+                        _ => true,
+                    };
+                }
                 // `methodReceiverName` (not a bare `TNamed` match) so this also
                 // covers a Unit-returning method called in statement position on
                 // a BUILTIN primitive receiver (`Int`/`Float`/`Bool`/`Str`/`Byte`/
                 // `[]Byte`) — e.g. `self.data.set(...)` on a `[]Byte` field — not
-                // just an ordinary class. Without this, such a call was wrongly
-                // assumed to leave a value on the stack, emitting a `Drop` with
-                // nothing to drop.
+                // just an ordinary class.
-                if let Some(class_name) =
-                    plum_checker::methodReceiverName(&inferLocalType(&attr.object, ctx))
+                if let Some(class_name) = plum_checker::methodReceiverName(&obj_ty) {
-                {
-                    let key = format!("{}::{}", class_name, call.name);
+                    let (_, key, _) = resolveMethodKey(&class_name, &call.name, ctx);
                     ctx.func_sigs
                         .get(&key)
                         .map(|s| s.ret.is_some())
@@ -4902,6 +4767,9 @@ fn compileMatch(
         let subject_ty = inferLocalType(subject, ctx);
         let subject_vt = plumTypeToValtype(&subject_ty);
         let scratch_local = ctx.match_scratch_base + base_slot + i as u32;
+        ctx.subject_ptypes
+            .borrow_mut()
+            .insert(scratch_local, subject_ty.clone());
         if matches!(subject_ty, PlumType::TTags(_)) {
             ctx.match_subject_types
                 .borrow_mut()
@@ -5297,6 +5165,11 @@ fn compileVariantConstructorArm(
         )
     })?;
     let field_types = info.field_types.clone();
+    // Payload types instantiated by the subject's type arguments.
+    let inst_types = match ctx.subject_ptypes.borrow().get(&scratch_local) {
+        Some(sty) => instFields(info, sty),
+        None => field_types.clone(),
+    };
     // This pattern's own narrowly-typed scratch local (declared with variant's exact
     // concrete ref type — see `nested_class_scratch_types`), distinct from
@@ -5323,6 +5196,7 @@ fn compileVariantConstructorArm(
     compileFieldPatterns(
         fields,
         &field_types,
+        &inst_types,
         0,
         narrow_local,
         variant_idx,
@@ -5372,6 +5246,7 @@ fn compileVariantConstructorArm(
 fn compileFieldPatterns(
     fields: &[ast::CasePattern],
     field_types: &[PlumType],
+    inst_types: &[PlumType],
     fpos: usize,
     container_local: u32,
     container_type_idx: u32,
@@ -5388,7 +5263,12 @@ fn compileFieldPatterns(
         return on_match(body, state);
     }
     let pat = &fields[fpos];
+    // The field's DECLARED type fixes its stored representation (an erased `T` slot
+    // is a `ref null $Obj`); its INSTANTIATED type is what a binding/pattern sees.
-    let field_ty = &field_types[fpos];
+    let decl_ty = &field_types[fpos];
+    let field_ty = &inst_types[fpos];
+    let decl_vt = plumTypeToValtype(decl_ty);
+    let inst_vt = plumTypeToValtype(field_ty);
     if let PlumType::TTags(tags) = field_ty {
         if isTagPattern(pat) {
@@ -5402,6 +5282,7 @@ fn compileFieldPatterns(
                         field_index: fld(fpos),
                     }
                     .encode(b);
+                    coerceVt(decl_vt, inst_vt, b, ctx.gc_types);
                 },
                 result_vt,
                 body,
@@ -5411,6 +5292,7 @@ fn compileFieldPatterns(
                     compileFieldPatterns(
                         fields,
                         field_types,
+                        inst_types,
                         fpos + 1,
                         container_local,
                         container_type_idx,
@@ -5443,6 +5325,7 @@ fn compileFieldPatterns(
         ast::CasePattern::Wildcard => compileFieldPatterns(
             fields,
             field_types,
+            inst_types,
             fpos + 1,
             container_local,
             container_type_idx,
@@ -5471,6 +5354,7 @@ fn compileFieldPatterns(
                 field_index: fld(fpos),
             }
             .encode(body);
+            coerceVt(decl_vt, inst_vt, body, ctx.gc_types);
             Instruction::LocalSet(idx).encode(body);
             ctx.type_env
                 .borrow_mut()
@@ -5478,6 +5362,7 @@ fn compileFieldPatterns(
             compileFieldPatterns(
                 fields,
                 field_types,
+                inst_types,
                 fpos + 1,
                 container_local,
                 container_type_idx,
@@ -5497,7 +5382,7 @@ fn compileFieldPatterns(
             ctx.enum_variants
                 .get(n)
                 .ok_or_else(|| format!("codegen: unknown enum variant '{}'", n))?;
-            if !matches!(plumTypeToValtype(field_ty), ValType::Ref(_)) {
+            if !matches!(decl_vt, ValType::Ref(_)) {
                 return Err(format!(
                     "codegen: enum tag pattern '{}' against a non-enum field",
                     n
@@ -5517,6 +5402,7 @@ fn compileFieldPatterns(
             compileFieldPatterns(
                 fields,
                 field_types,
+                inst_types,
                 fpos + 1,
                 container_local,
                 container_type_idx,
@@ -5543,7 +5429,7 @@ fn compileFieldPatterns(
             Ok(())
         }
         ast::CasePattern::Int(n) => {
-            if plumTypeToValtype(field_ty) != ValType::I64 {
+            if inst_vt != ValType::I64 {
                 return Err("codegen: integer match pattern against a non-Int field".to_string());
             }
             Instruction::LocalGet(container_local).encode(body);
@@ -5552,12 +5438,14 @@ fn compileFieldPatterns(
                 field_index: fld(fpos),
             }
             .encode(body);
+            coerceVt(decl_vt, inst_vt, body, ctx.gc_types);
             Instruction::I64Const(*n).encode(body);
             Instruction::I64Eq.encode(body);
             Instruction::If(blockTypeFor(result_vt)).encode(body);
             compileFieldPatterns(
                 fields,
                 field_types,
+                inst_types,
                 fpos + 1,
                 container_local,
                 container_type_idx,
@@ -5597,7 +5485,7 @@ fn compileFieldPatterns(
                 .enum_variants
                 .get(name)
                 .ok_or_else(|| format!("codegen: unknown enum variant '{}'", name))?;
-            if !matches!(plumTypeToValtype(field_ty), ValType::Ref(_)) {
+            if !matches!(decl_vt, ValType::Ref(_)) {
                 return Err(format!(
                     "codegen: constructor pattern '{}' against a non-enum field",
                     name
@@ -5624,6 +5512,7 @@ fn compileFieldPatterns(
             })?;
             let nested_local = ctx.nested_class_scratch_base + slot;
             let inner_field_types = info.field_types.clone();
+            let inner_inst_types = instFields(info, field_ty);
             Instruction::LocalGet(container_local).encode(body);
             Instruction::StructGet {
@@ -5645,6 +5534,7 @@ fn compileFieldPatterns(
             compileFieldPatterns(
                 inner_fields,
                 &inner_field_types,
+                &inner_inst_types,
                 0,
                 nested_local,
                 inner_variant_idx,
@@ -5659,6 +5549,7 @@ fn compileFieldPatterns(
                     compileFieldPatterns(
                         fields,
                         field_types,
+                        inst_types,
                         fpos + 1,
                         container_local,
                         container_type_idx,
@@ -5712,7 +5603,16 @@ fn compileExpr(
         }
         ast::Expr::Var(name) => {
             match ctx.locals.get(name.as_str()) {
+                Some(idx) => {
-                Some(idx) => Instruction::LocalGet(*idx).encode(body),
+                    Instruction::LocalGet(*idx).encode(body);
+                    // The local holds its DECLARED representation; this use site's
+                    // type may differ across an erased edge (a generic `T` slot read
+                    // at its instantiated type).
+                    if let Some(decl) = ctx.local_decl_types.get(name.as_str()) {
+                        let want = plumTypeToValtype(&inferLocalType(expr, ctx));
+                        coerceVt(plumTypeToValtype(decl), want, body, ctx.gc_types);
+                    }
+                }
                 // Not a local: a bare reference to a top-level function used as a
                 // value (e.g. `each(double)`) — push its zero-capture trampoline
                 // closure's (pre-built by the `start` function) global.
@@ -5739,12 +5639,12 @@ fn compileExpr(
         // inside an expression here for the first time.
         ast::Expr::Try(inner) => {
             let inner_ty = inferLocalType(inner, ctx);
-            let enum_name = match &inner_ty {
+            let enum_name = match plum_checker::nominalName(&inner_ty) {
-                PlumType::TNamed(n) => n.clone(),
+                Some(n) => n.to_string(),
-                other => {
+                None => {
                     return Err(format!(
                         "codegen: '?' requires a Try value, found {}",
-                        other
+                        inner_ty
                     ))
                 }
             };
@@ -5781,13 +5681,16 @@ fn compileExpr(
                             failure_name
                         )
                     })?;
+            // The payload slot is declared at its generic type (`T` -> `$Obj`); the
+            // value this expression yields is at its instantiated type.
-            let success_vt = plumTypeToValtype(
+            let raw_success_vt = plumTypeToValtype(
                 &success_info
                     .field_types
                     .first()
                     .cloned()
                     .unwrap_or(PlumType::TUnit),
             );
+            let success_vt = plumTypeToValtype(&inferLocalType(expr, ctx));
             let key = expr as *const ast::Expr as usize;
             let slot = *ctx
@@ -5802,8 +5705,8 @@ fn compileExpr(
             Instruction::If(BlockType::Result(success_vt)).encode(body);
             // Failure branch: take the inner `Err` payload and build the OUTER
             // function's `Err` variant from it (the Ok types may differ).
-            let outer_err = match &ctx.ret_type {
+            let outer_err = match ctx.ret_type.as_ref().and_then(plum_checker::nominalName) {
-                Some(PlumType::TNamed(outer_enum)) if *outer_enum != enum_name => {
+                Some(outer_enum) if outer_enum != enum_name => {
                     plum_checker::tryOperatorVariants(outer_enum, &cctx)
                         .map(|(_, _, fname, _)| fname)
                 }
@@ -5848,6 +5751,7 @@ fn compileExpr(
                     field_index: fld(0),
                 }
                 .encode(body);
+                coerceVt(raw_success_vt, success_vt, body, ctx.gc_types);
             }
             Instruction::End.encode(body);
         }
@@ -5858,12 +5762,12 @@ fn compileExpr(
         // the field, same as `Try`'s own success branch.
         ast::Expr::Elvis(e) => {
             let left_ty = inferLocalType(&e.left, ctx);
-            let enum_name = match &left_ty {
+            let enum_name = match plum_checker::nominalName(&left_ty) {
-                PlumType::TNamed(n) => n.clone(),
+                Some(n) => n.to_string(),
-                other => {
+                None => {
                     return Err(format!(
                         "codegen: '??' requires a Try value, found {}",
-                        other
+                        left_ty
                     ))
                 }
             };
@@ -5900,13 +5804,14 @@ fn compileExpr(
                             failure_name
                         )
                     })?;
-            let success_vt = plumTypeToValtype(
+            let raw_success_vt = plumTypeToValtype(
                 &success_info
                     .field_types
                     .first()
                     .cloned()
                     .unwrap_or(PlumType::TUnit),
             );
+            let success_vt = plumTypeToValtype(&inferLocalType(expr, ctx));
             let key = expr as *const ast::Expr as usize;
             let slot = *ctx
@@ -5919,7 +5824,7 @@ fn compileExpr(
             Instruction::LocalTee(scratch_local).encode(body);
             Instruction::RefTestNonNull(HeapType::Concrete(failure_idx)).encode(body);
             Instruction::If(BlockType::Result(success_vt)).encode(body);
-            compileExpr(&e.right, body, ctx, state)?;
+            compileExprAs(&e.right, Some(success_vt), body, ctx, state)?;
             Instruction::Else.encode(body);
             Instruction::LocalGet(scratch_local).encode(body);
             Instruction::RefCastNonNull(HeapType::Concrete(success_idx)).encode(body);
@@ -5929,6 +5834,7 @@ fn compileExpr(
                     field_index: fld(0),
                 }
                 .encode(body);
+                coerceVt(raw_success_vt, success_vt, body, ctx.gc_types);
             }
             Instruction::End.encode(body);
         }
@@ -6030,6 +5936,23 @@ fn compileExpr(
             compileExpr(&c.left, body, ctx, state)?;
             compileExpr(&c.right, body, ctx, state)?;
             match left_ty {
+                // Two erased values (`T == T` inside a generic body): the runtime
+                // helper compares boxed primitives and `Str`s by value.
+                PlumType::TParam(_) => match &c.op {
+                    ast::CmpOp::Eq => {
+                        Instruction::Call(ctx.dyn_eq_func).encode(body);
+                    }
+                    ast::CmpOp::Neq | ast::CmpOp::NotEq2 => {
+                        Instruction::Call(ctx.dyn_eq_func).encode(body);
+                        Instruction::I32Eqz.encode(body);
+                    }
+                    other => {
+                        return Err(format!(
+                            "codegen: '{:?}' is not supported between generic values",
+                            other
+                        ))
+                    }
+                },
                 PlumType::TFloat => {
                     match c.op {
                         ast::CmpOp::Lt => Instruction::F64Lt,
@@ -6095,12 +6018,12 @@ fn compileExpr(
             pushBoolRefFromI32Flag(body, ctx);
         }
         ast::Expr::Ternary(t) => {
-            let result_vt = plumTypeToValtype(&inferLocalType(&t.then, ctx));
+            let result_vt = plumTypeToValtype(&inferLocalType(expr, ctx));
             compileBoolConditionAsI32(&t.condition, body, ctx, state)?;
             Instruction::If(BlockType::Result(result_vt)).encode(body);
-            compileExpr(&t.then, body, ctx, state)?;
+            compileExprAs(&t.then, Some(result_vt), body, ctx, state)?;
             Instruction::Else.encode(body);
-            compileExpr(&t.else_, body, ctx, state)?;
+            compileExprAs(&t.else_, Some(result_vt), body, ctx, state)?;
             Instruction::End.encode(body);
         }
         ast::Expr::FnCall(call) => {
@@ -6108,8 +6031,8 @@ fn compileExpr(
             // dispatched via `call_indirect` — not a direct `Call` to a named function.
             let is_closure_call = ctx.locals.contains_key(&call.name)
                 && matches!(
-                    inferLocalType(&ast::Expr::Var(call.name.clone()), ctx),
+                    ctx.local_decl_types.get(&call.name),
-                    PlumType::TFun(_, _)
+                    Some(PlumType::TFun(_, _))
                 );
             // `Int(x)`/`Float(x)`/`Byte(x)` is the primitive numeric CAST
             // special case just below UNLESS `call.name` is ALSO a
@@ -6125,12 +6048,7 @@ fn compileExpr(
             // numeric-cast call site in the stdlib (`Float(self)`,
             // `Int(y)`, ...) keeps working unchanged.
             let single_arg_ty = if call.args.len() == 1 {
-                let arg_expr = match &call.args[0] {
-                    ast::Arg::Positional(e) => e,
-                    ast::Arg::Keyword { value, .. } => value,
-                    ast::Arg::Pair { value, .. } => value,
-                };
-                Some(inferLocalType(arg_expr, ctx))
+                Some(inferLocalType(argExprOf(&call.args[0]), ctx))
             } else {
                 None
             };
@@ -6144,11 +6062,7 @@ fn compileExpr(
                 && !is_same_type_variant_wrap
                 && single_arg_ty.is_some()
             {
-                let arg_expr = match &call.args[0] {
+                let arg_expr = argExprOf(&call.args[0]);
-                    ast::Arg::Positional(e) => e,
-                    ast::Arg::Keyword { value, .. } => value,
-                    ast::Arg::Pair { value, .. } => value,
-                };
                 let arg_ty = single_arg_ty.expect("just checked is_some");
                 compileExpr(arg_expr, body, ctx, state)?;
                 match (call.name.as_str(), &arg_ty) {
@@ -6167,32 +6081,9 @@ fn compileExpr(
                     _ => {}
                 }
             } else if is_closure_call {
-                compileClosureCall(call, body, ctx, state)?;
+                compileClosureCall(call, expr, body, ctx, state)?;
-            // `Type(1, 2, 3)` — mirrors `plum-checker`'s own `inferExpr` handling of
-            // the same case: sugar for `Type.init(1, 2, 3)`, desugared to that
+            // `Bad(x)` / `Bad()` — an uppercase name the checker typed as a tag
-            // equivalent static method-call expression so the existing
-            // `AttrKind::Method` codegen (below) handles it without duplication.
-            // Checked BEFORE the ordinary positional-variant-construction case just
-            // below — see the matching comment in `plum-checker`'s `inferExpr` for
-            // why a record-shaped enum's own name needs this precedence.
+            // union is a tag literal, even when a declared variant shares its name.
-            } else if ctx
-                .enum_variants
-                .get(&call.name)
-                .is_some_and(|info| info.enum_name == call.name)
-                && ctx
-                    .methods
-                    .contains_key(&(call.name.clone(), "init".to_string()))
-            {
-                let synthetic = ast::Expr::Attribute(Box::new(ast::AttributeExpr {
-                    object: ast::Expr::TypeName(call.name.clone()),
-                    attr: ast::AttrKind::Method(ast::FnCall {
-                        name: "init".to_string(),
-                        args: call.args.clone(),
-                    }),
-                }));
-                compileExpr(&synthetic, body, ctx, state)?;
-            } else if let Some(info) = ctx.enum_variants.get(&call.name) {
-                compileVariantConstruction(info, call, expr, body, ctx, state)?;
             } else if !ctx.func_ids.contains_key(&call.name)
                 && call.args.len() <= 1
                 && call
@@ -6202,12 +6093,7 @@ fn compileExpr(
                     .is_some_and(|c| c.is_uppercase() || c == plum_checker::TAG_MARKER)
                 && matches!(inferLocalType(expr, ctx), PlumType::TTags(_))
             {
-                // `Bad(x)` / `Bad()` — an undeclared uppercase name is a tag literal.
-                let payload = call.args.first().map(|a| match a {
+                let payload = call.args.first().map(argExprOf);
-                    ast::Arg::Positional(e) => e,
-                    ast::Arg::Keyword { value, .. } => value,
-                    ast::Arg::Pair { value, .. } => value,
-                });
                 compileTagLiteral(
                     plum_checker::tagLiteralName(&call.name),
                     payload,
@@ -6215,69 +6101,49 @@ fn compileExpr(
                     ctx,
                     state,
                 )?;
+            // `Type(1, 2, 3)` — mirrors `plum-checker`'s own `inferExpr` handling of
+            // the same case: sugar for `Type.init(1, 2, 3)`, compiled as that
+            // equivalent static method call (so the existing method-call codegen
+            // handles it without duplication). Checked BEFORE the ordinary
+            // positional-variant-construction case just below — see the matching
+            // comment in `plum-checker`'s `inferExpr` for why a record-shaped
+            // enum's own name needs this precedence.
-            } else {
+            } else if ctx
+                .enum_variants
+                .get(&call.name)
-                fn argExprOf(arg: &ast::Arg) -> &ast::Expr {
+                .is_some_and(|info| info.enum_name == call.name)
-                    match arg {
+                && ctx
-                        ast::Arg::Positional(e) => e,
+                    .methods
-                        ast::Arg::Keyword { value, .. } => value,
+                    .contains_key(&(call.name.clone(), "init".to_string()))
-                        ast::Arg::Pair { value, .. } => value,
-                    }
+            {
-                }
-                let callee_sig = inferLocalType(&ast::Expr::Var(call.name.clone()), ctx);
+                let object = ast::Expr::TypeName(call.name.clone());
-                let variadic_split = match &callee_sig {
+                let init_call = ast::FnCall {
-                    PlumType::TFun(params, _) => match params.last() {
-                        Some(PlumType::TVariadic(elem)) => {
-                            Some(((**elem).clone(), params.len() - 1))
+                    name: "init".to_string(),
-                        }
-                        _ => None,
+                    args: call.args.clone(),
-                    },
-                    _ => None,
                 };
+                compileMethodCall(
+                    &object,
+                    &init_call,
-                let sig_params: Vec<ValType> = ctx
+                    &PlumType::TNamed(call.name.clone()),
+                    expr,
+                    body,
+                    ctx,
+                    state,
+                )?;
+            } else if let Some(info) = ctx.enum_variants.get(&call.name) {
+                compileVariantConstruction(info, call, expr, body, ctx, state)?;
+            } else {
+                let sig = ctx
                     .func_sigs
                     .get(&call.name)
-                    .map(|s| s.params.clone())
-                    .unwrap_or_default();
-                match variadic_split {
-                    Some((elem_ty, fixed_count)) => {
-                        for (i, arg) in call.args.iter().take(fixed_count).enumerate() {
+                    .ok_or_else(|| format!("unknown function '{}'", call.name))?;
-                            compileExprAs(argExprOf(arg), sig_params.get(i).copied(), body, ctx, state)?;
+                compileCallArgs(&call.name, &call.args, sig, body, ctx, state)?;
-                        }
-                        let trailing: Vec<&ast::Expr> =
-                            call.args.iter().skip(fixed_count).map(argExprOf).collect();
-                        let elem_vt = plumTypeToValtype(&elem_ty);
-                        let array_type_idx = *ctx
-                            .gc_types
-                            .variadic_array_type_idx
-                            .get(&elem_vt)
-                            .ok_or_else(|| "internal codegen error: no variadic array type registered for this elem type".to_string())?;
-                        for arg_expr in &trailing {
-                            compileExprAs(arg_expr, Some(elem_vt), body, ctx, state)?;
-                        }
-                        Instruction::ArrayNewFixed {
-                            array_type_index: array_type_idx,
-                            array_size: trailing.len() as u32,
-                        }
-                        .encode(body);
-                        let func_idx = ctx
+                let func_idx = ctx
-                            .func_ids
+                    .func_ids
-                            .get(&call.name)
+                    .get(&call.name)
-                            .ok_or_else(|| format!("unknown function '{}'", call.name))?;
+                    .ok_or_else(|| format!("unknown function '{}'", call.name))?;
-                        Instruction::Call(*func_idx).encode(body);
+                Instruction::Call(*func_idx).encode(body);
-                    }
-                    None => {
-                        for (i, arg) in call.args.iter().enumerate() {
-                            compileExprAs(argExprOf(arg), sig_params.get(i).copied(), body, ctx, state)?;
-                        }
-                        compileDefaultArgs(&call.name, call.args.len(), body, ctx, state)?;
+                coerceCallResult(&sig.decl_ret, expr, body, ctx);
-                        let func_idx = ctx
-                            .func_ids
-                            .get(&call.name)
-                            .ok_or_else(|| format!("unknown function '{}'", call.name))?;
-                        Instruction::Call(*func_idx).encode(body);
-                    }
-                }
             }
         }
         ast::Expr::Self_ => {
@@ -6290,6 +6156,11 @@ fn compileExpr(
         }
         ast::Expr::TypeName(n) => {
             match ctx.enum_variants.get(n) {
+                // A bare uppercase name the checker typed as a tag union is a tag
+                // literal, even when a declared variant shares its name.
+                Some(_) if matches!(inferLocalType(expr, ctx), PlumType::TTags(_)) => {
+                    compileTagLiteral(plum_checker::tagLiteralName(n), None, body, ctx, state)?
+                }
                 Some(info) if info.field_types.is_empty() => {
                     let global_idx = *ctx.singleton_globals.get(n)
                     .unwrap_or_else(|| panic!("internal codegen error: payload-free variant '{}' has no singleton global", n));
@@ -6349,14 +6220,20 @@ fn compileExpr(
                 && call.spread.is_none()
                 && matches!(ctx.methods.get(&(call.type_name.clone(), "init".to_string())), Some(PlumType::TFun(p, _)) if initCallableWithNoArgs(p)) =>
         {
-            let synthetic = ast::Expr::Attribute(Box::new(ast::AttributeExpr {
-                object: ast::Expr::TypeName(call.type_name.clone()),
+            let object = ast::Expr::TypeName(call.type_name.clone());
-                attr: ast::AttrKind::Method(ast::FnCall {
+            let init_call = ast::FnCall {
-                    name: "init".to_string(),
+                name: "init".to_string(),
-                    args: vec![],
+                args: vec![],
-                }),
+            };
+            compileMethodCall(
+                &object,
+                &init_call,
+                &PlumType::TNamed(call.type_name.clone()),
+                expr,
+                body,
+                ctx,
+                state,
-            }));
+            )?;
-            compileExpr(&synthetic, body, ctx, state)?;
         }
         // A NAMED-payload enum variant construction (`Circle(radius: 5)`, as
         // opposed to the positional/generic-payload form `Next(T)` — constructed
@@ -6391,13 +6268,7 @@ fn compileExpr(
             Instruction::I32Const(typeIdOf(ctx.gc_types, &call.type_name)).encode(body);
             for (field_idx, field_name) in field_names.iter().enumerate() {
                 match call.fields.iter().find(|fa| &fa.name == field_name) {
-                    Some(fa) => compileExprAs(
-                        &fa.value,
-                        info.field_types.get(field_idx).map(plumTypeToValtype),
+                    Some(fa) => compileExprInto(&fa.value, &info.field_types[field_idx], body, ctx, state)?,
-                        body,
-                        ctx,
-                        state,
-                    )?,
                     // `Circle(..c, radius: 10)` — a field not overridden is read
                     // straight off the spread source instead (checker only proved
                     // `c` is SOME value of the owning enum, restricted to a bare
@@ -6440,305 +6311,10 @@ fn compileExpr(
             let obj_ty = inferLocalType(&attr.object, ctx);
             match &attr.attr {
                 ast::AttrKind::Field(field_name) => {
-                    // `Str` is an ordinary class (`data: Buffer`) with no name of
-                    // its own carried in `PlumType::TStr` — resolve it via the
-                    // literal name "Str", same as `TNamed` does via its own name.
-                    let class_name = match &obj_ty {
-                        PlumType::TNamed(n) => n.clone(),
-                        PlumType::TStr => "Str".to_string(),
-                        other => {
-                            return Err(format!(
-                                "codegen: cannot access field '{}' on non-class type {}",
-                                field_name, other
-                            ))
-                        }
-                    };
-                    // Fall back to a discriminant enum's shared params, declared
-                    // directly on the enum's SUPERTYPE (see `buildGcTypeRegistry`'s
-                    // `EnumSuper` arm) — no `ref.cast` to any particular variant
-                    // needed, since every variant has the exact same field list as
-                    // the supertype itself. This ALSO covers a record-shaped enum's
-                    // own field (the `type X = ...` replacement) via the unique-
-                    // owning-variant fallback below, since its one variant is
-                    // trivially its own unique owner of every field it declares.
-                    match ctx.enum_params.get(&class_name) {
-                        Some(params) => {
-                            let field_idx = params
-                                .iter()
-                                .position(|(n, _)| n == field_name)
-                                .ok_or_else(|| {
-                                    format!(
-                                        "codegen: no field '{}' on enum '{}'",
-                                        field_name, class_name
-                                    )
-                                })?;
-                            let super_type_idx = *ctx
-                                .gc_types
-                                .enum_super_type_idx
-                                .get(&class_name)
-                                .ok_or_else(|| {
-                                    format!(
-                                        "codegen: enum '{}' missing from the GC type registry",
-                                        class_name
-                                    )
-                                })?;
-                            compileExpr(&attr.object, body, ctx, state)?;
+                    compileFieldRead(&attr.object, field_name, &obj_ty, expr, body, ctx, state)?
-                            Instruction::StructGet {
-                                struct_type_index: super_type_idx,
-                                field_index: fld(field_idx),
-                            }
-                            .encode(body);
-                        }
-                        // Not a discriminant enum either: `class_name` is an
-                        // ordinary enum, and `plum-checker`'s `inferExpr` already
-                        // verified exactly ONE of its variants declares a field
-                        // with this name (ambiguity across sibling variants is a
-                        // checker error, never reaches codegen). Compile `.field`
-                        // as a checked downcast to that one variant's own
-                        // concrete struct type (same `ref.cast` idiom `match`
-                        // pattern-matching already uses, e.g. `compileCasePositions`),
-                        // then read the field off it — traps at runtime if the
-                        // value turns out to be a different variant, so no static
-                        // proof the value IS that variant is required here.
-                        None => {
-                            let (variant_name, info) = ctx
-                                .enum_variants
-                                .iter()
-                                .find(|(_, info)| {
-                                    info.enum_name == class_name
-                                        && info.field_names.iter().any(|n| n == field_name)
-                                })
-                                .ok_or_else(|| {
-                                    format!(
-                                        "codegen: no field '{}' on enum '{}'",
-                                        field_name, class_name
-                                    )
-                                })?;
-                            let field_idx = info
-                                .field_names
-                                .iter()
-                                .position(|n| n == field_name)
-                                .expect("just found by this field name");
-                            let variant_type_idx = *ctx
-                                .gc_types
-                                .variant_type_idx
-                                .get(variant_name)
-                                .ok_or_else(|| {
-                                    format!(
-                                        "codegen: variant '{}' missing from the GC type registry",
-                                        variant_name
-                                    )
-                                })?;
-                            compileExpr(&attr.object, body, ctx, state)?;
-                            Instruction::RefCastNonNull(HeapType::Concrete(variant_type_idx))
-                                .encode(body);
-                            Instruction::StructGet {
-                                struct_type_index: variant_type_idx,
-                                field_index: fld(field_idx),
-                            }
-                            .encode(body);
-                        }
-                    }
                 }
                 ast::AttrKind::Method(call) => {
-                    let class_name = match &obj_ty {
-                        PlumType::TNamed(n) => n.clone(),
-                        // Builtin primitive types (`Int`/`Float`/`Bool`/`Str`) declare
-                        // methods the same way classes do (`type Int = fun ...` in
-                        // `libs/std`) — they're just never `TNamed`, so map them back
-                        // to the receiver name `ctx.func_ids`/`ctx.methods` use.
-                        PlumType::TInt => "Int".to_string(),
-                        PlumType::TFloat => "Float".to_string(),
-                        PlumType::TBool => "Bool".to_string(),
-                        PlumType::TStr => "Str".to_string(),
-                        PlumType::TByte => "Byte".to_string(),
-                        PlumType::TByteSlice => "ByteSlice".to_string(),
-                        other => {
-                            return Err(format!(
-                                "codegen: cannot call method '{}' on non-class type {}",
-                                call.name, other
-                            ))
-                        }
-                    };
-                    // A method call on a trait-typed value goes through the trait's
-                    // `$dyn$<Trait>$<method>` dispatcher (reads the receiver's typeId).
-                    let is_trait_recv = ctx.gc_types.class_type_idx.get(&class_name)
-                        == Some(&ctx.gc_types.obj_type_idx)
-                        && ctx.methods.contains_key(&(
-                            class_name.clone(),
-                            plum_checker::TRAIT_MARKER.to_string(),
-                        ));
-                    // A method the receiver's own trait doesn't declare (e.g. a
-                    // `T: ToStr` bound's `toStr` on a `Shape`-typed value inside a
-                    // specialized generic) dispatches through whichever trait does.
-                    let dyn_owner = if is_trait_recv {
-                        if ctx.gc_types.dyn_fns.contains_key(&(class_name.clone(), call.name.clone())) {
-                            Some(class_name.clone())
-                        } else {
-                            ctx.gc_types
-                                .dyn_fns
-                                .keys()
-                                .find(|(_, m)| *m == call.name)
-                                .map(|(t, _)| t.clone())
-                        }
-                    } else {
-                        None
-                    };
-                    if is_trait_recv && dyn_owner.is_none() {
-                        // No implementor of this method exists at all: unreachable at
-                        // runtime, but the call must still type-check structurally.
-                        Instruction::Unreachable.encode(body);
-                        return Ok(());
-                    }
-                    if let Some(&dyn_idx) = dyn_owner.as_ref().and_then(|t| {
-                        ctx.gc_types
-                            .dyn_fns
-                            .get(&(t.clone(), call.name.clone()))
-                    }) {
-                        let owner = dyn_owner.clone().unwrap_or_default();
-                        let param_tys: Vec<PlumType> =
-                            match ctx.methods.get(&(owner, call.name.clone())) {
-                                Some(PlumType::TFun(ps, _)) => ps.clone(),
-                                _ => Vec::new(),
-                            };
-                        compileExpr(&attr.object, body, ctx, state)?;
-                        for (i, arg) in call.args.iter().enumerate() {
-                            let e = match arg {
-                                ast::Arg::Positional(e) => e,
-                                ast::Arg::Keyword { value, .. } => value,
-                                ast::Arg::Pair { value, .. } => value,
-                            };
-                            compileExprAs(e, param_tys.get(i).map(plumTypeToValtype), body, ctx, state)?;
-                        }
-                        Instruction::Call(dyn_idx).encode(body);
-                        return Ok(());
-                    }
-                    let direct_key = format!("{}::{}", class_name, call.name);
-                    // Fallback: a primitive/class receiver's method might be
-                    // defined once on the "union" enum that bare-wraps it
-                    // instead (`enum Number = | Int | Float`, e.g. `abs`
-                    // defined on `Number` rather than duplicated per
-                    // primitive) — `class_name` (e.g. "Int") is itself a
-                    // registered enum-variant NAME in that case (see
-                    // `buildGlobalTables`'s bare-wrap conditions), so look up
-                    // its owning enum and retry there. `box_variant_idx` is
-                    // this variant's own concrete GC struct type index, used
-                    // below to box the raw `self` value into it before the
-                    // call (the wrap-enum's method expects a boxed `Number`,
-                    // not a bare `i64`/`f64`).
-                    let wrap_fallback = (!ctx.func_ids.contains_key(&direct_key)).then(|| {
-                        ctx.enum_variants.get(class_name.as_str()).and_then(|info| {
-                            let wrap_key = format!("{}::{}", info.enum_name, call.name);
-                            ctx.func_ids.contains_key(&wrap_key).then(|| {
-                                let variant_idx = *ctx.gc_types.variant_type_idx.get(class_name.as_str())
-                                    .expect("class_name is a registered enum variant, checked above");
-                                (info.enum_name.clone(), wrap_key, variant_idx)
-                            })
-                        })
-                    }).flatten();
-                    let (dispatch_name, key, box_variant_idx) = match wrap_fallback {
-                        Some((enum_name, wrap_key, variant_idx)) => {
-                            (enum_name, wrap_key, Some(variant_idx))
-                        }
-                        None => (class_name.clone(), direct_key, None),
-                    };
-                    let func_idx = *ctx.func_ids.get(&key).ok_or_else(|| {
-                        format!("codegen: unknown method '{}.{}'", class_name, call.name)
-                    })?;
-                    // A "static"-style call (`Bool.parse("true")`, `Float.fromStr("3.14")`)
-                    // on a self-less method declared inside a `type`/`enum` body — its
-                    // receiver is a bare reference to the type's own name, not a real
-                    // value. `attr.object`'s only possible resolution to exactly
-                    // `TNamed(class_name)` via a bare `TypeName` is this pattern (a real
-                    // enum-variant/const reference resolves to some OTHER concrete type,
-                    // per the checker's `inferExpr`). Every method still reserves a
-                    // leading self slot in its wasm signature regardless of whether its
-                    // Plum source declares a `self` param (see `fnWasmParamTypes`), so
-                    // something of the right type must still be pushed — the body simply
-                    // never reads it (no `self` binding exists for it to read).
-                    let is_static_call =
-                        matches!(&attr.object, ast::Expr::TypeName(n) if *n == class_name);
-                    if is_static_call {
-                        // Use `class_name`'s wasm type (via `astTypeToWasm`, exactly
-                        // like `fnWasmParamTypes` computed the callee's actual self
-                        // slot type), NOT `obj_ty` — for a builtin primitive receiver
-                        // (`Int.fromStr`), `obj_ty` is `TNamed("Int")` (the checker's
-                        // bare-`TypeName` fallback doesn't know about primitives), whose
-                        // `plumTypeToValtype` would wrongly resolve to a GC ref instead
-                        // of `i64`.
-                        let vt = astTypeToWasm(&dispatch_name).unwrap_or(ValType::I32);
-                        pushSelfPlaceholder(vt, body);
-                    } else {
-                        if box_variant_idx.is_some() {
-                            // The wrap-enum variant's header typeId goes below its payload.
-                            Instruction::I32Const(typeIdOf(ctx.gc_types, &class_name)).encode(body);
-                        }
-                        compileExpr(&attr.object, body, ctx, state)?; // push self
-                        if let Some(variant_idx) = box_variant_idx {
-                            // Dispatching to the wrap-enum's method (see
-                            // `wrap_fallback` above) — its `self` param is
-                            // typed as the ENUM (`Number`), a boxed GC struct,
-                            // not the bare primitive/class value just pushed.
-                            Instruction::StructNew(variant_idx).encode(body);
-                        }
-                    }
-                    fn argExprOf(arg: &ast::Arg) -> &ast::Expr {
-                        match arg {
-                            ast::Arg::Positional(e) => e,
-                            ast::Arg::Keyword { value, .. } => value,
-                            ast::Arg::Pair { value, .. } => value,
-                        }
-                    }
-                    // A trailing `...T` param (e.g. `add(self, values: ...T)`) packs its
-                    // trailing args into one GC array, exactly like a plain function call
-                    // (see the `Expr::FnCall` variadic-call arm) — `call.args` doesn't
-                    // include `self`, matching `ctx.methods`' own param list.
-                    let variadic_split =
-                        match ctx.methods.get(&(dispatch_name.clone(), call.name.clone())) {
-                            Some(PlumType::TFun(params, _)) => match params.last() {
-                                Some(PlumType::TVariadic(elem)) => {
-                                    Some(((**elem).clone(), params.len() - 1))
-                                }
-                                _ => None,
-                            },
-                            _ => None,
-                        };
-                    let sig_params: Vec<ValType> = ctx
-                        .func_sigs
-                        .get(&key)
-                        .map(|s| s.params.clone())
-                        .unwrap_or_default();
-                    match variadic_split {
-                        Some((elem_ty, fixed_count)) => {
-                            for (i, arg) in call.args.iter().take(fixed_count).enumerate() {
-                                compileExprAs(argExprOf(arg), sig_params.get(i + 1).copied(), body, ctx, state)?;
-                            }
-                            let trailing: Vec<&ast::Expr> =
-                                call.args.iter().skip(fixed_count).map(argExprOf).collect();
-                            let elem_vt = plumTypeToValtype(&elem_ty);
-                            let array_type_idx = *ctx
-                                .gc_types
-                                .variadic_array_type_idx
-                                .get(&elem_vt)
-                                .ok_or_else(|| "internal codegen error: no variadic array type registered for this elem type".to_string())?;
-                            for arg_expr in &trailing {
-                                compileExprAs(arg_expr, Some(elem_vt), body, ctx, state)?;
-                            }
-                            Instruction::ArrayNewFixed {
-                                array_type_index: array_type_idx,
-                                array_size: trailing.len() as u32,
-                            }
-                            .encode(body);
-                        }
-                        None => {
-                            for (i, arg) in call.args.iter().enumerate() {
-                                compileExprAs(argExprOf(arg), sig_params.get(i + 1).copied(), body, ctx, state)?;
-                            }
-                            compileDefaultArgs(&key, call.args.len(), body, ctx, state)?;
+                    compileMethodCall(&attr.object, call, &obj_ty, expr, body, ctx, state)?
-                        }
-                    }
-                    Instruction::Call(func_idx).encode(body);
                 }
             }
         }
@@ -6768,6 +6344,353 @@ fn compileExpr(
     Ok(())
 }
+/// After a call to a function whose DECLARED return type is `decl_ret`: converts
+/// the result from the callee's (erased) representation to the call
+/// expression's own instantiated type (unboxing a primitive that travelled
+/// through a generic `T` slot, or casting an erased reference back down).
+fn coerceCallResult(decl_ret: &PlumType, call_expr: &ast::Expr, body: &mut Vec<u8>, ctx: &LocalCtx) {
+    coerceCallResultTo(decl_ret, &inferLocalType(call_expr, ctx), body, ctx);
+}
+fn coerceCallResultTo(decl_ret: &PlumType, want: &PlumType, body: &mut Vec<u8>, ctx: &LocalCtx) {
+    if matches!(decl_ret, PlumType::TUnit) || matches!(want, PlumType::TUnit | PlumType::TVar(_)) {
+        return;
+    }
+    coerceVt(
+        plumTypeToValtype(decl_ret),
+        plumTypeToValtype(want),
+        body,
+        ctx.gc_types,
+    );
+}
+/// Pushes the arguments of a call to the function described by `sig`: each fixed
+/// argument converted to its DECLARED param type (boxing into erased `T` slots,
+/// wrapping a bare `Int`/`Float` for a `Number` param), a trailing `...T` pack
+/// built into one GC array, and the declared defaults for omitted trailing params.
+fn compileCallArgs(
+    func_key: &str,
+    args: &[ast::Arg],
+    sig: &FuncSig,
+    body: &mut Vec<u8>,
+    ctx: &LocalCtx,
+    state: &mut ModuleState,
+) -> Result<(), String> {
+    let decl = &sig.decl_params;
+    match decl.last() {
+        Some(PlumType::TVariadic(elem)) => {
+            let fixed = decl.len() - 1;
+            for (i, arg) in args.iter().take(fixed).enumerate() {
+                compileExprInto(argExprOf(arg), &decl[i], body, ctx, state)?;
+            }
+            let trailing: Vec<&ast::Expr> = args.iter().skip(fixed).map(argExprOf).collect();
+            let elem_vt = plumTypeToValtype(elem);
+            let array_type_idx = *ctx
+                .gc_types
+                .variadic_array_type_idx
+                .get(&elem_vt)
+                .ok_or_else(|| "internal codegen error: no variadic array type registered for this elem type".to_string())?;
+            for arg_expr in &trailing {
+                compileExprInto(arg_expr, elem, body, ctx, state)?;
+            }
+            Instruction::ArrayNewFixed {
+                array_type_index: array_type_idx,
+                array_size: trailing.len() as u32,
+            }
+            .encode(body);
+        }
+        _ => {
+            for (i, arg) in args.iter().enumerate() {
+                match decl.get(i) {
+                    Some(d) => compileExprInto(argExprOf(arg), d, body, ctx, state)?,
+                    None => compileExpr(argExprOf(arg), body, ctx, state)?,
+                }
+            }
+            compileDefaultArgs(func_key, args.len(), body, ctx, state)?;
+        }
+    }
+    Ok(())
+}
+/// `object.field` for a class / enum value: a `struct.get` of the field at its
+/// DECLARED (possibly erased `T`) representation, converted to the access
+/// expression's own instantiated type.
+fn compileFieldRead(
+    object: &ast::Expr,
+    field_name: &str,
+    obj_ty: &PlumType,
+    expr: &ast::Expr,
+    body: &mut Vec<u8>,
+    ctx: &LocalCtx,
+    state: &mut ModuleState,
+) -> Result<(), String> {
+    // `Str` is an ordinary class (`data: Buffer`) with no name of its own carried
+    // in `PlumType::TStr` — resolve it via the literal name "Str", same as a
+    // `TNamed`/`TApp` does via its own name.
+    let class_name = match (plum_checker::nominalName(obj_ty), obj_ty) {
+        (Some(n), _) => n.to_string(),
+        (None, PlumType::TStr) => "Str".to_string(),
+        _ => {
+            return Err(format!(
+                "codegen: cannot access field '{}' on non-class type {}",
+                field_name, obj_ty
+            ))
+        }
+    };
+    let want = plumTypeToValtype(&inferLocalType(expr, ctx));
+    // A discriminant enum's shared params are declared directly on the enum's
+    // SUPERTYPE (see `buildGcTypeRegistry`'s `EnumSuper` arm) — no `ref.cast` to
+    // any one variant needed.
+    if let Some(params) = ctx.enum_params.get(&class_name) {
+        let field_idx = params
+            .iter()
+            .position(|(n, _)| n == field_name)
+            .ok_or_else(|| format!("codegen: no field '{}' on enum '{}'", field_name, class_name))?;
+        let super_type_idx = *ctx
+            .gc_types
+            .enum_super_type_idx
+            .get(&class_name)
+            .ok_or_else(|| {
+                format!("codegen: enum '{}' missing from the GC type registry", class_name)
+            })?;
+        compileExpr(object, body, ctx, state)?;
+        Instruction::StructGet {
+            struct_type_index: super_type_idx,
+            field_index: fld(field_idx),
+        }
+        .encode(body);
+        coerceVt(
+            plumTypeToValtype(&params[field_idx].1),
+            want,
+            body,
+            ctx.gc_types,
+        );
+        return Ok(());
+    }
+    // Not a discriminant enum: `class_name` is an ordinary enum, and the checker
+    // already verified exactly ONE of its variants declares a field with this name.
+    // Compile `.field` as a checked downcast to that one variant's own struct type,
+    // then read the field off it — traps at runtime if the value turns out to be a
+    // different variant.
+    let (variant_name, info) = ctx
+        .enum_variants
+        .iter()
+        .find(|(_, info)| {
+            info.enum_name == class_name && info.field_names.iter().any(|n| n == field_name)
+        })
+        .ok_or_else(|| format!("codegen: no field '{}' on enum '{}'", field_name, class_name))?;
+    let field_idx = info
+        .field_names
+        .iter()
+        .position(|n| n == field_name)
+        .expect("just found by this field name");
+    let variant_type_idx = *ctx
+        .gc_types
+        .variant_type_idx
+        .get(variant_name)
+        .ok_or_else(|| {
+            format!(
+                "codegen: variant '{}' missing from the GC type registry",
+                variant_name
+            )
+        })?;
+    compileExpr(object, body, ctx, state)?;
+    Instruction::RefCastNonNull(HeapType::Concrete(variant_type_idx)).encode(body);
+    Instruction::StructGet {
+        struct_type_index: variant_type_idx,
+        field_index: fld(field_idx),
+    }
+    .encode(body);
+    coerceVt(
+        plumTypeToValtype(&info.field_types[field_idx]),
+        want,
+        body,
+        ctx.gc_types,
+    );
+    Ok(())
+}
+/// Resolves a method call's receiver name to the function that implements it:
+/// the receiver's own `Name::method`, or — for a primitive/class receiver whose
+/// method is defined once on the "union" enum that bare-wraps it
+/// (`enum Number = | Int | Float`) — that enum's method together with the wrapping
+/// variant the raw `self` must be boxed into first.
+fn resolveMethodKey(class_name: &str, method: &str, ctx: &LocalCtx) -> (String, String, Option<String>) {
+    let direct_key = format!("{}::{}", class_name, method);
+    if !ctx.func_ids.contains_key(&direct_key) {
+        if let Some(info) = ctx.enum_variants.get(class_name) {
+            let wrap_key = format!("{}::{}", info.enum_name, method);
+            if ctx.func_ids.contains_key(&wrap_key) {
+                return (info.enum_name.clone(), wrap_key, Some(class_name.to_string()));
+            }
+        }
+    }
+    (class_name.to_string(), direct_key, None)
+}
+/// The trait that declares `method` (with `arity` params) and has a `$dyn$` dispatcher,
+/// for a call on an erased (`TParam`-typed) receiver whose bound traits the codegen
+/// does not otherwise track.
+fn dynOwnerForMethod(method: &str, arity: usize, ctx: &LocalCtx) -> Option<String> {
+    let mut owners: Vec<&String> = ctx
+        .gc_types
+        .dyn_fns
+        .keys()
+        .filter(|(_, m)| m == method)
+        .map(|(t, _)| t)
+        .filter(|t| {
+            matches!(
+                ctx.methods.get(&((*t).clone(), method.to_string())),
+                Some(PlumType::TFun(ps, _)) if ps.len() == arity
+            )
+        })
+        .collect();
+    owners.sort();
+    owners.first().map(|t| (*t).clone())
+}
+/// Compiles `object.method(args)`. `obj_ty` is the receiver's static type and
+/// `result_expr` the expression whose recorded type is the call's instantiated
+/// result type (a desugared `Type(...)` -> `Type.init(...)` passes the original
+/// call expression).
+fn compileMethodCall(
+    object: &ast::Expr,
+    call: &ast::FnCall,
+    obj_ty: &PlumType,
+    result_expr: &ast::Expr,
+    body: &mut Vec<u8>,
+    ctx: &LocalCtx,
+    state: &mut ModuleState,
+) -> Result<(), String> {
+    // A method on an erased generic parameter (`K: Hashable` -> `key.hash()`)
+    // dispatches dynamically through the declaring trait's `$dyn$` dispatcher.
+    if matches!(obj_ty, PlumType::TParam(_)) {
+        let owner = dynOwnerForMethod(&call.name, call.args.len(), ctx).ok_or_else(|| {
+            format!(
+                "codegen: '{}' has no method '{}' (add a bound)",
+                obj_ty, call.name
+            )
+        })?;
+        return compileDynCall(&owner, object, call, &inferLocalType(result_expr, ctx), body, ctx, state);
+    }
+    let class_name = match plum_checker::methodReceiverName(obj_ty) {
+        Some(n) => n,
+        None => {
+            return Err(format!(
+                "codegen: cannot call method '{}' on non-class type {}",
+                call.name, obj_ty
+            ))
+        }
+    };
+    // A method call on a trait-typed value goes through the trait's
+    // `$dyn$<Trait>$<method>` dispatcher (reads the receiver's typeId).
+    let is_trait_recv = ctx.gc_types.class_type_idx.get(&class_name)
+        == Some(&ctx.gc_types.obj_type_idx)
+        && ctx
+            .methods
+            .contains_key(&(class_name.clone(), plum_checker::TRAIT_MARKER.to_string()));
+    if is_trait_recv {
+        // A method the receiver's own trait doesn't declare dispatches through
+        // whichever trait does.
+        let owner = if ctx
+            .gc_types
+            .dyn_fns
+            .contains_key(&(class_name.clone(), call.name.clone()))
+        {
+            Some(class_name.clone())
+        } else {
+            dynOwnerForMethod(&call.name, call.args.len(), ctx)
+        };
+        return match owner {
+            Some(owner) => compileDynCall(&owner, object, call, &inferLocalType(result_expr, ctx), body, ctx, state),
+            None => {
+                // The trait declares the method (the checker rejects any other) but
+                // no type implements it: unreachable at runtime, but the call must
+                // still be valid wasm.
+                Instruction::Unreachable.encode(body);
+                Ok(())
+            }
+        };
+    }
+    let (dispatch_name, key, box_variant) = resolveMethodKey(&class_name, &call.name, ctx);
+    let func_idx = *ctx
+        .func_ids
+        .get(&key)
+        .ok_or_else(|| format!("codegen: unknown method '{}.{}'", class_name, call.name))?;
+    // A "static"-style call (`Bool.parse("true")`, `Float.fromStr("3.14")`) on a
+    // self-less method declared inside a `type`/`enum` body — its receiver is a
+    // bare reference to the type's own name, not a real value. Every method still
+    // reserves a leading self slot in its wasm signature regardless of whether its
+    // Plum source declares a `self` param (see `fnWasmParamTypes`), so something of
+    // the right type must still be pushed — the body simply never reads it.
+    let is_static_call = matches!(object, ast::Expr::TypeName(n) if *n == class_name);
+    if is_static_call {
+        let vt = astTypeToWasm(&dispatch_name).unwrap_or(ValType::I32);
+        pushSelfPlaceholder(vt, body);
+    } else {
+        if let Some(variant) = &box_variant {
+            // The wrap-enum variant's header typeId goes below its payload.
+            Instruction::I32Const(typeIdOf(ctx.gc_types, variant)).encode(body);
+        }
+        compileExpr(object, body, ctx, state)?; // push self
+        if let Some(variant) = &box_variant {
+            // Dispatching to the wrap-enum's method — its `self` param is typed as
+            // the ENUM (`Number`), a boxed GC struct, not the bare primitive just pushed.
+            let variant_idx = *ctx.gc_types.variant_type_idx.get(variant).ok_or_else(|| {
+                format!("codegen: variant '{}' missing from the GC type registry", variant)
+            })?;
+            Instruction::StructNew(variant_idx).encode(body);
+        }
+    }
+    let sig = ctx
+        .func_sigs
+        .get(&key)
+        .ok_or_else(|| format!("codegen: unknown method '{}.{}'", class_name, call.name))?;
+    compileCallArgs(&key, &call.args, sig, body, ctx, state)?;
+    Instruction::Call(func_idx).encode(body);
+    coerceCallResult(&sig.decl_ret, result_expr, body, ctx);
+    Ok(())
+}
+/// A call through `owner`'s `$dyn$<owner>$<method>` dispatcher: the receiver (any
+/// value, converted to the erased `$Obj` representation — a primitive is boxed)
+/// followed by the arguments at the trait method's declared param types.
+fn compileDynCall(
+    owner: &str,
+    object: &ast::Expr,
+    call: &ast::FnCall,
+    want: &PlumType,
+    body: &mut Vec<u8>,
+    ctx: &LocalCtx,
+    state: &mut ModuleState,
+) -> Result<(), String> {
+    let dyn_idx = *ctx
+        .gc_types
+        .dyn_fns
+        .get(&(owner.to_string(), call.name.clone()))
+        .ok_or_else(|| format!("codegen: no dispatcher for '{}.{}'", owner, call.name))?;
+    let (param_tys, ret_ty): (Vec<PlumType>, PlumType) =
+        match ctx.methods.get(&(owner.to_string(), call.name.clone())) {
+            Some(PlumType::TFun(ps, r)) => (ps.clone(), (**r).clone()),
+            _ => (Vec::new(), PlumType::TUnit),
+        };
+    let obj_vt = ValType::Ref(RefType {
+        nullable: true,
+        heap_type: HeapType::Concrete(ctx.gc_types.obj_type_idx),
+    });
+    compileExprAs(object, Some(obj_vt), body, ctx, state)?;
+    for (i, arg) in call.args.iter().enumerate() {
+        match param_tys.get(i) {
+            Some(d) => compileExprInto(argExprOf(arg), d, body, ctx, state)?,
+            None => compileExpr(argExprOf(arg), body, ctx, state)?,
+        }
+    }
+    Instruction::Call(dyn_idx).encode(body);
+    coerceCallResultTo(&ret_ty, want, body, ctx);
+    Ok(())
+}
 /// Compiles a variant-construction call. A payload-free variant (`End`, called as
 /// `End()` rather than used bare) is its pre-allocated singleton global. A payload
 /// variant pushes its field values in order and does `struct.new` into its own
@@ -6790,14 +6713,17 @@ fn compileDefaultArgs(
     let Some(sig) = ctx.func_sigs.get(func_key) else {
         return Ok(());
     };
-    for default in sig.param_defaults.iter().skip(supplied_count) {
+    for (i, default) in sig.param_defaults.iter().enumerate().skip(supplied_count) {
         let default_expr = default.as_ref().ok_or_else(|| {
             format!(
                 "codegen: call '{}' is missing a required argument (no default declared)",
                 func_key
             )
         })?;
+        match sig.decl_params.get(i) {
+            Some(d) => compileExprInto(default_expr, d, body, ctx, state)?,
-        compileExpr(default_expr, body, ctx, state)?;
+            None => compileExpr(default_expr, body, ctx, state)?,
+        }
     }
     Ok(())
 }
@@ -6852,13 +6778,10 @@ fn compileVariantConstruction(
             ast::Arg::Keyword { value, .. } => value,
             ast::Arg::Pair { value, .. } => value,
         };
-        compileExprAs(
-            arg_expr,
-            info.field_types.get(i).map(plumTypeToValtype),
+        match info.field_types.get(i) {
-            body,
+            Some(d) => compileExprInto(arg_expr, d, body, ctx, state)?,
-            ctx,
-            state,
+            None => compileExpr(arg_expr, body, ctx, state)?,
-        )?;
+        }
     }
     Instruction::StructNew(variant_type_idx).encode(body);
     Ok(())
@@ -6944,10 +6867,35 @@ fn compileInterpolatedString(
                         Instruction::Call(func_idx).encode(body);
                     }
                     other => {
+                        // An erased (`T`) or trait-typed value dispatches `toStr`
+                        // dynamically; a class/enum with its own `toStr` calls it.
+                        let to_str = ast::FnCall {
+                            name: "toStr".to_string(),
+                            args: vec![],
+                        };
+                        let str_ty = PlumType::TStr;
+                        let is_dyn = match &other {
+                            PlumType::TParam(_) => true,
+                            t => plum_checker::nominalName(t).is_some_and(|n| {
+                                ctx.gc_types.class_type_idx.get(n)
+                                    == Some(&ctx.gc_types.obj_type_idx)
+                            }),
+                        };
+                        if is_dyn {
+                            let owner = dynOwnerForMethod("toStr", 0, ctx).ok_or_else(|| {
+                                format!("codegen: interpolating a value of type {} requires a `toStr` method", other)
+                            })?;
+                            compileDynCall(&owner, expr, &to_str, &str_ty, body, ctx, state)?;
+                        } else if plum_checker::nominalName(&other)
+                            .is_some_and(|n| ctx.func_ids.contains_key(&format!("{}::toStr", n)))
+                        {
+                            compileMethodCall(expr, &to_str, &other, expr, body, ctx, state)?;
+                        } else {
-                        return Err(format!(
+                            return Err(format!(
-                            "codegen: interpolating a value of type {} is not yet supported",
+                                "codegen: interpolating a value of type {} is not yet supported",
-                            other
+                                other
-                        ));
+                            ));
+                        }
                     }
                 }
             }
@@ -6980,7 +6928,7 @@ fn compileClosureLiteral(
     // env struct (snapshotting each captured free variable's current value from the
     // enclosing function's local), then wrap both into the shared closure struct.
     Instruction::I32Const(info.table_idx as i32).encode(body);
-    for (name, _) in &info.free_vars {
+    for (name, cap_ty) in &info.free_vars {
         let local_idx = *ctx.locals.get(name).ok_or_else(|| {
             format!(
                 "codegen: captured variable '{}' is not a local in the enclosing scope",
@@ -6988,20 +6936,30 @@ fn compileClosureLiteral(
             )
         })?;
         Instruction::LocalGet(local_idx).encode(body);
+        let have = ctx
+            .local_decl_types
+            .get(name)
+            .map(plumTypeToValtype)
+            .unwrap_or_else(|| plumTypeToValtype(cap_ty));
+        coerceVt(have, plumTypeToValtype(cap_ty), body, ctx.gc_types);
     }
     Instruction::StructNew(info.env_type_idx).encode(body);
     Instruction::StructNew(ctx.gc_types.closure_type_idx).encode(body);
     Ok(())
 }
-/// Compiles a call to a closure-typed local via `call_indirect`. The local is
+/// Compiles a call to a closure-typed local via `call_indirect`, using the erased
+/// closure ABI (`ClosureSigKey`): every argument is converted to `anyref`
+/// (primitives boxed), the result is converted from `anyref` to the call's own
+/// instantiated type (or dropped when the closure's declared result is `Unit`).
-/// statically typed `anyref` (closures share that placeholder type — see
+/// The local is statically `anyref` (closures share that placeholder type — see
 /// `plumTypeToValtype`), so every read of its fields `ref.cast`s down to the shared
 /// concrete closure struct type first. Stack order matches the closure function's
 /// signature `(env, ...args)`: push the env, then each argument, then the table
 /// index (the `call_indirect` operand).
 fn compileClosureCall(
     call: &ast::FnCall,
+    call_expr: &ast::Expr,
     body: &mut Vec<u8>,
     ctx: &LocalCtx,
     state: &mut ModuleState,
@@ -7011,41 +6969,14 @@ fn compileClosureCall(
         .get(&call.name)
         .ok_or_else(|| format!("codegen: closure '{}' is not a local", call.name))?;
     let closure_type_idx = ctx.gc_types.closure_type_idx;
-    // Prefer the exact signature recorded when this local was assigned a closure
-    // *literal* (see `closure_local_sigs`) — it's already correct. Otherwise (e.g.
-    // `call.name` is a `fn(...)`-typed parameter, whose declared type is reliable on
-    // its own) fall back to re-deriving it from the type env.
-    let sig_key: ClosureSigKey = match ctx.closure_local_sigs.borrow().get(&call.name) {
-        Some(key) => key.clone(),
-        None => {
-            let (param_ptypes, ret_ptype) =
-                match inferLocalType(&ast::Expr::Var(call.name.clone()), ctx) {
-                    PlumType::TFun(p, r) => (p, *r),
-                    other => {
-                        return Err(format!(
-                            "codegen: '{}' is not callable (type {:?})",
-                            call.name, other
-                        ))
-                    }
-                };
-            let mut sig_params = vec![ValType::Ref(RefType::ANYREF)]; // env pointer
-            for p in &param_ptypes {
-                sig_params.push(plumTypeToValtype(p));
-            }
-            let ret_vt = match ret_ptype {
-                PlumType::TUnit => None,
-                other => Some(plumTypeToValtype(&other)),
-            };
-            (sig_params, ret_vt)
-        }
-    };
-    let type_index = *ctx.closure_call_types.get(&sig_key).ok_or_else(|| {
+    let type_index = *ctx.closure_call_types.get(&call.args.len()).ok_or_else(|| {
         format!(
-            "internal codegen error: no call_indirect type for closure '{}'",
+            "internal codegen error: no call_indirect type for closure '{}' with {} args",
-            call.name
+            call.name,
+            call.args.len()
         )
     })?;
+    let any = ValType::Ref(RefType::ANYREF);
     // env (closure struct field 1)
     Instruction::LocalGet(closure_local).encode(body);
@@ -7055,9 +6986,9 @@ fn compileClosureCall(
         field_index: 1,
     }
     .encode(body);
-    // real arguments
+    // real arguments, boxed to the erased ABI
     for arg in &call.args {
-        compileExpr(argExprOf(arg), body, ctx, state)?;
+        compileExprAs(argExprOf(arg), Some(any), body, ctx, state)?;
     }
     // table index (closure struct field 0) — the call_indirect operand
     Instruction::LocalGet(closure_local).encode(body);
@@ -7072,12 +7003,36 @@ fn compileClosureCall(
         table_index: 0,
     }
     .encode(body);
+    // The result: `Unit` closures produce a null anyref that is dropped here, so
+    // a Unit-typed call leaves nothing on the stack (see `exprHasResult`).
+    if closureCallReturnsUnit(&call.name, ctx) {
+        Instruction::Drop.encode(body);
+    } else {
+        let want = plumTypeToValtype(&inferLocalType(call_expr, ctx));
+        coerceVt(any, want, body, ctx.gc_types);
+    }
     Ok(())
 }
+/// Whether the closure-typed local `name` is declared to return `Unit`.
+fn closureCallReturnsUnit(name: &str, ctx: &LocalCtx) -> bool {
+    match ctx.local_decl_types.get(name) {
+        Some(PlumType::TFun(_, ret)) => matches!(**ret, PlumType::TUnit),
+        _ => match inferLocalType(&ast::Expr::Var(name.to_string()), ctx) {
+            PlumType::TFun(_, ret) => matches!(*ret, PlumType::TUnit),
+            _ => false,
+        },
+    }
+}
-/// Compiles a closure literal's own body into a standalone wasm function. Local 0 is the
+/// Compiles a closure literal's own body into a standalone wasm function with the
+/// erased closure ABI `(env: anyref, a1: anyref, ..., an: anyref) -> anyref`
+/// (see `ClosureSigKey`). Local 0 is the env pointer; locals `1..=n` are the raw
-/// implicit env pointer; the closure's params follow; then each captured free variable
+/// incoming params; typed locals follow — one per closure param (holding the
+/// raw param unboxed/cast to its real Plum type by the prologue), one per
-/// gets a local loaded from the env struct at function entry (restoring the snapshot).
+/// captured free variable (restored from the env struct), then the body's own
+/// named locals and scratch slots. The tail value is boxed back to `anyref` (a
+/// `Unit` body yields a null `anyref`).
 fn compileClosureBody(
     cl: &ast::Closure,
     info: &ClosureInfo,
@@ -7086,23 +7041,21 @@ fn compileClosureBody(
 ) -> Result<Vec<u8>, String> {
     let mut body = Vec::new();
-    // Base type env: globals + captured free vars + closure params.
+    // Fallback type env (synthesized nodes only) + declared local types.
     let mut base_env = ctx.global_env.clone();
+    let mut decl_types: HashMap<String, PlumType> = HashMap::new();
     for (name, ty) in &info.free_vars {
         base_env.insert(name.clone(), TypeScheme::mono(ty.clone()));
+        decl_types.insert(name.clone(), ty.clone());
     }
     for (name, pty) in cl.params.iter().zip(info.param_ptypes.iter()) {
         base_env.insert(name.clone(), TypeScheme::mono(pty.clone()));
+        decl_types.insert(name.clone(), pty.clone());
     }
     let mut collector = Collector {
-        env: base_env.clone(),
-        cctx: checkCtxOf(
-            &ctx.methods,
+        types: &ctx.types,
-            &ctx.enum_variants,
+        enum_variants: &ctx.enum_variants,
-            &ctx.enum_params,
-            &ctx.min_required,
-        ),
         named: Vec::new(),
         named_set: Default::default(),
         match_scratch: HashMap::new(),
@@ -7115,14 +7068,18 @@ fn compileClosureBody(
     collector.walkBlock(&cl.body);
     // ---- local index layout ----
-    // [env_ptr][closure params][free-var locals][named...][classcall][match][closure scratch]
+    // [env_ptr][raw params][typed params][free-var locals][named...][match][scratch]
     let mut locals: HashMap<String, u32> = HashMap::new();
     let mut groups: Vec<ValType> = Vec::new();
     let mut idx = 0u32;
-    idx += 1; // local 0 = env pointer (a param, so not declared below)
+    idx += 1 + cl.params.len() as u32; // env + raw params (all in the signature)
+    let mut param_prologue: Vec<(u32, u32, ValType)> = Vec::new(); // (raw, typed, vt)
+    for (i, (name, pty)) in cl.params.iter().zip(info.param_ptypes.iter()).enumerate() {
-    for name in &cl.params {
+        let vt = plumTypeToValtype(pty);
         locals.insert(name.clone(), idx);
+        groups.push(vt);
+        param_prologue.push((i as u32 + 1, idx, vt));
         idx += 1;
     }
     for (name, ty) in &info.free_vars {
@@ -7131,6 +7088,7 @@ fn compileClosureBody(
         idx += 1;
     }
     for (name, ty) in &collector.named {
+        decl_types.entry(name.clone()).or_insert_with(|| ty.clone());
         if locals.contains_key(name) {
             continue;
         }
@@ -7150,10 +7108,6 @@ fn compileClosureBody(
     }
     let nested_class_scratch_base = idx;
-    // Each slot is declared with its OWN concrete variant ref type (not a uniform
-    // placeholder) — `struct.get` on a constructor-pattern match requires the local
-    // holding the narrowed (`ref.cast`) value to be statically typed as that exact
-    // variant, and different slots very likely narrow to different variants.
     for vname in &collector.nested_class_scratch_types {
         let variant_idx = withGcTypes(|r| classOrVariantTypeIdx(r, vname));
         groups.push(gcRef(variant_idx));
@@ -7184,6 +7138,12 @@ fn compileClosureBody(
         }
     }
+    // Prologue: convert each raw `anyref` param to its real representation.
+    for (raw, typed, vt) in &param_prologue {
+        Instruction::LocalGet(*raw).encode(&mut body);
+        coerceVt(ValType::Ref(RefType::ANYREF), *vt, &mut body, &ctx.gc_types);
+        Instruction::LocalSet(*typed).encode(&mut body);
+    }
     // Restore each captured free variable from the env struct (local 0, statically
     // `anyref` — `ref.cast` down to THIS closure's own concrete env type) at entry.
     for (i, (name, _)) in info.free_vars.iter().enumerate() {
@@ -7208,11 +7168,14 @@ fn compileClosureBody(
         variadic_for_scratch: collector.variadic_for_scratch,
         func_ids: &ctx.func_ids,
         func_sigs: &ctx.func_sigs,
+        types: &ctx.types,
+        local_decl_types: decl_types,
         closures: &ctx.closures,
         closure_call_types: &ctx.closure_call_types,
         named_fn_values: &ctx.named_fn_values,
         string_concat_func: ctx.string_concat_func,
         string_eq_func: ctx.string_eq_func,
+        dyn_eq_func: ctx.dyn_eq_func,
         int_to_string_func: ctx.int_to_string_func,
         methods: &ctx.methods,
         enum_variants: &ctx.enum_variants,
@@ -7221,13 +7184,22 @@ fn compileClosureBody(
         gc_types: &ctx.gc_types,
         singleton_globals: &ctx.singleton_globals,
         type_env: RefCell::new(base_env),
-        closure_local_sigs: RefCell::new(HashMap::new()),
         loop_extra_depth: Cell::new(0),
-        ret_type: None,
+        in_closure: true,
+        ret_type: Some(info.ret_ptype.clone()),
         match_subject_types: RefCell::new(HashMap::new()),
+        subject_ptypes: RefCell::new(HashMap::new()),
     };
+    let any = ValType::Ref(RefType::ANYREF);
+    if matches!(info.ret_ptype, PlumType::TUnit) {
+        compileBlockAsFnBody(&cl.body, &mut body, &local_ctx, state, None)?;
+        Instruction::RefNull(HeapType::ANY).encode(&mut body);
+    } else {
+        let ret_vt = plumTypeToValtype(&info.ret_ptype);
-    compileBlockAsFnBody(&cl.body, &mut body, &local_ctx, state, info.ret_vt)?;
+        compileBlockAsFnBody(&cl.body, &mut body, &local_ctx, state, Some(ret_vt))?;
+        coerceVt(ret_vt, any, &mut body, &ctx.gc_types);
+    }
     Instruction::End.encode(&mut body);
     Ok(body)

plum-wasm-codegen/tests/codegen_tests.rs CHANGED Viewed

@@ -194,6 +194,9 @@ fn assertValid(src: &str) -> Vec<u8> {
     let source = parse(src);
     let bytes =
         compileSource(&source).unwrap_or_else(|e| panic!("compile failed for {:?}: {}", src, e));
+    if let Some(path) = std::env::var_os("PLUM_DUMP_WASM") {
+        let _ = std::fs::write(path, &bytes);
+    }
     let result = wasmparser::validate(&bytes);
     assert!(result.is_ok(), "wasm validation failed: {:?}", result.err());
     bytes
@@ -1132,9 +1135,9 @@ fn question_mark_different_ok_types() {
 fun inner() -> Try[Int, [A]] =
   {}
-fun outer() -> Try[Str, [A, B]] =
+fun outer() -> Try[Float, [A, B]] =
   x := inner()?
-  Ok(\"fine\")
+  Ok(1.5)
 fun main() -> Int =
   match outer()
@@ -1288,9 +1291,9 @@ fn probe_question_mark_payload_tag_and_str_payload() {
 fun inner() -> Try[Int, [Bad(Str)]] =
   {}
-fun outer() -> Try[Str, [Bad(Str), Other(Int)]] =
+fun outer() -> Try[Float, [Bad(Str), Other(Int)]] =
   x := inner()?
-  Ok(\"fine\")
+  Ok(1.5)
 fun main() -> Int =
   match outer()
@@ -1468,7 +1471,7 @@ fn probe_question_mark_merges_two_ok_types() {
 fun getInt() -> Try[Int, [A]] =
   {}
-fun getStr() -> Try[Str, [B]] =
+fun getStr() -> Try[Float, [B]] =
   {}
 fun both() -> Try[Int, [A, B]] =
@@ -1485,8 +1488,8 @@ fun main() -> Int =
             a, b
         )
     };
-    assert_eq!(runTryMain(&prog("Ok(5)", "Ok(\"x\")")), 5);
+    assert_eq!(runTryMain(&prog("Ok(5)", "Ok(2.5)")), 5);
-    assert_eq!(runTryMain(&prog("Err(A)", "Ok(\"x\")")), 100);
+    assert_eq!(runTryMain(&prog("Err(A)", "Ok(2.5)")), 100);
     assert_eq!(runTryMain(&prog("Ok(5)", "Err(B)")), 200);
 }
@@ -1672,3 +1675,100 @@ fun main() -> Int =
 ";
     assert_eq!(runMerged::<i64>("boxed", src), 1);
 }
+// ---- erased generics (T4) ----
+#[test]
+fn boxed_i64_extremes_through_generic() {
+    let src = "\
+import std/Bool
+import std/Str
+import std/Number
+fun identity(x: T) -> T =
+  x
+fun main() -> Int =
+  lo := 0 - 9223372036854775807 - 1
+  big := 9007199254740993
+  nz := identity(-0.0)
+  ok := identity(lo) == lo && identity(big) == big && identity(big + 0) - big == 0
+  neg := 1.0 / nz < 0.0
+  if ok && neg && identity(0 - 5) == 0 - 5
+    return 1
+  return 0
+";
+    assert_eq!(runMerged::<i64>("extremes", src), 1);
+}
+#[test]
+fn generic_closure_thunk() {
+    let src = "\
+import std/Bool
+import std/Str
+import std/Number
+import std/Try
+import std/List
+fun main() -> Int =
+  xs := List(1, 2, 3).map(|n| n * 2)
+  xs.reduce(0, |acc, x| acc + x)
+";
+    assert_eq!(runMerged::<i64>("thunk", src), 12);
+}
+#[test]
+fn try_of_list_of_try() {
+    let src = "\
+import std/Bool
+import std/Str
+import std/Number
+import std/Try
+import std/List
+fun inner(n: Int) -> Try[Int, [A]] =
+  if n > 1
+    return Err(A)
+  return Ok(n + 40)
+fun make() -> Try[List[Try[Int, [A]]], [B]] =
+  return Ok(List(inner(1), inner(2)))
+fun main() -> Int =
+  match make()
+    Ok(xs) =>
+      first := xs.get(0).unwrap()
+      second := xs.get(1).unwrap()
+      match first, second
+        Ok(a), Err(_) => a
+        _, _ => 0
+    Err(_) => 0
+";
+    assert_eq!(runMerged::<i64>("trylist", src), 41);
+}
+#[test]
+fn one_copy_per_generic() {
+    let src = "\
+import std/Bool
+import std/Str
+import std/Number
+import std/Try
+import std/List
+fun main() -> Int =
+  a := List(1, 2).map(|n| n + 1)
+  b := List(\"x\", \"y\").map(|s| s + \"!\")
+  a.length() + b.length()
+";
+    let dir = std::env::temp_dir().join(format!("plum_t4_copy_{}", std::process::id()));
+    std::fs::create_dir_all(&dir).unwrap();
+    let path = dir.join("main.plum");
+    std::fs::write(&path, src).unwrap();
+    let source = plum_core::loadAndMerge(&path, &repoRoot()).expect("load");
+    let (_, keys) = plum_wasm_codegen::compileSourceWithFunctions(&source).expect("compile");
+    let _ = std::fs::remove_dir_all(&dir);
+    let maps: Vec<&String> = keys.iter().filter(|k| k.as_str() == "List::map").collect();
+    assert_eq!(maps.len(), 1, "got {:?}", keys);
+    assert!(!keys.iter().any(|k| k.contains('$')), "mangled names remain");
+}