3f7586e | plum | pyrossh

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

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

3f7586e — Peter John 2026-10-26T11:44:55+05:30

feat(codegen)!: one compiled copy per generic instantiation, unboxed

Files changed (4) hide show

plum-checker/src/lib.rs +77 -9
plum-cli/src/main.rs +5 -2
plum-wasm-codegen/src/lib.rs +998 -746
plum-wasm-codegen/tests/codegen_tests.rs +207 -15

plum-checker/src/lib.rs CHANGED Viewed

@@ -23,6 +23,13 @@ thread_local! {
     static INST_MODE: Cell<bool> = const { Cell::new(false) };
     /// Line of the declaration currently being checked (the "called at" line of recorded calls).
     static CUR_LINE: Cell<usize> = const { Cell::new(0) };
+    /// Address of the expression `inferExprWith` is currently inferring (the innermost one).
+    static CUR_EXPR: Cell<usize> = const { Cell::new(0) };
+    /// While checking the last statement of a value-producing tail (an fn body's
+    /// final `if`/`match`/expression): the type that tail value must have, so its
+    /// generic arguments are pinned like a directly-returned expression's.
+    static TAIL: RefCell<Option<PlumType>> = const { RefCell::new(None) };
+    static MATCH_TAIL: RefCell<Option<PlumType>> = const { RefCell::new(None) };
 }
 /// A call to a generic fn/method seen in some body: callee identity plus the
@@ -33,9 +40,23 @@ struct CallSite {
     name: String,
     args: BTreeMap<String, PlumType>,
     line: usize,
+    /// Address of the call expression (or, for an implicit call, of the expression it is made on).
+    expr: usize,
+    /// A call codegen makes on its own (string interpolation's `toStr`), not written in source.
+    implicit: bool,
 }
 fn recordCall(recv: Option<&str>, name: &str, args: BTreeMap<String, PlumType>) {
+    recordCallAt(CUR_EXPR.with(|e| e.get()), false, recv, name, args);
+}
+fn recordCallAt(
+    expr: usize,
+    implicit: bool,
+    recv: Option<&str>,
+    name: &str,
+    args: BTreeMap<String, PlumType>,
+) {
     if args.is_empty() {
         return;
     }
@@ -46,6 +67,8 @@ fn recordCall(recv: Option<&str>, name: &str, args: BTreeMap<String, PlumType>)
                 name: name.to_string(),
                 args,
                 line: CUR_LINE.with(|l| l.get()),
+                expr,
+                implicit,
             });
         }
     });
@@ -69,6 +92,10 @@ pub struct TypedInfo {
     pub instantiations: Vec<Instantiation>,
     pub inst_expr_types: HashMap<(usize, usize), PlumType>,
     pub inst_index: HashMap<(String, Vec<PlumType>), usize>,
+    /// `(calling instantiation (None = a root fn), call expression address, implicit)` ->
+    /// the instantiation it calls. `implicit` marks calls codegen makes itself (the
+    /// `toStr` of a `"{x}"` interpolation, keyed by the interpolated expression).
+    pub call_inst: HashMap<(Option<usize>, usize, bool), usize>,
 }
 /// One reached instantiation of a generic fn or method of a generic type.
@@ -460,7 +487,15 @@ fn parseTagUnion(s: &str) -> Option<PlumType> {
             Some(p) => {
                 let name = seg[..p].trim().to_string();
                 let payload = seg[p + 1..].strip_suffix(')')?;
+                let payload = payload.trim();
+                let pty = if isGenericName(payload) {
+                    TSUBST
+                        .with(|s| s.borrow().as_ref().and_then(|m| m.get(payload).cloned()))
+                        .unwrap_or_else(|| PlumType::TParam(payload.to_string()))
+                } else {
+                    plumTypeFromName(payload)
+                };
-                tags.insert(name, Some(Box::new(plumTypeFromName(payload.trim()))));
+                tags.insert(name, Some(Box::new(pty)));
             }
             None => {
                 tags.insert(seg.to_string(), None);
@@ -1455,7 +1490,7 @@ fn drainCalls() -> Vec<CallSite> {
 /// Generic parameter names of `f`: its owner type's generics, then the free
 /// type parameters of its own signature. Empty = not generic.
-fn fnGenericNames(f: &ast::Fn, ctx: &CheckCtx) -> Vec<String> {
+pub fn fnGenericNames(f: &ast::Fn, ctx: &CheckCtx) -> Vec<String> {
     let mut names: Vec<String> = match &f.type_param {
         Some(r) => enumGenericsOf(r, ctx).to_vec(),
         None => Vec::new(),
@@ -1521,7 +1556,8 @@ fn registerCalls(
             None => cs.name.clone(),
         };
         let key = (item.clone(), args.clone());
-        if st.info.inst_index.contains_key(&key) {
+        if let Some(&existing) = st.info.inst_index.get(&key) {
+            st.info.call_inst.insert((parent, cs.expr, cs.implicit), existing);
             continue;
         }
         let id = st.info.instantiations.len();
@@ -1545,6 +1581,7 @@ fn registerCalls(
             called_at_line: cs.line,
         });
         st.info.inst_index.insert(key, id);
+        st.info.call_inst.insert((parent, cs.expr, cs.implicit), id);
         st.queue.push_back(id);
     }
 }
@@ -1686,7 +1723,11 @@ fn checkFn(
                 Some((ast::Stmt::Expr(e, line, column), init)) => (Some((e, *line, *column)), init),
                 _ => (None, &block.stmts[..]),
             };
+            let n_init = init.len();
-            for stmt in init {
+            for (i, stmt) in init.iter().enumerate() {
+                if tail.is_none() && i + 1 == n_init && !matches!(declared_ret, PlumType::TUnit) {
+                    TAIL.with(|c| *c.borrow_mut() = Some(declared_ret.clone()));
+                }
                 errors.append(&mut checkStmt(
                     stmt,
                     &mut env,
@@ -1730,7 +1771,11 @@ fn checkBlock(
     ctx: &CheckCtx,
 ) -> Vec<CheckError> {
     let mut errors = Vec::new();
+    let tail = TAIL.with(|t| t.borrow_mut().take());
+    for (i, stmt) in block.stmts.iter().enumerate() {
-    for stmt in &block.stmts {
+        if i + 1 == block.stmts.len() {
+            TAIL.with(|t| *t.borrow_mut() = tail.clone());
+        }
         let mut stmt_errors = checkStmt(stmt, env, declared_ret, fn_name, fn_pos, ctx);
         errors.append(&mut stmt_errors);
     }
@@ -1761,6 +1806,8 @@ fn checkStmt(
     ctx: &CheckCtx,
 ) -> Vec<CheckError> {
     let mut errors = Vec::new();
+    let tail = TAIL.with(|t| t.borrow_mut().take());
+    let set_tail = |t: &Option<PlumType>| TAIL.with(|c| *c.borrow_mut() = t.clone());
     match stmt {
         ast::Stmt::Assign(a) => {
             for (target, value) in a.targets.iter().zip(a.values.iter()) {
@@ -1881,6 +1928,7 @@ fn checkStmt(
                     format!("fn '{}': if condition: {}", fn_name, msg),
                 )),
             }
+            set_tail(&tail);
             errors.append(&mut checkBlock(
                 &if_.body,
                 env,
@@ -1909,7 +1957,8 @@ fn checkStmt(
                         format!("fn '{}': else if condition: {}", fn_name, msg),
                     )),
                 }
+                set_tail(&tail);
-                errors.append(&mut checkBlock(
+            errors.append(&mut checkBlock(
                     &ei.body,
                     env,
                     declared_ret,
@@ -1919,7 +1968,8 @@ fn checkStmt(
                 ));
             }
             if let Some(else_block) = &if_.else_ {
+                set_tail(&tail);
-                errors.append(&mut checkBlock(
+            errors.append(&mut checkBlock(
                     else_block,
                     env,
                     declared_ret,
@@ -1993,7 +2043,7 @@ fn checkStmt(
             ));
         }
         ast::Stmt::Expr(e, line, column) => {
-            if let Err(msg) = inferExpr(e, env, ctx) {
+            if let Err(msg) = inferExprWith(e, env, ctx, tail.as_ref()) {
                 errors.push(CheckError::at(
                     *line,
                     *column,
@@ -2018,6 +2068,7 @@ fn checkStmt(
             )),
         },
         ast::Stmt::Match(m) => {
+            MATCH_TAIL.with(|c| *c.borrow_mut() = tail.clone());
             errors.append(&mut checkMatch(m, env, declared_ret, fn_name, fn_pos, ctx));
         }
         ast::Stmt::Break | ast::Stmt::Continue | ast::Stmt::Todo => {}
@@ -2212,6 +2263,7 @@ fn checkMatch(
     fn_pos: (usize, usize),
     ctx: &CheckCtx,
 ) -> Vec<CheckError> {
+    let match_tail = MATCH_TAIL.with(|c| c.borrow_mut().take());
     let mut errors = Vec::new();
     let mut subject_types: Vec<PlumType> = Vec::new();
@@ -2297,6 +2349,7 @@ fn checkMatch(
                 )),
             }
         }
+        TAIL.with(|c| *c.borrow_mut() = match_tail.clone());
         errors.append(&mut checkBlock(
             &case.body,
             &mut case_env,
@@ -3055,7 +3108,9 @@ pub fn inferExprWith(
     ctx: &CheckCtx,
     expected: Option<&PlumType>,
 ) -> Result<PlumType, String> {
+    let prev = CUR_EXPR.with(|c| c.replace(expr as *const ast::Expr as usize));
     let r = inferExprInner(expr, env, ctx, expected);
+    CUR_EXPR.with(|c| c.set(prev));
     if let Ok(t) = &r {
         recordType(expr, t);
     }
@@ -3079,7 +3134,20 @@ fn inferExprInner(
             // were never part of this check.
             for part in &s.parts {
                 if let ast::StringPart::Interp(e) = part {
-                    let _ = inferExprWith(e, env, ctx, None);
+                    if let Ok(PlumType::TApp(n, targs)) = inferExprWith(e, env, ctx, None) {
+                        let gens = enumGenericsOf(&n, ctx);
+                        if gens.len() == targs.len()
+                            && ctx.methods.contains_key(&(n.clone(), "toStr".to_string()))
+                        {
+                            recordCallAt(
+                                e as *const ast::Expr as usize,
+                                true,
+                                Some(&n),
+                                "toStr",
+                                appSubst(gens, &targs),
+                            );
+                        }
+                    }
                 }
             }
             Ok(PlumType::TStr)

plum-cli/src/main.rs CHANGED Viewed

@@ -774,7 +774,7 @@ fn cmdRun(file: std::path::PathBuf, lib_path: std::path::PathBuf) -> Result<()>
         .map_err(|e| anyhow::anyhow!("failed to construct wasmtime engine: {e}"))?;
     let module = wasmtime::Module::new(&engine, &wasm_bytes)
-        .map_err(|e| anyhow::anyhow!("compiled wasm failed to load: {e}"))?;
+        .map_err(|e| anyhow::anyhow!("compiled wasm failed to load: {e:#}"))?;
     let mut store = wasmtime::Store::new(&engine, ());
     let imports = hostImports(&mut store, &module)?;
     let instance = wasmtime::Instance::new(&mut store, &module, &imports)
@@ -913,6 +913,9 @@ fn cmdTest(paths: Vec<std::path::PathBuf>, lib_path: std::path::PathBuf) -> Resu
 /// the single-file and directory-recursive paths of `cmdTest`.
 fn runTestFile(file: &std::path::Path, lib_path: &std::path::Path) -> Result<(usize, usize)> {
     let (wasm_bytes, names) = compileToTestWasm(file, lib_path)?;
+    if let Ok(path) = std::env::var("PLUM_DUMP_WASM") {
+        let _ = std::fs::write(path, &wasm_bytes);
+    }
     let mut config = wasmtime::Config::new();
     config.wasm_gc(true);
@@ -921,7 +924,7 @@ fn runTestFile(file: &std::path::Path, lib_path: &std::path::Path) -> Result<(us
         .map_err(|e| anyhow::anyhow!("failed to construct wasmtime engine: {e}"))?;
     let module = wasmtime::Module::new(&engine, &wasm_bytes)
-        .map_err(|e| anyhow::anyhow!("compiled wasm failed to load: {e}"))?;
+        .map_err(|e| anyhow::anyhow!("compiled wasm failed to load: {e:#}"))?;
     let mut store = wasmtime::Store::new(&engine, ());
     let imports = hostImports(&mut store, &module)?;
     let instance = wasmtime::Instance::new(&mut store, &module, &imports)

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

@@ -48,6 +48,7 @@ pub struct WasmModule {
     pub func_count: u32,
     global_count: u32,
     start_function: Option<u32>,
+    func_names: Vec<(u32, String)>,
 }
 impl WasmModule {
@@ -65,6 +66,7 @@ impl WasmModule {
             func_count: 0,
             global_count: 0,
             start_function: None,
+            func_names: Vec::new(),
         }
     }
@@ -107,6 +109,11 @@ impl WasmModule {
         idx
     }
+    /// Records a debug name for function `idx` (wasm `name` section).
+    pub fn nameFunction(&mut self, idx: u32, name: &str) {
+        self.func_names.push((idx, name.to_string()));
+    }
     pub fn addExport(&mut self, name: &str, kind: ExportKind, idx: u32) {
         self.exports.push((name.to_string(), kind, idx));
     }
@@ -294,6 +301,19 @@ impl WasmModule {
             module.section(&data);
         }
+        if !self.func_names.is_empty() {
+            let mut names = wasm_encoder::NameSection::new();
+            let mut map = wasm_encoder::NameMap::new();
+            let mut sorted = self.func_names.clone();
+            sorted.sort_by_key(|(i, _)| *i);
+            sorted.dedup_by_key(|(i, _)| *i);
+            for (i, n) in &sorted {
+                map.append(*i, n);
+            }
+            names.functions(&map);
+            module.section(&names);
+        }
         module.finish()
     }
 }
@@ -356,33 +376,37 @@ pub struct ClosureInfo {
 /// `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 = usize;
+type ClosureSigKey = (Vec<ValType>, Option<ValType>);
 /// Global, read-only lookup tables shared by every function body being compiled.
 pub struct CompileCtx<'a> {
     pub func_ids: HashMap<String, u32>,
     pub func_sigs: HashMap<String, FuncSig>,
+    /// Instantiation id -> its wasm function and signature.
+    pub inst_funcs: HashMap<usize, (u32, FuncSig)>,
+    /// See `plum_checker::TypedInfo::call_inst`.
+    pub call_inst: HashMap<(Option<usize>, usize, bool), usize>,
+    /// Every free (non-method) fn name, generic or not.
+    pub known_fns: HashSet<String>,
+    pub eg: EnumGenerics,
     pub methods: MethodEnv,
     pub enum_variants: EnumVariants,
     pub enum_params: EnumParams,
     pub min_required: plum_checker::MinRequiredArgs,
     pub global_env: TypeEnv,
     /// Closure literal (keyed by `&Expr::Closure` pointer identity) -> its `ClosureInfo`.
-    pub closures: HashMap<usize, ClosureInfo>,
+    pub closures: HashMap<(usize, usize), ClosureInfo>,
     /// 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>,
+    pub closure_asts: HashMap<(usize, usize), &'a ast::Closure>,
     /// Closure arity -> the erased `call_indirect` function-type index.
     pub closure_call_types: HashMap<ClosureSigKey, u32>,
-    /// Instantiated type of every expression of the original 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
     /// struct has no captures it never changes, so it's built once by the shared
     /// `start` function instead of being reconstructed per reference.
-    pub named_fn_values: HashMap<String, u32>,
+    pub named_fn_values: HashMap<(String, PlumType), u32>,
     /// Shared runtime helper `(a: ref Str, b: ref Str) -> ref Str`: allocates a new
     /// `array<i8>` exactly long enough to hold `a`'s bytes followed by `b`'s, for
     /// lowering string interpolation (`"{expr}"`).
@@ -403,7 +427,7 @@ pub struct CompileCtx<'a> {
     pub gc_types: GcTypeRegistry,
     /// Payload-free variant name (True/False/End/...) -> the global index holding
     /// its one pre-allocated instance (see this migration plan's Decision 2).
-    pub singleton_globals: HashMap<String, u32>,
+    pub singleton_globals: HashMap<(PlumType, String), u32>,
 }
 /// Per-module state that accumulates as function bodies are compiled: every static
@@ -435,14 +459,20 @@ struct LocalCtx<'a> {
     variadic_for_scratch: HashMap<usize, u32>,
     func_ids: &'a HashMap<String, u32>,
     func_sigs: &'a HashMap<String, FuncSig>,
+    inst_funcs: &'a HashMap<usize, (u32, FuncSig)>,
+    call_inst: &'a HashMap<(Option<usize>, usize, bool), usize>,
+    known_fns: &'a HashSet<String>,
+    /// Index of the unit being compiled (closures are keyed by it) and its instantiation.
+    unit_idx: usize,
+    unit_inst: Option<usize>,
     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>,
+    closures: &'a HashMap<(usize, usize), ClosureInfo>,
     closure_call_types: &'a HashMap<ClosureSigKey, u32>,
-    named_fn_values: &'a HashMap<String, u32>,
+    named_fn_values: &'a HashMap<(String, PlumType), u32>,
     string_concat_func: u32,
     string_eq_func: u32,
     dyn_eq_func: u32,
@@ -452,7 +482,7 @@ struct LocalCtx<'a> {
     enum_params: &'a EnumParams,
     min_required: &'a plum_checker::MinRequiredArgs,
     gc_types: &'a GcTypeRegistry,
-    singleton_globals: &'a HashMap<String, u32>,
+    singleton_globals: &'a HashMap<(PlumType, String), u32>,
     /// Tracks each binding's inferred type as compilation proceeds through
     /// statements in order, mirroring `plum-checker`'s own env evolution — needed
     /// to resolve `Attribute`/`ClassCall` targets and pick the right load/store width.
@@ -847,27 +877,17 @@ fn withGcTypes<R>(f: impl FnOnce(&GcTypeRegistry) -> R) -> R {
     })
 }
-/// A constructor-pattern name (`nested_class_scratch_types`'s recorded name, or any
-/// other spot a pattern's own concrete GC type index is needed) is always an enum
+/// GC type index of a pattern/`?` scratch local: variant `vname` of enum type `ty`,
-/// variant — falls back to `class_type_idx` only for the record-shaped alias case
-/// (see `buildGcTypeRegistry`'s own alias comment), which `variant_type_idx` should
-/// already cover directly; kept as a defensive second lookup.
+/// or (empty `vname`) the enum's own supertype.
-fn classOrVariantTypeIdx(r: &GcTypeRegistry, name: &str) -> u32 {
+fn scratchTypeIdx(r: &GcTypeRegistry, ty: &PlumType, vname: &str) -> u32 {
+    let found = if vname.is_empty() {
+        r.superIdx(ty).or_else(|| r.classIdx(ty))
+    } else {
-    *r.variant_type_idx
+        r.variantIdx(ty, vname)
-        .get(name)
+    };
-        .or_else(|| r.class_type_idx.get(name))
-        // A scratch slot narrowed to a MULTI-variant enum's own wide supertype
-        // (not any one variant) — the `?` operator's scratch local holds the
-        // subject at its natural (possibly multi-variant, e.g. `Try`)
-        // type, never narrower, since it ref.casts to whichever of the two
-        // variants applies only at the point of use, not up front.
-        .or_else(|| r.enum_super_type_idx.get(name))
-        .unwrap_or_else(|| {
+    found.unwrap_or_else(|| {
-            panic!(
-                "internal codegen error: '{}' missing from the GC type registry",
+        panic!("internal codegen error: '{}' of {} missing from the GC type registry", vname, ty)
-                name
-            )
-        })
+    })
 }
 /// Resolves an `ast::Type`/`ast::ParamType`'s bare name (e.g. from a function
@@ -927,54 +947,7 @@ fn pushSelfPlaceholder(vt: ValType, body: &mut Vec<u8>) {
 }
 fn plumTypeToValtype(t: &PlumType) -> ValType {
-    match t {
-        PlumType::TApp(n, _) => plumTypeToValtype(&PlumType::TNamed(n.clone())),
-        PlumType::TInt => ValType::I64,
-        PlumType::TFloat => ValType::F64,
-        PlumType::TBool => ValType::I32,
-        // `Str` is an ORDINARY class (`type Str(...) = data: Buffer ...` in
-        // `str.plum`) — its own real struct type, registered exactly like any
-        // other class (see `buildGcTypeRegistry`'s `Slot::Class` handling),
-        // NOT the raw `byte_array_type_idx` (that's `Buffer`'s own `data`
-        // field's type, two levels down) — except when `Str` was never
-        // actually declared at all (an isolated snippet/unit test that never
-        // went through `plum-core::loader::loadAndMerge`'s `std/str` prelude),
-        // where `strGcValtypeOrFallback` falls back to treating `Str` as
-        // that raw array directly, matching this function's pre-refactor
-        // behavior.
-        PlumType::TStr => withGcTypes(strGcValtypeOrFallback),
-        PlumType::TByte => ValType::I32,
-        // `[]Byte` is represented by the EXACT SAME wasm-gc array type as `Str`
-        // (a mutable `array<i8>`) — they're structurally identical, and nothing
-        // in this codegen needs to distinguish them at the wasm-type level
-        // (no runtime `ref.test`/dynamic dispatch keys off it), so reusing
-        // `byte_array_type_idx` avoids a second, redundant GC type-section entry.
-        PlumType::TByteSlice => withGcTypes(|r| gcRef(r.byte_array_type_idx)),
-        PlumType::TNamed(name) => withGcTypes(|r| {
-            match r
-                .class_type_idx
-                .get(name)
-                .or_else(|| r.enum_super_type_idx.get(name))
-            {
-                Some(idx) => gcRef(*idx),
-                // Genuinely unmodeled type name (not a real class/enum) — permissive
-                // fallback, matching this function's pre-wasm-gc "unmodeled type:
-                // pointer" behavior; codegen sites that actually need a concrete
-                // struct type still resolve it themselves and error clearly if absent.
-                None => ValType::Ref(RefType::ANYREF),
-            }
-        }),
-        // A closure value is a 2-field `{table_index: i32, env: anyref}` struct —
-        // its OWN concrete GC type, registered per Task 2e (closures), not through
-        // this general resolver; `anyref` here is a safe placeholder used only
-        // where a closure's exact struct type isn't being constructed/destructured
-        // directly (e.g. deciding a local's storage class), matching `TVariadic`'s
-        // 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::TUnit => ValType::I64,
+    withGcTypes(|r| plumTypeToGcValtype(t, r))
-    }
 }
 /// Type-section indices for every wasm-gc composite type this program's
@@ -992,6 +965,17 @@ pub struct GcTypeRegistry {
     /// Variant name (flat namespace, matching `EnumVariants`) -> its concrete
     /// subtype `struct` type index.
     pub variant_type_idx: HashMap<String, u32>,
+    /// Concrete instance of a generic enum (`List[Int]`) -> its supertype index
+    /// (for `Array[T]`: the native array type of `T`'s representation).
+    pub app_super: HashMap<PlumType, u32>,
+    /// Record-shaped generic enum instance -> its one variant's struct index.
+    pub app_class: HashMap<PlumType, u32>,
+    /// (generic enum instance, variant name) -> variant struct index.
+    pub app_variant: HashMap<(PlumType, String), u32>,
+    /// Every registered enum instance (`TNamed` for non-generic, `TApp` for generic).
+    pub instances: Vec<PlumType>,
+    /// Names of every declared enum.
+    pub known_enums: HashSet<String>,
     /// The single shared `array<i8>` type index `[]Byte`/`Buffer`'s own
     /// `data` field use — NOT `Str`'s own representation (`Str` is an
     /// ordinary class, `data: Buffer`; see `libs/std/Str.plum`'s header).
@@ -1039,6 +1023,36 @@ pub struct GcTypeRegistry {
     pub dyn_fns: HashMap<(String, String), u32>,
 }
+impl GcTypeRegistry {
+    /// Supertype struct index of enum type `ty` (`TNamed` or `TApp`).
+    pub fn superIdx(&self, ty: &PlumType) -> Option<u32> {
+        match ty {
+            PlumType::TNamed(n) => self
+                .enum_super_type_idx
+                .get(n)
+                .or_else(|| self.class_type_idx.get(n))
+                .copied(),
+            PlumType::TApp(..) => self.app_super.get(ty).copied(),
+            _ => None,
+        }
+    }
+    /// Struct index of the class-like (record-shaped) type `ty`.
+    pub fn classIdx(&self, ty: &PlumType) -> Option<u32> {
+        match ty {
+            PlumType::TNamed(n) => self.class_type_idx.get(n).copied(),
+            PlumType::TApp(..) => self.app_class.get(ty).copied(),
+            _ => None,
+        }
+    }
+    /// Struct index of variant `vname` of enum type `ty`.
+    pub fn variantIdx(&self, ty: &PlumType, vname: &str) -> Option<u32> {
+        match ty {
+            PlumType::TApp(..) => self.app_variant.get(&(ty.clone(), vname.to_string())).copied(),
+            _ => self.variant_type_idx.get(vname).copied(),
+        }
+    }
+}
 /// Box type ids (see the plan's Global constraints): 0 is `$Obj` itself.
 pub const TYPE_ID_BOX_I64: i32 = 1;
 pub const TYPE_ID_BOX_F64: i32 = 2;
@@ -1082,45 +1096,27 @@ fn isArraySpecialization(name: &str) -> bool {
 /// structure: this function is only ever called during its second pass).
 fn plumTypeToGcValtype(t: &PlumType, registry: &GcTypeRegistry) -> ValType {
     match t {
-        PlumType::TApp(n, _) => plumTypeToGcValtype(&PlumType::TNamed(n.clone()), registry),
+        PlumType::TApp(n, _) => match registry.classIdx(t).or_else(|| registry.superIdx(t)) {
+            Some(idx) => gcRef(idx),
+            None if hasFreeTy(t) || !registry.known_enums.contains(n) => {
+                ValType::Ref(RefType::ANYREF)
+            }
+            None => panic!("internal codegen error: type {} was not registered", t),
+        },
         PlumType::TInt => ValType::I64,
         PlumType::TFloat => ValType::F64,
         PlumType::TBool => ValType::I32,
-        // See the matching comment in `plumTypeToValtype` — `Str` is an
-        // ordinary class's own real struct type, not the raw
-        // `byte_array_type_idx`, except when `Str` was never actually
-        // declared at all (`strGcValtypeOrFallback`'s fallback case).
         PlumType::TStr => strGcValtypeOrFallback(registry),
         PlumType::TByte => ValType::I32,
-        // See the matching comment in `plumTypeToValtype` — `[]Byte` reuses
-        // `Buffer`'s own `array<i8>` GC type index rather than getting its own.
-        PlumType::TByteSlice => ValType::Ref(RefType {
-            nullable: true,
-            heap_type: HeapType::Concrete(registry.byte_array_type_idx),
+        PlumType::TByteSlice => gcRef(registry.byte_array_type_idx),
-        }),
         PlumType::TNamed(name) => match registry
             .class_type_idx
             .get(name)
             .or_else(|| registry.enum_super_type_idx.get(name))
         {
-            Some(idx) => ValType::Ref(RefType {
+            Some(idx) => gcRef(*idx),
-                nullable: true,
-                heap_type: HeapType::Concrete(*idx),
-            }),
-            // A field typed as a generic enum (e.g. `Node.next: Link[Node]`)
-            // resolves here to the BARE generic name — `plumTypeFromAst`
-            // has no representation for type arguments, so it can't know this means
-            // `Link[Int]` rather than bare `Link` (erased generics keep one
-            // compiled `Link`) — same permissive `anyref` fallback as
-            // `plumTypeToValtype` above, for the same "genuinely unmodeled" reason:
-            // `struct.get`/`ref.test`/`ref.cast` all work against `anyref` operands
-            // fine, so a field merely being STORED as `anyref` instead of the exact
-            // concrete type costs nothing but static precision.
             None => ValType::Ref(RefType::ANYREF),
         },
-        // TFun (closures) and TVariadic get their own concrete representation once
-        // Task 2 (closures/variadic calls) lands — `anyref` is a safe, valid-but-not-
-        // 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),
@@ -1128,86 +1124,92 @@ fn plumTypeToGcValtype(t: &PlumType, registry: &GcTypeRegistry) -> ValType {
     }
 }
+/// Free type variables / generic parameters anywhere inside `t`.
+fn hasFreeTy(t: &PlumType) -> bool {
+    match t {
+        PlumType::TVar(_) | PlumType::TParam(_) => true,
+        PlumType::TApp(_, a) => a.iter().any(hasFreeTy),
+        PlumType::TFun(ps, r) => ps.iter().any(hasFreeTy) || hasFreeTy(r),
+        PlumType::TVariadic(i) => hasFreeTy(i),
+        PlumType::TTags(m) => m.values().flatten().any(|t| hasFreeTy(t)),
+        _ => false,
+    }
+}
+fn arrayDepth(t: &PlumType) -> usize {
+    match t {
+        PlumType::TApp(n, a) => {
+            usize::from(isArraySpecialization(n)) + a.iter().map(arrayDepth).max().unwrap_or(0)
+        }
+        _ => 0,
+    }
+}
-/// Builds the wasm-gc type registry for every concrete enum actually declared in
+/// Builds the wasm-gc type registry: one struct family per non-generic enum and per
-/// `source` (`Bool`/`Str`/etc included, but only if imported — no builtin is
-/// hardcoded here), plus the shared raw byte-array type, and declares them all as
-/// ONE `rec` group via `module.addGcTypes` — a single group sidesteps every ordering
-/// question about mutual/self-references (a record-shaped enum's field naming
-/// another such enum's type, an enum variant field referencing its own enum,
-/// `Node.next: Link[Node]`, etc.), since within one `rec` group members may
+/// distinct concrete instance (`apps`, e.g. `List[Int]`) of a generic enum, keyed by
+/// the structural `PlumType`; `Array[T]` instances become native wasm arrays of `T`'s
-/// reference each other regardless of declaration order.
+/// representation. Everything is declared as ONE `rec` group.
 fn buildGcTypeRegistry(
     module: &mut WasmModule,
     source: &ast::Source,
     enum_variants: &EnumVariants,
     enum_params: &EnumParams,
+    apps: &[PlumType],
 ) -> GcTypeRegistry {
     enum Slot {
         Str,
-        /// `$Obj {typeId: i32}` — supertype of every struct below.
         Obj,
-        EnumSuper(String),
+        EnumSuper(PlumType),
-        Variant(String),
+        Variant(PlumType, String),
-        /// The single shared `array<anyref>` type every `Array[T]`
-        /// aliases — see `isArraySpecialization`.
-        ArrayRef,
+        ArrayRef(ValType),
         Tag,
         BoxI64,
         BoxF64,
         BoxI32,
         BoxBool,
     }
-    // Pass 1: assign every entry a slot (and therefore a type index) up front, before
-    // any field list is built, so field-type resolution can reference ANY other entry.
     let mut slots: Vec<Slot> = vec![Slot::Str, Slot::Obj];
     let obj_type_idx: u32 = 1;
+    let mut reg = GcTypeRegistry {
+        class_type_idx: HashMap::new(),
+        enum_super_type_idx: HashMap::new(),
-    let mut type_ids: HashMap<String, i32> = HashMap::new();
+        variant_type_idx: HashMap::new(),
+        app_super: HashMap::new(),
+        app_class: HashMap::new(),
+        app_variant: HashMap::new(),
+        instances: Vec::new(),
+        known_enums: HashSet::new(),
+        byte_array_type_idx: 0,
+        closure_type_idx: 0,
+        variadic_array_type_idx: HashMap::new(),
+        array_type_idx: 0,
+        tag_type_idx: 0,
+        box_i64_idx: 0,
+        box_f64_idx: 0,
+        box_i32_idx: 0,
+        box_bool_idx: 0,
+        obj_type_idx,
+        type_ids: HashMap::new(),
+        box_i64_fn: 0,
+        box_f64_fn: 0,
+        box_i32_fn: 0,
+        box_bool_fn: 0,
+        mk_str_fn: None,
+        dyn_fns: HashMap::new(),
+    };
     let mut next_type_id = TYPE_ID_FIRST_DECLARED;
-    let mut class_type_idx: HashMap<String, u32> = HashMap::new();
+    let mut enum_decls: HashMap<String, &ast::Enum> = HashMap::new();
-    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;
-    // `Bool` is an ordinary enum now (`type Bool = | True | False` in
-    // `libs/std/Bool.plum`) — registered exactly like any other enum
-    // declared in `source.items`, present only if actually imported.
-    let mut enum_decls: Vec<(String, Vec<String>)> = Vec::new();
+    let mut instances: Vec<PlumType> = Vec::new();
     for item in &source.items {
-        if let ast::Item::Enum(e) = item {
+        if let ast::Item::Trait(t) = item {
-            enum_decls.push((
-                e.name.clone(),
-                e.variants.iter().map(|v| v.name.clone()).collect(),
+            reg.class_type_idx.insert(t.name.clone(), obj_type_idx);
-            ));
         }
     }
-    // A trait name used as a type lowers to `ref null $Obj`.
     for item in &source.items {
-        if let ast::Item::Trait(t) = item {
+        let ast::Item::Enum(e) = item else { continue };
-            class_type_idx.insert(t.name.clone(), obj_type_idx);
-        }
-    }
-    for (enum_name, variant_names) in &enum_decls {
-        // `Array`/`Array$T` is a RECORD-shaped enum (single variant sharing the
-        // enum's own name — the `type Array[T] = ...` replacement) whose values
-        // are ALL represented by the one shared `array<anyref>` type regardless
-        // of `T` (see `isArraySpecialization`'s own doc comment) — alias its
-        // enum/variant/class names onto that single existing slot instead of
-        // giving it its own real struct type.
-        if isArraySpecialization(enum_name) {
-            let idx = *array_ref_slot.get_or_insert_with(|| {
-                let idx = slots.len() as u32;
-                slots.push(Slot::ArrayRef);
-                idx
-            });
-            enum_super_type_idx.insert(enum_name.clone(), idx);
+        enum_decls.insert(e.name.clone(), e);
-            class_type_idx.insert(enum_name.clone(), idx);
-            for vname in variant_names {
-                variant_type_idx.insert(vname.clone(), idx);
+        reg.known_enums.insert(e.name.clone());
-            }
-            continue;
-        }
-        let this_id = match enum_name.as_str() {
+        let this_id = match e.name.as_str() {
             "Str" => TYPE_ID_STR,
             "Buffer" => TYPE_ID_BUFFER,
             _ => {
@@ -1216,67 +1218,101 @@ fn buildGcTypeRegistry(
                 id
             }
         };
-        type_ids.insert(enum_name.clone(), this_id);
+        reg.type_ids.insert(e.name.clone(), this_id);
-        for vname in variant_names {
+        for v in &e.variants {
-            type_ids.insert(vname.clone(), this_id);
+            reg.type_ids.insert(v.name.clone(), this_id);
         }
-        enum_super_type_idx.insert(enum_name.clone(), slots.len() as u32);
+        if e.generics.is_empty() && !isArraySpecialization(&e.name) {
-        slots.push(Slot::EnumSuper(enum_name.clone()));
-        for vname in variant_names {
-            variant_type_idx.insert(vname.clone(), slots.len() as u32);
-            slots.push(Slot::Variant(vname.clone()));
+            instances.push(PlumType::TNamed(e.name.clone()));
         }
-        // A RECORD-shaped enum (the `type X = ...` replacement, e.g. `enum Cat =
-        // | Cat(name: Str)`) also gets a `class_type_idx` alias onto its one
+    }
-        // variant's real struct slot — `plumTypeToValtype`'s `TNamed(name)` arm
-        // resolves a value of this type via `class_type_idx` (checked first,
-        // falling back to `enum_super_type_idx`), and every OTHER codegen site
-        // that already looks up a "class" by this exact name (field access,
+    let mut arrays: Vec<PlumType> = Vec::new();
+    for a in apps {
-        // construction, pattern destructuring, ...) keeps working unchanged.
+        if let PlumType::TApp(n, _) = a {
+            if isArraySpecialization(n) {
+                arrays.push(a.clone());
-        if variant_names.len() == 1 && variant_names[0] == *enum_name {
+            } else if enum_decls.contains_key(n) && !instances.contains(a) {
-            class_type_idx.insert(enum_name.clone(), variant_type_idx[&variant_names[0]]);
+                instances.push(a.clone());
+            }
         }
     }
+    for ty in &instances {
+        let n = plum_checker::nominalName(ty).unwrap().to_string();
+        let e = enum_decls[&n];
+        let super_idx = slots.len() as u32;
+        slots.push(Slot::EnumSuper(ty.clone()));
+        match ty {
+            PlumType::TNamed(_) => {
+                reg.enum_super_type_idx.insert(n.clone(), super_idx);
+            }
+            _ => {
+                reg.app_super.insert(ty.clone(), super_idx);
+            }
+        }
+        for v in &e.variants {
+            let idx = slots.len() as u32;
+            slots.push(Slot::Variant(ty.clone(), v.name.clone()));
+            match ty {
+                PlumType::TNamed(_) => {
+                    reg.variant_type_idx.insert(v.name.clone(), idx);
+                }
+                _ => {
+                    reg.app_variant.insert((ty.clone(), v.name.clone()), idx);
+                }
+            }
+            if e.variants.len() == 1 && v.name == n {
+                match ty {
+                    PlumType::TNamed(_) => {
+                        reg.class_type_idx.insert(n.clone(), idx);
+                    }
+                    _ => {
+                        reg.app_class.insert(ty.clone(), idx);
+                    }
+                }
+            }
+        }
+    }
+    reg.instances = instances.clone();
-    let tag_type_idx = slots.len() as u32;
+    reg.tag_type_idx = slots.len() as u32;
     slots.push(Slot::Tag);
-    let box_i64_idx = slots.len() as u32;
+    reg.box_i64_idx = slots.len() as u32;
     slots.push(Slot::BoxI64);
-    let box_f64_idx = slots.len() as u32;
+    reg.box_f64_idx = slots.len() as u32;
     slots.push(Slot::BoxF64);
-    let box_i32_idx = slots.len() as u32;
+    reg.box_i32_idx = slots.len() as u32;
     slots.push(Slot::BoxI32);
-    let box_bool_idx = slots.len() as u32;
+    reg.box_bool_idx = slots.len() as u32;
     slots.push(Slot::BoxBool);
-    // The registry is fully index-complete after pass 1 (every name has an assigned
+    // Native arrays: one wasm array type per distinct element representation,
-    // slot) even though no field lists exist yet — safe to hand to `plumTypeToGcValtype`
-    // for pass 2's field-type resolution.
+    // innermost (least nested) element types first.
-    let registry = GcTypeRegistry {
+    arrays.sort_by_key(arrayDepth);
-        class_type_idx,
-        enum_super_type_idx,
-        variant_type_idx,
-        byte_array_type_idx: 0,
-        closure_type_idx: 0,
-        variadic_array_type_idx: HashMap::new(),
+    let mut by_vt: HashMap<ValType, u32> = HashMap::new();
+    for a in &arrays {
+        let PlumType::TApp(_, args) = a else { continue };
+        let vt = plumTypeToGcValtype(&args[0], &reg);
-        array_type_idx: array_ref_slot.unwrap_or(0),
+        let idx = *by_vt.entry(vt).or_insert_with(|| {
-        tag_type_idx,
-        box_i64_idx,
-        box_f64_idx,
-        box_i32_idx,
-        box_bool_idx,
-        obj_type_idx,
-        type_ids,
-        box_i64_fn: 0,
-        box_f64_fn: 0,
-        box_i32_fn: 0,
-        box_bool_fn: 0,
-        mk_str_fn: None,
+            let idx = slots.len() as u32;
-        dyn_fns: HashMap::new(),
+            slots.push(Slot::ArrayRef(vt));
+            idx
-    };
+        });
+        reg.app_super.insert(a.clone(), idx);
+        reg.app_class.insert(a.clone(), idx);
+        reg.app_variant.insert((a.clone(), "Array".to_string()), idx);
+    }
+    let enum_generics = |n: &str| -> Vec<String> {
+        enum_decls
+            .get(n)
+            .map(|e| e.generics.iter().map(|g| g.name.clone()).collect())
+            .unwrap_or_default()
+    };
-    // Pass 2: build the real SubType for every slot, now that every cross-reference
+    let subst_for = |ty: &PlumType| -> std::collections::BTreeMap<String, PlumType> {
+        match ty {
+            PlumType::TApp(n, args) => enum_generics(n).into_iter().zip(args.iter().cloned()).collect(),
-    // resolves.
+            _ => Default::default(),
+        }
+    };
     let subtypes: Vec<SubType> = slots
         .iter()
         .map(|slot| match slot {
@@ -1291,20 +1327,16 @@ fn buildGcTypeRegistry(
                     shared: false,
                 },
             },
-            // An ORDINARY enum's supertype declares zero fields (each variant adds its
-            // own distinct payload fields below it). A DISCRIMINANT enum (`enum
-            // Foo(n: Int) = ...`) is different: every variant shares the EXACT SAME
-            // field list (`plum-checker::buildGlobalTables` already gives every variant
-            // of such an enum identical `field_types`, equal to the shared params), so
-            // the supertype declares those fields directly — this is what lets `self.n`
-            // field access work on the plain supertype-typed reference with a
-            // `struct.get`, no `ref.cast` to one arbitrary variant required (which would
-            // trap at runtime whenever `self` isn't actually THAT variant).
-            Slot::EnumSuper(enum_name) => {
+            Slot::EnumSuper(ty) => {
+                let n = plum_checker::nominalName(ty).unwrap();
+                let s = subst_for(ty);
-                let params = enum_params.get(enum_name).cloned().unwrap_or_default();
+                let params = enum_params.get(n).cloned().unwrap_or_default();
                 let mut field_types: Vec<FieldType> = vec![typeIdField()];
-                field_types.extend(params.iter().map(|(_, ty)| FieldType {
+                field_types.extend(params.iter().map(|(_, fty)| FieldType {
-                    element_type: StorageType::Val(plumTypeToGcValtype(ty, &registry)),
+                    element_type: StorageType::Val(plumTypeToGcValtype(
+                        &plum_checker::types::substitute(fty, &s),
+                        &reg,
+                    )),
                     mutable: true,
                 }));
                 SubType {
@@ -1318,29 +1350,14 @@ fn buildGcTypeRegistry(
                     },
                 }
             }
-            Slot::Variant(vname) => {
+            Slot::Variant(ty, vname) => {
                 let info = enum_variants.get(vname).unwrap_or_else(|| {
-                    panic!(
-                        "internal codegen error: variant '{}' missing from EnumVariants",
+                    panic!("internal codegen error: variant '{}' missing from EnumVariants", vname)
-                        vname
-                    )
                 });
-                let super_idx = *registry
-                    .enum_super_type_idx
-                    .get(&info.enum_name)
-                    .unwrap_or_else(|| {
-                        panic!(
-                            "internal codegen error: enum '{}' missing its supertype slot",
+                let super_idx = reg.superIdx(ty).expect("enum supertype slot");
-                            info.enum_name
-                        )
-                    });
-                // For a discriminant enum, `info.field_types` is ALREADY identical to the
-                // supertype's own fields (see the `EnumSuper` arm above) — a variant with
-                // zero ADDED fields beyond its supertype is still valid wasm-gc
-                // subtyping, so no special-casing is needed here.
                 let mut field_types: Vec<FieldType> = vec![typeIdField()];
-                field_types.extend(info.field_types.iter().map(|ty| FieldType {
+                field_types.extend(plum_checker::variantFields(info, ty).iter().map(|fty| FieldType {
-                    element_type: StorageType::Val(plumTypeToGcValtype(ty, &registry)),
+                    element_type: StorageType::Val(plumTypeToGcValtype(fty, &reg)),
                     mutable: true,
                 }));
                 SubType {
@@ -1389,12 +1406,12 @@ fn buildGcTypeRegistry(
             Slot::BoxF64 => boxSubType(ValType::F64, obj_type_idx),
             Slot::BoxI32 => boxSubType(ValType::I32, obj_type_idx),
             Slot::BoxBool => boxSubType(ValType::I32, obj_type_idx),
-            Slot::ArrayRef => SubType {
+            Slot::ArrayRef(vt) => SubType {
                 is_final: true,
                 supertype_idx: None,
                 composite_type: CompositeType {
                     inner: CompositeInnerType::Array(ArrayType(FieldType {
-                        element_type: StorageType::Val(ValType::Ref(RefType::ANYREF)),
+                        element_type: StorageType::Val(*vt),
                         mutable: true,
                     })),
                     shared: false,
@@ -1402,10 +1419,8 @@ fn buildGcTypeRegistry(
             },
         })
         .collect();
     module.addGcTypes(subtypes);
-    registry
+    reg
 }
 /// The immutable `typeId: i32` header field every `$Obj` subtype starts with.
@@ -1440,9 +1455,6 @@ fn blockTypeFor(result_vt: Option<ValType>) -> BlockType {
     result_vt.map(BlockType::Result).unwrap_or(BlockType::Empty)
 }
-fn retTypeToWasm(ret: Option<&ast::Type>) -> Option<ValType> {
-    ret.and_then(|r| astTypeToWasm(&r.name))
-}
 fn encodeLeb128U32(mut val: u32) -> Vec<u8> {
     let mut bytes = Vec::new();
@@ -1752,18 +1764,305 @@ fn desugarAssertStmt(stmt: &ast::Stmt) -> ast::Stmt {
     }
 }
+/// One function body to compile: a non-generic fn (`inst: None`) or one concrete
+/// instantiation of a generic fn / method of a generic type.
+struct UnitDef<'a> {
+    f: &'a ast::Fn,
+    inst: Option<usize>,
+    subst: std::collections::BTreeMap<String, PlumType>,
+    /// Debug name in the wasm name section.
+    name: String,
+}
+type Subst = std::collections::BTreeMap<String, PlumType>;
+type EnumGenerics = HashMap<String, Vec<String>>;
+/// The type of `self` for a method of `recv`, with the owner's generics substituted.
+fn recvPlumType(recv: &str, subst: &Subst, eg: &EnumGenerics) -> PlumType {
+    if recv == "ByteSlice" {
+        return PlumType::TByteSlice;
+    }
+    match eg.get(recv) {
+        Some(g) if !g.is_empty() => PlumType::TApp(
+            recv.to_string(),
+            g.iter()
+                .map(|n| subst.get(n).cloned().unwrap_or_else(|| PlumType::TParam(n.clone())))
+                .collect(),
+        ),
+        _ => plum_checker::plumTypeFromName(recv),
+    }
+}
+/// `(self type, declared param types (variadic as TVariadic), return type)`, generics substituted.
+fn unitDeclTypes(f: &ast::Fn, subst: &Subst, eg: &EnumGenerics) -> (Option<PlumType>, Vec<PlumType>, PlumType) {
+    let sub = |t: PlumType| plum_checker::types::substitute(&t, subst);
+    let self_ty = f.type_param.as_deref().map(|r| recvPlumType(r, subst, eg));
+    let params = f.params.iter().map(|p| sub(paramPlumType(&p.ty))).collect();
+    let ret = sub(f
+        .returns
+        .as_ref()
+        .map(plum_checker::plumTypeFromAstG)
+        .unwrap_or(PlumType::TUnit));
+    (self_ty, params, ret)
+}
+fn unitFuncSig(f: &ast::Fn, subst: &Subst, eg: &EnumGenerics, g: &GcTypeRegistry) -> FuncSig {
+    let (self_ty, params, ret) = unitDeclTypes(f, subst, eg);
+    let mut vts: Vec<ValType> = Vec::new();
+    if let Some(s) = &self_ty {
+        vts.push(plumTypeToGcValtype(s, g));
+    }
+    for p in &params {
+        vts.push(match p {
+            PlumType::TVariadic(e) => {
+                let ev = plumTypeToGcValtype(e, g);
+                gcRef(*g.variadic_array_type_idx.get(&ev).unwrap_or_else(|| {
+                    panic!("internal codegen error: no variadic array type for element {}", e)
+                }))
+            }
+            other => plumTypeToGcValtype(other, g),
+        });
+    }
+    let ret_vt = if matches!(ret, PlumType::TUnit) { None } else { Some(plumTypeToGcValtype(&ret, g)) };
+    let param_defaults = f
+        .params
+        .iter()
+        .map(|p| match &p.ty {
+            ast::ParamType::Type(_) => p.default.clone(),
+            _ => None,
+        })
+        .collect();
+    FuncSig {
+        params: vts,
+        ret: ret_vt,
+        param_defaults,
+        decl_params: params,
+        decl_ret: ret,
+    }
+}
+/// Collects every concrete generic-enum instance, function type and variadic element
+/// type mentioned by the types it is shown.
+struct TypeCollector<'a> {
+    apps: Vec<PlumType>,
+    seen: HashSet<PlumType>,
+    funs: Vec<PlumType>,
+    funs_seen: HashSet<PlumType>,
+    variadics: Vec<PlumType>,
+    variadics_seen: HashSet<PlumType>,
+    enum_variants: &'a EnumVariants,
+    enum_params: &'a EnumParams,
+    eg: &'a EnumGenerics,
+}
+impl<'a> TypeCollector<'a> {
+    fn visit(&mut self, t: &PlumType) {
+        if hasFreeTy(t) {
+            return;
+        }
+        match t {
+            PlumType::TApp(n, args) => {
+                for a in args {
+                    self.visit(a);
+                }
+                if !self.seen.insert(t.clone()) {
+                    return;
+                }
+                self.apps.push(t.clone());
+                if isArraySpecialization(n) {
+                    return;
+                }
+                let infos: Vec<&EnumVariantInfo> = self
+                    .enum_variants
+                    .values()
+                    .filter(|i| i.enum_name == *n)
+                    .collect();
+                for info in infos {
+                    for f in plum_checker::variantFields(info, t) {
+                        self.visit(&f);
+                    }
+                }
+                if let (Some(params), Some(g)) = (self.enum_params.get(n), self.eg.get(n)) {
+                    let s: Subst = g.iter().cloned().zip(args.iter().cloned()).collect();
+                    for (_, fty) in params.clone() {
+                        self.visit(&plum_checker::types::substitute(&fty, &s));
+                    }
+                }
+            }
+            PlumType::TFun(ps, r) => {
+                for p in ps {
+                    self.visit(p);
+                }
+                self.visit(r);
+                if self.funs_seen.insert(t.clone()) {
+                    self.funs.push(t.clone());
+                }
+            }
+            PlumType::TVariadic(e) => {
+                self.visit(e);
+                if self.variadics_seen.insert((**e).clone()) {
+                    self.variadics.push((**e).clone());
+                }
+            }
+            PlumType::TTags(m) => {
+                for v in m.values().flatten() {
+                    self.visit(v);
+                }
+            }
+            _ => {}
+        }
+    }
+}
+/// Everything a unit body needs to resolve calls, closures and expression types.
+struct UnitRef<'a> {
+    idx: usize,
+    inst: Option<usize>,
+    subst: &'a Subst,
+    types: &'a HashMap<usize, PlumType>,
+}
 fn compileSourceInner(
     source: &ast::Source,
     extra_exports: &[(String, String)],
     typed: plum_checker::TypedInfo,
 ) -> Result<(Vec<u8>, Vec<String>), String> {
-    // The source is compiled as written (generics erased, not specialized): the
+    let plum_checker::TypedInfo {
+        expr_types,
+        instantiations,
+        inst_expr_types,
+        call_inst,
+        ..
+    } = typed;
-    // checker's per-expression instantiated types drive every box/unbox decision.
+    // Per-instantiation expression types, split out by instantiation id.
+    let mut inst_types: Vec<HashMap<usize, PlumType>> = vec![HashMap::new(); instantiations.len()];
-    let types = typed.expr_types;
+    for ((id, ptr), t) in inst_expr_types {
+        inst_types[id].insert(ptr, t);
+    }
     // `Bool.toStr` is a checker/codegen builtin: compiled as one extra method, never added to the source.
     let bool_to_str_fn = plum_checker::needsBuiltinBoolToStr(source).then(plum_checker::builtinBoolToStr);
     let (global_env, methods, enum_variants, enum_params) = plum_checker::buildGlobalTables(source);
     let min_required = plum_checker::buildMinRequiredArgs(source);
+    let mut eg: EnumGenerics = HashMap::new();
+    for item in &source.items {
+        if let ast::Item::Enum(e) = item {
+            eg.insert(e.name.clone(), e.generics.iter().map(|g| g.name.clone()).collect());
+        }
+    }
+    // ---- units: every non-generic fn, plus one per reached instantiation ----
+    let all_fns: Vec<&ast::Fn> = source
+        .items
+        .iter()
+        .filter_map(|item| match item {
+            ast::Item::Fn(f) if !f.is_extern => Some(f),
+            _ => None,
+        })
+        .chain(bool_to_str_fn.iter())
+        .collect();
+    let mut units: Vec<UnitDef> = Vec::new();
+    let mut known_fns: HashSet<String> = HashSet::new();
+    {
+        let cctx = checkCtxOf(&methods, &enum_variants, &enum_params, &min_required);
+        for f in &all_fns {
+            if f.type_param.is_none() {
+                known_fns.insert(f.name.clone());
+            }
+            if plum_checker::fnGenericNames(f, &cctx).is_empty() {
+                units.push(UnitDef {
+                    f,
+                    inst: None,
+                    subst: Subst::new(),
+                    name: fnKey(f).replace("::", "."),
+                });
+            }
+        }
+        for inst in &instantiations {
+            let Some(f) = all_fns
+                .iter()
+                .find(|f| f.type_param == inst.receiver && f.name == inst.name)
+            else {
+                continue;
+            };
+            let subst: Subst = inst
+                .generics
+                .iter()
+                .cloned()
+                .zip(inst.type_args.iter().cloned())
+                .collect();
+            let owner_n = inst.receiver.as_ref().and_then(|r| eg.get(r)).map(|g| g.len()).unwrap_or(0);
+            let show = |a: &[PlumType]| a.iter().map(|t| t.to_string()).collect::<Vec<_>>().join(", ");
+            let name = match &inst.receiver {
+                Some(r) => {
+                    let mut n = format!("{}[{}].{}", r, show(&inst.type_args[..owner_n.min(inst.type_args.len())]), inst.name);
+                    if inst.type_args.len() > owner_n {
+                        n.push_str(&format!("[{}]", show(&inst.type_args[owner_n..])));
+                    }
+                    if owner_n == 0 {
+                        n = format!("{}.{}", r, inst.name);
+                    }
+                    n
+                }
+                None => format!("{}[{}]", inst.name, show(&inst.type_args)),
+            };
+            units.push(UnitDef {
+                f,
+                inst: Some(inst.id),
+                subst,
+                name,
+            });
+        }
+    }
+    // ---- collect the concrete generic types the program uses ----
+    let mut tc = TypeCollector {
+        apps: Vec::new(),
+        seen: HashSet::new(),
+        funs: Vec::new(),
+        funs_seen: HashSet::new(),
+        variadics: Vec::new(),
+        variadics_seen: HashSet::new(),
+        enum_variants: &enum_variants,
+        enum_params: &enum_params,
+        eg: &eg,
+    };
+    for info in enum_variants.values() {
+        if info.generics.is_empty() {
+            for t in &info.field_types {
+                tc.visit(t);
+            }
+        }
+    }
+    for (name, params) in enum_params.iter() {
+        if eg.get(name).is_none_or(|g| g.is_empty()) {
+            for (_, t) in params {
+                tc.visit(t);
+            }
+        }
+    }
+    for t in expr_types.values() {
+        tc.visit(t);
+    }
+    for m in &inst_types {
+        for t in m.values() {
+            tc.visit(t);
+        }
+    }
+    for u in &units {
+        let (s, ps, r) = unitDeclTypes(u.f, &u.subst, &eg);
+        if let Some(s) = s {
+            tc.visit(&s);
+        }
+        for p in &ps {
+            tc.visit(p);
+        }
+        tc.visit(&r);
+    }
+    for inst in &instantiations {
+        for t in &inst.type_args {
+            tc.visit(t);
+        }
+    }
     // Intern every tag name the program's types mention, in sorted order.
     {
@@ -1779,9 +2078,19 @@ fn compileSourceInner(
         for t in methods.values() {
             collectTagNamesTy(t, &mut names);
         }
-        for t in types.values() {
+        for t in expr_types.values() {
             collectTagNamesTy(t, &mut names);
         }
+        for m in &inst_types {
+            for t in m.values() {
+                collectTagNamesTy(t, &mut names);
+            }
+        }
+        for inst in &instantiations {
+            for t in &inst.type_args {
+                collectTagNamesTy(t, &mut names);
+            }
+        }
         CURRENT_TAG_IDS.with(|c| {
             *c.borrow_mut() = names
                 .into_iter()
@@ -1793,7 +2102,7 @@ fn compileSourceInner(
     let mut module = WasmModule::new();
-    let mut gc_types = buildGcTypeRegistry(&mut module, source, &enum_variants, &enum_params);
+    let mut gc_types = buildGcTypeRegistry(&mut module, source, &enum_variants, &enum_params, &tc.apps);
     CURRENT_GC_TYPES.with(|c| *c.borrow_mut() = Some(gc_types.clone()));
     CURRENT_CONSTS.with(|c| {
@@ -1805,22 +2114,12 @@ fn compileSourceInner(
         }
     });
-    // Register one shared `array<T>` GC type per distinct wasm value type used by a
+    // One immutable `array<T>` per distinct wasm value type used by a `...T` variadic.
-    // `...T` variadic parameter anywhere in the program (almost always just one, e.g.
-    // `Int...`) — replaces the old bump-allocated `[count][elem...]` blob (`array.len`
-    // replaces the explicit count word). Must happen before function signatures are
-    // registered below, since a variadic param's wasm type is this array's `ref`.
     let mut variadic_elem_vts: Vec<ValType> = Vec::new();
-    for item in &source.items {
-        if let ast::Item::Fn(f) = item {
-            for p in &f.params {
+    for e in &tc.variadics {
-                if let ast::ParamType::Variadic(t) = &p.ty {
-                    let vt = astTypeToWasm(&t.name).unwrap_or(ValType::I64);
+        let vt = plumTypeToGcValtype(e, &gc_types);
-                    if !variadic_elem_vts.contains(&vt) {
+        if !variadic_elem_vts.contains(&vt) {
-                        variadic_elem_vts.push(vt);
+            variadic_elem_vts.push(vt);
-                    }
-                }
-            }
         }
     }
     let variadic_array_subtypes: Vec<SubType> = variadic_elem_vts
@@ -1845,13 +2144,7 @@ fn compileSourceInner(
         CURRENT_GC_TYPES.with(|c| *c.borrow_mut() = Some(gc_types.clone()));
     }
-    // Register every `extern fun` (e.g. `plum-std/Os.plum`'s `printLn`) as a
+    // Register every `extern fun` as a genuine wasm import BEFORE any function.
-    // genuine wasm import BEFORE any function (including the `start` function
-    // set up right below) — imports must occupy the low end of the function
-    // index space for every later `addFunction`'s index arithmetic to stay
-    // correct. `plum-checker` has already confirmed every extern fn has no
-    // receiver and no body, so `f.name` alone (no `fnKey` receiver-qualification) is
-    // always its unique key.
     let mut func_ids: HashMap<String, u32> = HashMap::new();
     let mut func_sigs: HashMap<String, FuncSig> = HashMap::new();
     let mut extern_wrappers: Vec<(String, u32, Vec<ValType>, Option<ValType>)> = Vec::new();
@@ -1860,38 +2153,28 @@ fn compileSourceInner(
             if !f.is_extern {
                 continue;
             }
+            known_fns.insert(f.name.clone());
+            let sig = unitFuncSig(f, &Subst::new(), &eg, &gc_types);
-            let param_types = fnWasmParamTypes(f, &gc_types);
+            let param_types = sig.params.clone();
-            let ret = retTypeToWasm(f.returns.as_ref());
+            let ret = sig.ret;
-            // `Int` in an extern signature is narrowed to wasm i32 at the host
+            // `Int` in an extern signature is narrowed to wasm i32 at the host boundary.
-            // boundary (the browser host never sees a BigInt). The import gets the
-            // narrowed type; a same-named wrapper with the plain i64 signature (added
-            // below, once all imports exist) range-checks/wraps args and sign-extends
-            // the result, so every Plum call site is unchanged.
             let narrow = |v: &ValType| if *v == ValType::I64 { ValType::I32 } else { *v };
             let imp_params: Vec<ValType> = param_types.iter().map(narrow).collect();
             let imp_results: Vec<ValType> = ret.iter().map(narrow).collect();
             let type_idx = module.addType(&imp_params, &imp_results);
             let func_idx = module.addImport("plum", &f.name, type_idx);
-            extern_wrappers.push((f.name.clone(), func_idx, param_types.clone(), ret));
+            extern_wrappers.push((f.name.clone(), func_idx, param_types, ret));
             func_sigs.insert(
                 f.name.clone(),
                 FuncSig {
-                    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()
+                    ..sig
-                        .map(plum_checker::plumTypeFromAstG)
-                        .unwrap_or(PlumType::TUnit),
                 },
             );
         }
     }
-    // `plum::crash(Str)`: same wasm type as `printLn`; imported only when the
-    // program actually contains a `crash` statement.
+    // `plum::crash(Str)`
     {
         let uses_crash = sourceUsesCrash(&format!("{:?}", source.items));
         if uses_crash {
@@ -1902,9 +2185,7 @@ fn compileSourceInner(
         }
     }
-    // Extern `Int` narrowing wrappers (see the import loop above). The i32 range
+    // Extern `Int` narrowing wrappers.
-    // check is unconditional (one wrap/extend/compare per Int arg; the CLI has no
-    // separate debug mode): an `Int` that doesn't fit in i32 traps.
     for (name, imp_idx, params, ret) in &extern_wrappers {
         let mut b = vec![0u8];
         for (i, vt) in params.iter().enumerate() {
@@ -1933,54 +2214,39 @@ fn compileSourceInner(
         let results_vec: Vec<ValType> = ret.iter().cloned().collect();
         let t = module.addType(params, &results_vec);
         let w = module.addFunction(t, &b);
+        module.nameFunction(w, name);
         func_ids.insert(name.clone(), w);
     }
-    // Pre-allocate one instance of every payload-free variant (True/False/End/...)
+    // Pre-allocate one instance of every payload-free variant of every enum instance.
-    // as a global, populated once by a `start` function rather than reconstructed on
-    // every reference — see this migration plan's Decision 2. `struct.new` isn't
-    // allowed inside a global's own const-expr initializer (confirmed empirically in
-    // Task 1), so each global starts `ref.null` and a `start` function fills it in
-    // before any export is callable. The zero-capture "trampoline" closures
-    // registered below (once closures are discovered) append to this SAME start
-    // function, so its body isn't finalized/patched into the module until then.
-    let mut singleton_globals: HashMap<String, u32> = HashMap::new();
+    let mut singleton_globals: HashMap<(PlumType, String), u32> = HashMap::new();
     let mut start_body = Vec::new();
+    for ty in gc_types.instances.clone() {
+        let en = plum_checker::nominalName(&ty).unwrap().to_string();
+        let mut vnames: Vec<(&String, &EnumVariantInfo)> =
+            enum_variants.iter().filter(|(_, i)| i.enum_name == en).collect();
+        vnames.sort_by_key(|(_, i)| i.tag);
-    for (name, info) in &enum_variants {
+        for (name, info) in vnames {
-        if !info.field_types.is_empty() {
+            if !info.field_types.is_empty() {
-            continue;
+                continue;
-        }
+            }
+            let variant_idx = gc_types.variantIdx(&ty, name).unwrap_or_else(|| {
-        // `Array`'s bare payload-free variant is aliased onto the
+                panic!("internal codegen error: payload-free variant '{}' missing from GC type registry", name)
+            });
-        // ONE shared `array<anyref>` type (see
+            let mut init = Vec::new();
-        // `buildGcTypeRegistry`'s `isArraySpecialization` handling), not a
-        // real struct type — it's never actually instantiated this way
+            Instruction::RefNull(HeapType::Concrete(variant_idx)).encode(&mut init);
-        // (construction goes through the `init`/`push` compiler intrinsics
+            let global_idx = module.addGlobal(gcRef(variant_idx), true, &init);
-        // instead), so it must not get a singleton global here.
+            singleton_globals.insert((ty.clone(), name.clone()), global_idx);
+            Instruction::I32Const(typeIdOf(&gc_types, name)).encode(&mut start_body);
-        if isArraySpecialization(name) {
+            Instruction::StructNew(variant_idx).encode(&mut start_body);
-            continue;
+            Instruction::GlobalSet(global_idx).encode(&mut start_body);
         }
-        let variant_idx = *gc_types.variant_type_idx.get(name).unwrap_or_else(|| {
-            panic!(
-                "internal codegen error: payload-free variant '{}' missing from GC type registry",
-                name
-            )
-        });
-        let mut init = Vec::new();
-        Instruction::RefNull(HeapType::Concrete(variant_idx)).encode(&mut init);
-        let global_idx = module.addGlobal(gcRef(variant_idx), true, &init);
-        singleton_globals.insert(name.clone(), global_idx);
-        // A payload-free variant is exactly `{typeId}`.
-        Instruction::I32Const(typeIdOf(&gc_types, name)).encode(&mut start_body);
-        Instruction::StructNew(variant_idx).encode(&mut start_body);
-        Instruction::GlobalSet(global_idx).encode(&mut start_body);
     }
     let start_type_idx = module.addType(&[], &[]);
     let start_func_idx = module.addFunction(start_type_idx, &[]);
+    module.nameFunction(start_func_idx, "start");
     module.setStartFunction(start_func_idx);
-    // Box helpers (`i64 -> $BoxI64`, ...) and the `Str` builder push the header
-    // typeId themselves, so callers only supply the payload.
     gc_types.box_i64_fn =
         registerBoxHelper(&mut module, ValType::I64, TYPE_ID_BOX_I64, gc_types.box_i64_idx);
     gc_types.box_f64_fn =
@@ -1989,6 +2255,14 @@ fn compileSourceInner(
         registerBoxHelper(&mut module, ValType::I32, TYPE_ID_BOX_I32, gc_types.box_i32_idx);
     gc_types.box_bool_fn =
         registerBoxHelper(&mut module, ValType::I32, TYPE_ID_BOX_BOOL, gc_types.box_bool_idx);
+    for (f, n) in [
+        (gc_types.box_i64_fn, "box.i64"),
+        (gc_types.box_f64_fn, "box.f64"),
+        (gc_types.box_i32_fn, "box.i32"),
+        (gc_types.box_bool_fn, "box.bool"),
+    ] {
+        module.nameFunction(f, n);
+    }
     if let (Some(&buffer_idx), Some(&str_idx)) = (
         gc_types.class_type_idx.get("Buffer"),
         gc_types.class_type_idx.get("Str"),
@@ -2009,59 +2283,32 @@ 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 ABI: one `call_indirect` type per Plum function signature,
-    // `(env, anyref * n) -> anyref`, shared by every closure and call site.
+    // `(env: anyref, params...) -> result`, with every value in its own representation.
     let mut closure_call_types: HashMap<ClosureSigKey, u32> = HashMap::new();
-    for arity in 0..=MAX_CLOSURE_ARITY {
+    for t in &tc.funs {
-        let params = vec![ValType::Ref(RefType::ANYREF); arity + 1];
-        let t = module.addType(&params, &[ValType::Ref(RefType::ANYREF)]);
-        closure_call_types.insert(arity, t);
+        if let PlumType::TFun(ps, r) = t {
+            getClosureCallType(&mut module, &mut closure_call_types, &closureSigKey(ps, r, &gc_types));
+        }
     }
-    // Register every function AND method signature up front (methods get an implicit
+    // Register every unit's wasm function up front.
-    // leading `self: pointer` param and are keyed as "Receiver::method").
+    let mut inst_funcs: HashMap<usize, (u32, FuncSig)> = HashMap::new();
-    for f in source
+    for u in &units {
-        .items
+        let sig = unitFuncSig(u.f, &u.subst, &eg, &gc_types);
-        .iter()
+        let results_vec: Vec<ValType> = sig.ret.into_iter().collect();
+        let type_idx = module.addType(&sig.params, &results_vec);
-        .filter_map(|item| match item {
+        let func_idx = module.addFunction(type_idx, &[]);
-            ast::Item::Fn(f) => Some(f),
+        module.nameFunction(func_idx, &u.name);
+        match u.inst {
-            _ => None,
+            Some(id) => {
+                inst_funcs.insert(id, (func_idx, sig));
-        })
+            }
-        .chain(bool_to_str_fn.iter())
-    {
-        {
-            if f.is_extern {
-                continue;
+            None => {
+                let key = fnKey(u.f);
+                func_ids.insert(key.clone(), func_idx);
+                func_sigs.insert(key, sig);
             }
-            let param_types = fnWasmParamTypes(f, &gc_types);
-            let ret = retTypeToWasm(f.returns.as_ref());
-            let results_vec: Vec<ValType> = ret.into_iter().collect();
-            let type_idx = module.addType(&param_types, &results_vec);
-            let func_idx = module.addFunction(type_idx, &[]);
-            let key = fnKey(f);
-            func_ids.insert(key.clone(), func_idx);
-            let param_defaults: Vec<Option<ast::Expr>> = f
-                .params
-                .iter()
-                .map(|p| match &p.ty {
-                    ast::ParamType::Type(_) => p.default.clone(),
-                    _ => None,
-                })
-                .collect();
-            func_sigs.insert(
-                key,
-                FuncSig {
-                    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),
-                },
-            );
         }
     }
@@ -2076,44 +2323,30 @@ fn compileSourceInner(
     );
     CURRENT_GC_TYPES.with(|c| *c.borrow_mut() = Some(gc_types.clone()));
-    let fns: Vec<&ast::Fn> = source
-        .items
-        .iter()
-        .filter_map(|item| match item {
-            ast::Item::Fn(f) if !f.is_extern => Some(f),
-            _ => None,
-        })
-        .chain(bool_to_str_fn.iter())
-        .collect();
-    // ---- Discovery pre-pass: find every closure literal in every function body. ----
+    // ---- Discovery pre-pass: every closure literal in every unit body. ----
-    // (Runs on the original, erased source.) Registers each closure as its own wasm function + table
-    // element and records the free variables it must capture.
-    // Only genuine free functions (`type_param.is_none()`) — a bare `FnCall`
-    // (`each(...)`) can only ever resolve to a free function, never a method
-    // (those always dispatch through `Attribute`/`AttrKind::Method`, keyed by
-    // `(receiver, name)` instead — see that arm's own comment below). Keying
-    // this by bare name across free functions AND methods would let a
-    // method silently SHADOW a same-named free function here
-    // (e.g. a user's own top-level `each` losing to `List.each` once
-    // `List` happens to be in scope) — same-named methods on unrelated
-    // classes are already ambiguous by bare name, so methods have no business
-    // being in a bare-name lookup table at all.
-    let fn_decls: HashMap<String, &ast::Fn> = fns
+    let fn_decls: HashMap<String, &ast::Fn> = units
         .iter()
-        .filter(|f| f.type_param.is_none())
+        .filter(|u| u.inst.is_none() && u.f.type_param.is_none())
-        .map(|f| (f.name.clone(), *f))
+        .map(|u| (u.f.name.clone(), u.f))
         .collect();
+    let unit_types = |u: &UnitDef| -> &HashMap<usize, PlumType> {
+        match u.inst {
+            Some(id) => &inst_types[id],
+            None => &expr_types,
+        }
+    };
-    let mut raw_closures: Vec<RawClosure> = Vec::new();
+    let mut raw_closures: Vec<(usize, RawClosure)> = Vec::new();
-    let mut named_fn_refs: HashSet<String> = HashSet::new();
+    let mut named_fn_refs: HashSet<(String, PlumType)> = HashSet::new();
+    for (ui, u) in units.iter().enumerate() {
-    for f in &fns {
+        let f = u.f;
         let mut locals: HashSet<String> = HashSet::new();
         for p in &f.params {
             locals.insert(p.name.clone());
         }
         let mut walker = ClosureWalker {
-            types: &types,
+            types: unit_types(u),
             fn_decls: &fn_decls,
+            func_sigs: &func_sigs,
             found: Vec::new(),
             locals,
             named_fn_refs: HashSet::new(),
@@ -2121,18 +2354,12 @@ fn compileSourceInner(
         match &f.body {
             ast::FnBody::Block(block) => walker.walkBlock(block),
             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`"),
+            ast::FnBody::Extern => unreachable!("extern fns are excluded from units"),
         }
-        raw_closures.extend(walker.found);
+        raw_closures.extend(walker.found.into_iter().map(|c| (ui, c)));
         named_fn_refs.extend(walker.named_fn_refs);
     }
-    // Register every closure literal's own env struct type, plus the ONE shared
-    // closure-value struct `{table_idx: i32, env: anyref}` every closure (and
-    // trampoline, below) wraps its env in — declared together as a single `rec`
-    // group now that every closure's free-variable types are known. The shared
-    // struct is always slot 0; closure `i`'s env type is slot `i + 1`.
     let mut closure_subtypes: Vec<SubType> = vec![SubType {
         is_final: true,
         supertype_idx: None,
@@ -2153,7 +2380,7 @@ fn compileSourceInner(
             shared: false,
         },
     }];
-    for rc in &raw_closures {
+    for (_, rc) in &raw_closures {
         let field_types: Vec<FieldType> = rc
             .free_vars
             .iter()
@@ -2177,17 +2404,20 @@ fn compileSourceInner(
     gc_types.closure_type_idx = closure_type_indices[0];
     CURRENT_GC_TYPES.with(|c| *c.borrow_mut() = Some(gc_types.clone()));
-    let mut closures: HashMap<usize, ClosureInfo> = HashMap::new();
+    let mut closures: HashMap<(usize, usize), ClosureInfo> = HashMap::new();
-    let mut closure_asts: HashMap<usize, &ast::Closure> = HashMap::new();
+    let mut closure_asts: HashMap<(usize, usize), &ast::Closure> = HashMap::new();
-    for (i, rc) in raw_closures.iter().enumerate() {
+    for (i, (ui, rc)) in raw_closures.iter().enumerate() {
-        let arity = rc.closure.params.len();
-        let type_idx = *closure_call_types
+        let key = closureSigKey(
+            &rc.param_ptypes,
+            &rc.ret_ptype,
-            .get(&arity)
+            &gc_types,
+        );
-            .ok_or_else(|| format!("codegen: closures with {} params are not supported", arity))?;
+        let type_idx = getClosureCallType(&mut module, &mut closure_call_types, &key);
         let func_idx = module.addFunction(type_idx, &[]);
+        module.nameFunction(func_idx, &format!("{}.closure", units[*ui].name));
         let table_idx = module.addTableElement(func_idx);
         closures.insert(
-            rc.ptr,
+            (*ui, rc.ptr),
             ClosureInfo {
                 func_idx,
                 table_idx,
@@ -2197,57 +2427,35 @@ fn compileSourceInner(
                 free_vars: rc.free_vars.clone(),
             },
         );
-        closure_asts.insert(rc.ptr, rc.closure);
+        closure_asts.insert((*ui, rc.ptr), rc.closure);
-    }
+    }
-    // Register a zero-capture "trampoline" closure for every top-level function
+    // Zero-capture trampolines for top-level functions used as values.
-    // referenced as a bare value (e.g. `each(double)`): a real wasm function with the
-    // erased closure ABI `(env, anyref...) -> anyref` that ignores its env, unboxes
-    // each argument to the real function's parameter representation, forwards to the
-    // real function and boxes its result, plus a funcref-table entry for it. Since
-    // it never captures anything, its `{table_idx, env=null}` closure struct is a
-    // 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();
+    let mut named_fn_values: HashMap<(String, PlumType), u32> = HashMap::new();
-    for name in &named_fn_refs {
+    for (name, fty) in &named_fn_refs {
         let sig = func_sigs
             .get(name)
             .expect("named fn ref must be a registered top-level function");
         let real_func_idx = *func_ids
             .get(name)
             .expect("named fn ref must be a registered top-level function");
-        let arity = sig.params.len();
+        let PlumType::TFun(ps, r) = fty else { continue };
-        let type_idx = *closure_call_types
+        let key = closureSigKey(ps, r, &gc_types);
-            .get(&arity)
-            .ok_or_else(|| format!("codegen: function '{}' has too many params to use as a value", name))?;
+        let type_idx = getClosureCallType(&mut module, &mut closure_call_types, &key);
-        let mut tbody = Vec::new();
+        let mut tbody = vec![0u8];
-        tbody.push(0u8); // no locals beyond the params already in the signature
-        for (i, vt) in sig.params.iter().enumerate() {
+        for i in 0..sig.params.len() {
-            Instruction::LocalGet((i + 1) as u32).encode(&mut tbody); // local 0 is env, ignored
+            Instruction::LocalGet((i + 1) as u32).encode(&mut tbody);
-            match sig.decl_params.get(i) {
-                Some(PlumType::TBool) => {
-                    coerceTy(&anyTy(), &PlumType::TBool, &mut tbody, &gc_types)
-                }
-                _ => coerceVt(ValType::Ref(RefType::ANYREF), *vt, &mut tbody, &gc_types),
-            }
         }
         Instruction::Call(real_func_idx).encode(&mut tbody);
-        match sig.ret {
-            Some(_) if matches!(sig.decl_ret, PlumType::TBool) => {
-                coerceTy(&PlumType::TBool, &anyTy(), &mut tbody, &gc_types)
-            }
-            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);
+        module.nameFunction(func_idx, &format!("{}.trampoline", name));
         let table_idx = module.addTableElement(func_idx);
         let mut init = Vec::new();
         Instruction::RefNull(HeapType::Concrete(gc_types.closure_type_idx)).encode(&mut init);
         let global_idx = module.addGlobal(gcRef(gc_types.closure_type_idx), true, &init);
-        named_fn_values.insert(name.clone(), global_idx);
+        named_fn_values.insert((name.clone(), fty.clone()), global_idx);
         Instruction::I32Const(table_idx as i32).encode(&mut start_body);
         Instruction::RefNull(HeapType::ANY).encode(&mut start_body);
@@ -2255,19 +2463,12 @@ fn compileSourceInner(
         Instruction::GlobalSet(global_idx).encode(&mut start_body);
     }
-    // The `start` function is now complete — every payload-free variant singleton
-    // (above) and every trampoline closure (above) has appended its own init code.
-    // It declares no locals of its own, but a function body's raw bytes must still
-    // start with the (empty) locals-declaration vector — a single `0x00` — before
-    // the instruction stream, exactly like every other compiled function body below.
     Instruction::End.encode(&mut start_body);
     let mut final_start_body = vec![0u8];
     final_start_body.extend(start_body);
     let start_slot = (start_func_idx - module.func_import_count) as usize;
     module.functions[start_slot].1 = final_start_body;
-    // Runtime helpers backing string interpolation (`"{expr}"`): always registered
-    // (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);
@@ -2276,6 +2477,10 @@ fn compileSourceInner(
     let ctx = CompileCtx {
         func_ids,
         func_sigs,
+        inst_funcs,
+        call_inst,
+        known_fns,
+        eg,
         methods,
         enum_variants,
         enum_params,
@@ -2284,7 +2489,6 @@ fn compileSourceInner(
         closures,
         closure_asts,
         closure_call_types,
-        types,
         named_fn_values,
         string_concat_func,
         string_eq_func,
@@ -2298,35 +2502,45 @@ fn compileSourceInner(
         passive_segments: Vec::new(),
     };
-    let mut compiled_bodies: Vec<(String, Vec<u8>)> = Vec::new();
+    let mut compiled_bodies: Vec<(u32, Vec<u8>)> = Vec::new();
+    for (ui, u) in units.iter().enumerate() {
+        let f = u.f;
+        let uref = UnitRef {
+            idx: ui,
+            inst: u.inst,
-    for f in &fns {
+            subst: &u.subst,
+            types: unit_types(u),
+        };
-        let body = match compileIntrinsicFnBody(f) {
+        let body = match compileIntrinsicFnBody(f, &u.subst) {
             Some(body) => body,
-            None => compileFnBody(f, &ctx, &mut state).map_err(|e| {
+            None => compileFnBody(f, &ctx, &mut state, &uref).map_err(|e| format!("{e} (in '{}')", u.name))?,
-                format!("{e} (in '{}{}')", f.type_param.as_ref().map(|r| format!("{r}.")).unwrap_or_default(), f.name)
-            })?,
+        };
+        let idx = match u.inst {
+            Some(id) => ctx.inst_funcs[&id].0,
+            None => ctx.func_ids[&fnKey(f)],
         };
-        compiled_bodies.push((fnKey(f), body));
+        compiled_bodies.push((idx, body));
     }
-    // Patch compiled bodies back into their pre-registered function slots.
-    for (name, body) in &compiled_bodies {
+    for (idx, body) in &compiled_bodies {
-        let idx = *ctx
-            .func_ids
-            .get(name)
-            .expect("function was registered in the first pass");
-        let slot = (idx - module.func_import_count) as usize;
+        let slot = (*idx - module.func_import_count) as usize;
         module.functions[slot].1 = body.clone();
     }
     // Compile each closure literal's own body into its reserved function slot.
     let mut closure_bodies: Vec<(u32, Vec<u8>)> = Vec::new();
-    for (ptr, info) in &ctx.closures {
+    for ((ui, ptr), info) in &ctx.closures {
         let cl = ctx
             .closure_asts
-            .get(ptr)
+            .get(&(*ui, *ptr))
             .expect("every registered closure has its AST recorded");
+        let u = &units[*ui];
+        let uref = UnitRef {
+            idx: *ui,
+            inst: u.inst,
+            subst: &u.subst,
+            types: unit_types(u),
+        };
-        let body = compileClosureBody(cl, info, &ctx, &mut state)?;
+        let body = compileClosureBody(cl, info, &ctx, &mut state, &uref)?;
         closure_bodies.push((info.func_idx, body));
     }
     for (func_idx, body) in &closure_bodies {
@@ -2334,10 +2548,6 @@ fn compileSourceInner(
         module.functions[slot].1 = body.clone();
     }
-    // Flush every staged string literal into the module in the SAME order they were
-    // staged — `compileStaticString` already baked each one's index (its position in
-    // `state.passive_segments` at staging time) into an `array.new_data` instruction,
-    // so that order must be preserved exactly for those indices to still be correct.
     for bytes in &state.passive_segments {
         module.addPassiveDataSegment(bytes);
     }
@@ -2360,10 +2570,31 @@ fn compileSourceInner(
         .filter(|k| k.as_str() != CRASH_FN_KEY)
         .cloned()
         .collect();
+    fn_keys.extend(units.iter().filter(|u| u.inst.is_some()).map(|u| u.name.clone()));
     fn_keys.sort();
     Ok((module.finish(), fn_keys))
 }
+/// `(param value types, result value type)` of a closure of Plum type `fn(ps) -> r`.
+fn closureSigKey(ps: &[PlumType], r: &PlumType, g: &GcTypeRegistry) -> ClosureSigKey {
+    (
+        ps.iter().map(|p| plumTypeToGcValtype(p, g)).collect(),
+        if matches!(r, PlumType::TUnit) { None } else { Some(plumTypeToGcValtype(r, g)) },
+    )
+}
+fn getClosureCallType(module: &mut WasmModule, m: &mut HashMap<ClosureSigKey, u32>, key: &ClosureSigKey) -> u32 {
+    if let Some(&t) = m.get(key) {
+        return t;
+    }
+    let mut params = vec![ValType::Ref(RefType::ANYREF)];
+    params.extend(key.0.iter().copied());
+    let results: Vec<ValType> = key.1.into_iter().collect();
+    let t = module.addType(&params, &results);
+    m.insert(key.clone(), t);
+    t
+}
 /// `(payload) -> ref $Box*`: allocates a box with its header typeId set.
 fn registerBoxHelper(module: &mut WasmModule, vt: ValType, type_id: i32, box_idx: u32) -> u32 {
     let mut b = vec![0u8];
@@ -2956,10 +3187,10 @@ fn registerIntToStringHelper(module: &mut WasmModule, byte_array_type_idx: u32)
 /// registers their real signature and validates call sites), then intercepted
 /// here — by `fnKey` — instead of compiling their `todo` body to `unreachable`.
 /// Returns `None` for any other function, meaning "compile it normally."
-fn compileIntrinsicFnBody(f: &ast::Fn) -> Option<Vec<u8>> {
+fn compileIntrinsicFnBody(f: &ast::Fn, subst: &Subst) -> Option<Vec<u8>> {
     if let Some(recv) = f.type_param.as_deref() {
         if isArraySpecialization(recv) {
-            return compileArrayIntrinsicFnBody(f);
+            return compileArrayIntrinsicFnBody(f, subst);
         }
     }
     let byte_array_type_idx = withGcTypes(|r| r.byte_array_type_idx);
@@ -3129,8 +3360,10 @@ fn unwrapStrToBytes(body: &mut Vec<u8>) {
 /// `ref.cast` back from the raw stored `anyref` down to `T`'s own concrete
 /// type; `set`/`init` need no such cast the other way, since any concrete ref
 /// is already a valid subtype wherever `anyref` is expected.
-fn compileArrayIntrinsicFnBody(f: &ast::Fn) -> Option<Vec<u8>> {
+fn compileArrayIntrinsicFnBody(f: &ast::Fn, subst: &Subst) -> Option<Vec<u8>> {
+    let elem = subst.get("T")?.clone();
+    let array_ty = PlumType::TApp("Array".to_string(), vec![elem]);
-    let array_type_idx = withGcTypes(|r| r.array_type_idx);
+    let array_type_idx = withGcTypes(|r| r.superIdx(&array_ty))?;
     match f.name.as_str() {
         // init() -> Array[T] — always starts empty; see `push` for how a
         // specific length is actually built up.
@@ -3244,15 +3477,6 @@ fn compileArrayIntrinsicFnBody(f: &ast::Fn) -> Option<Vec<u8>> {
             Instruction::LocalGet(1).encode(&mut body); // i
             Instruction::I32WrapI64.encode(&mut body);
             Instruction::ArrayGet(array_type_idx).encode(&mut body);
-            // Narrow the raw `anyref` element back to `T`'s own concrete type —
-            // skipped when `T` itself resolves to a bare `anyref` (nothing to cast to).
-            if let Some(ValType::Ref(RefType {
-                heap_type: HeapType::Concrete(idx),
-                ..
-            })) = f.returns.as_ref().and_then(|t| astTypeToWasm(&t.name))
-            {
-                Instruction::RefCastNullable(HeapType::Concrete(idx)).encode(&mut body);
-            }
             Instruction::End.encode(&mut body);
             Some(body)
         }
@@ -3280,6 +3504,15 @@ fn compileArrayIntrinsicFnBody(f: &ast::Fn) -> Option<Vec<u8>> {
 /// The `PlumType` of a declared parameter, including `fn(...)`-typed params as `TFun`;
 /// a single-letter generic name is a `TParam`.
+/// The enum type (`TNamed`/`TApp`) a variant-constructing expression produces.
+fn enumTypeOfExpr(expr: &ast::Expr, info: &EnumVariantInfo, ctx: &LocalCtx) -> PlumType {
+    let t = inferLocalType(expr, ctx);
+    match &t {
+        PlumType::TNamed(n) | PlumType::TApp(n, _) if *n == info.enum_name => t,
+        _ => PlumType::TNamed(info.enum_name.clone()),
+    }
+}
 fn paramPlumType(pt: &ast::ParamType) -> PlumType {
     match pt {
         ast::ParamType::Type(t) => plum_checker::plumTypeFromAstG(t),
@@ -3307,6 +3540,22 @@ struct RawClosure<'a> {
     free_vars: Vec<(String, PlumType)>,
 }
+/// The `fn(...)` type a bare reference to top-level fn `name` is used at.
+fn namedRefType(
+    name: &str,
+    expr: &ast::Expr,
+    types: &HashMap<usize, PlumType>,
+    sigs: &HashMap<String, FuncSig>,
+) -> PlumType {
+    match types.get(&(expr as *const ast::Expr as usize)) {
+        Some(t @ PlumType::TFun(..)) if !hasFreeTy(t) => t.clone(),
+        _ => match sigs.get(name) {
+            Some(s) => PlumType::TFun(s.decl_params.clone(), Box::new(s.decl_ret.clone())),
+            None => PlumType::TFun(vec![], Box::new(PlumType::TUnit)),
+        },
+    }
+}
 fn argExprOf(arg: &ast::Arg) -> &ast::Expr {
     match arg {
         ast::Arg::Positional(e) => e,
@@ -3322,6 +3571,7 @@ fn argExprOf(arg: &ast::Arg) -> &ast::Expr {
 struct ClosureWalker<'a, 't> {
     types: &'t HashMap<usize, PlumType>,
     fn_decls: &'a HashMap<String, &'a ast::Fn>,
+    func_sigs: &'t HashMap<String, FuncSig>,
     found: Vec<RawClosure<'a>>,
     /// Local names bound in the function currently being walked (params, assign
     /// targets, for-loop vars) — used to tell a local variable reference apart from a
@@ -3332,7 +3582,7 @@ struct ClosureWalker<'a, 't> {
     /// `Expr::FnCall` and never reaches here). Each one needs a zero-capture
     /// "trampoline" closure so it can be used wherever a `fn(...)`-typed value is
     /// expected.
-    named_fn_refs: HashSet<String>,
+    named_fn_refs: HashSet<(String, PlumType)>,
 }
 impl<'a, 't> ClosureWalker<'a, 't> {
@@ -3456,7 +3706,8 @@ impl<'a, 't> ClosureWalker<'a, 't> {
                 if !self.locals.contains(name) {
                     if let Some(f) = self.fn_decls.get(name) {
                         if f.type_param.is_none() {
+                            let ty = namedRefType(name, expr, self.types, self.func_sigs);
-                            self.named_fn_refs.insert(name.clone());
+                            self.named_fn_refs.insert((name.clone(), ty));
                         }
                     }
                 }
@@ -3765,7 +4016,7 @@ struct Collector<'a> {
     /// Slot number (the `u32` values in `nested_class_scratch`) -> the variant name
     /// it narrows to, so its scratch local can be declared with that variant's exact
     /// concrete ref type instead of a uniform placeholder type.
-    nested_class_scratch_types: Vec<String>,
+    nested_class_scratch_types: Vec<(PlumType, String)>,
     next_nested_class_slot: u32,
     /// `For` stmt identity (pointer address) -> a slot number; each slot reserves 2
     /// consecutive `i32` scratch locals for variadic iteration (`for v in nums`):
@@ -3821,7 +4072,7 @@ impl<'a> Collector<'a> {
                 let slot = self.next_nested_class_slot;
                 self.next_nested_class_slot += 1;
                 self.nested_class_scratch.insert(key, slot);
-                self.nested_class_scratch_types.push(name.clone());
+                self.nested_class_scratch_types.push((ty.clone(), name.clone()));
                 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`).
@@ -3953,11 +4204,10 @@ impl<'a> Collector<'a> {
             ast::Expr::Try(inner) => {
                 let key = expr as *const ast::Expr as usize;
                 let ty = self.ty(inner);
-                let name = plum_checker::nominalName(&ty).unwrap_or("").to_string();
                 let slot = self.next_nested_class_slot;
                 self.next_nested_class_slot += 1;
                 self.nested_class_scratch.insert(key, slot);
-                self.nested_class_scratch_types.push(name);
+                self.nested_class_scratch_types.push((ty, String::new()));
                 self.walkExpr(inner);
             }
             ast::Expr::Unary(u) => self.walkExpr(&u.operand),
@@ -3974,11 +4224,10 @@ impl<'a> Collector<'a> {
             ast::Expr::Elvis(e) => {
                 let key = expr as *const ast::Expr as usize;
                 let ty = self.ty(&e.left);
-                let name = plum_checker::nominalName(&ty).unwrap_or("").to_string();
                 let slot = self.next_nested_class_slot;
                 self.next_nested_class_slot += 1;
                 self.nested_class_scratch.insert(key, slot);
-                self.nested_class_scratch_types.push(name);
+                self.nested_class_scratch_types.push((ty, String::new()));
                 self.walkExpr(&e.left);
                 self.walkExpr(&e.right);
             }
@@ -4029,26 +4278,26 @@ fn compileFnBody(
     f: &ast::Fn,
     ctx: &CompileCtx,
     state: &mut ModuleState,
+    unit: &UnitRef,
 ) -> 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.
+    // saw): globals, `self`, and the params under their (instantiated) declared types.
     let mut base_env = ctx.global_env.clone();
     let mut decl_types: HashMap<String, PlumType> = HashMap::new();
+    let (self_decl, param_decls, ret_decl) = unitDeclTypes(f, unit.subst, &ctx.eg);
-    if let Some(recv) = &f.type_param {
+    if let Some(self_ty) = self_decl {
-        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 = paramPlumType(&p.ty);
+    for (p, ty) in f.params.iter().zip(param_decls.iter()) {
         base_env.insert(p.name.clone(), TypeScheme::mono(ty.clone()));
-        decl_types.insert(p.name.clone(), ty);
+        decl_types.insert(p.name.clone(), ty.clone());
     }
     let mut collector = Collector {
-        types: &ctx.types,
+        types: unit.types,
         enum_variants: &ctx.enum_variants,
         named: Vec::new(),
         named_set: Default::default(),
@@ -4104,8 +4353,8 @@ fn compileFnBody(
     // 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 {
+    for (sty, vname) in &collector.nested_class_scratch_types {
-        let variant_idx = withGcTypes(|r| classOrVariantTypeIdx(r, vname));
+        let variant_idx = withGcTypes(|r| scratchTypeIdx(r, sty, vname));
         groups.push(gcRef(variant_idx));
         idx += 1;
     }
@@ -4144,7 +4393,12 @@ fn compileFnBody(
         variadic_for_scratch: collector.variadic_for_scratch,
         func_ids: &ctx.func_ids,
         func_sigs: &ctx.func_sigs,
+        inst_funcs: &ctx.inst_funcs,
+        call_inst: &ctx.call_inst,
+        known_fns: &ctx.known_fns,
+        unit_idx: unit.idx,
+        unit_inst: unit.inst,
-        types: &ctx.types,
+        types: unit.types,
         local_decl_types: decl_types,
         closures: &ctx.closures,
         closure_call_types: &ctx.closure_call_types,
@@ -4162,12 +4416,16 @@ fn compileFnBody(
         type_env: RefCell::new(base_env),
         loop_extra_depth: Cell::new(0),
         in_closure: false,
-        ret_type: f.returns.as_ref().map(plum_checker::plumTypeFromAstG),
+        ret_type: f.returns.as_ref().map(|_| ret_decl.clone()),
         match_subject_types: RefCell::new(HashMap::new()),
         subject_ptypes: RefCell::new(HashMap::new()),
     };
+    let result_vt = if f.returns.is_none() || matches!(ret_decl, PlumType::TUnit) {
+        None
+    } else {
-    let result_vt = retTypeToWasm(f.returns.as_ref());
+        Some(plumTypeToValtype(&ret_decl))
+    };
     match &f.body {
         ast::FnBody::Expr(e) => {
@@ -4425,18 +4683,27 @@ fn compileStmt(
                                             field_name, class_name
                                         )
                                     })?;
-                                let super_type_idx = *ctx
+                                let super_type_idx = ctx
                                     .gc_types
-                                    .enum_super_type_idx
-                                    .get(&class_name)
+                                    .superIdx(&obj_ty)
                                     .ok_or_else(|| {
                                         format!(
                                             "codegen: enum '{}' missing from the GC type registry",
                                             class_name
                                         )
                                     })?;
+                                let sub_s: Subst = ctx
+                                    .enum_variants
+                                    .values()
+                                    .find(|i| i.enum_name == class_name)
+                                    .map(|i| match &obj_ty {
+                                        PlumType::TApp(_, a) => i.generics.iter().cloned().zip(a.iter().cloned()).collect(),
+                                        _ => Subst::new(),
+                                    })
+                                    .unwrap_or_default();
+                                let fty = plum_checker::types::substitute(&params[field_idx].1, &sub_s);
                                 compileExpr(object, body, ctx, state)?;
-                                compileExprInto(value, &params[field_idx].1, body, ctx, state)?;
+                                compileExprInto(value, &fty, body, ctx, state)?;
                                 Instruction::StructSet {
                                     struct_type_index: super_type_idx,
                                     field_index: fld(field_idx),
@@ -4462,12 +4729,13 @@ fn compileStmt(
                                     .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)
+                                let variant_type_idx = ctx.gc_types.variantIdx(&obj_ty, variant_name)
-                                    .ok_or_else(|| format!("codegen: variant '{}' missing from the GC type registry", variant_name))?;
+                                    .ok_or_else(|| format!("codegen: variant '{}' of {} missing from the GC type registry", variant_name, obj_ty))?;
+                                let fty = plum_checker::variantFields(info, &obj_ty)[field_idx].clone();
                                 compileExpr(object, body, ctx, state)?;
                                 Instruction::RefCastNonNull(HeapType::Concrete(variant_type_idx))
                                     .encode(body);
-                                compileExprInto(value, &info.field_types[field_idx], body, ctx, state)?;
+                                compileExprInto(value, &fty, body, ctx, state)?;
                                 Instruction::StructSet {
                                     struct_type_index: variant_type_idx,
                                     field_index: fld(field_idx),
@@ -4484,23 +4752,9 @@ fn compileStmt(
                 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`.
-                let rt_vt = ctx.ret_type.as_ref().map(plumTypeToValtype);
-                if let Some(vt) = rt_vt {
-                    if let Some(rt @ PlumType::TBool) = ctx.ret_type.as_ref() {
-                        coerceTy(rt, &anyTy(), body, ctx.gc_types);
-                    } else {
-                        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_) => {
@@ -4686,13 +4940,15 @@ fn exprHasResult(expr: &ast::Expr, ctx: &LocalCtx) -> bool {
             {
                 return !closureCallReturnsUnit(&call.name, ctx);
             }
-            ctx.func_sigs
-                .get(&call.name)
+            resolveCallee(ctx, expr, false, &call.name)
-                .map(|s| s.ret.is_some())
+                .map(|(_, s)| s.ret.is_some())
                 .unwrap_or(true)
         }
         ast::Expr::Attribute(attr) => match &attr.attr {
             ast::AttrKind::Method(call) => {
+                if let Some((_, s)) = resolveCallee(ctx, expr, false, "") {
+                    return s.ret.is_some();
+                }
                 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.
@@ -5318,10 +5574,16 @@ fn compileVariantEqArm(
             name
         ));
     }
+    let sty = ctx
+        .subject_ptypes
+        .borrow()
+        .get(&scratch_local)
+        .cloned()
+        .unwrap_or_else(|| PlumType::TVar("_".to_string()));
-    let variant_idx = *ctx.gc_types.variant_type_idx.get(name).ok_or_else(|| {
+    let variant_idx = ctx.gc_types.variantIdx(&sty, name).ok_or_else(|| {
         format!(
-            "codegen: variant '{}' missing from the GC type registry",
+            "codegen: variant '{}' of {} missing from the GC type registry",
-            name
+            name, sty
         )
     })?;
     // A single ref.test against the variant's exact concrete type replaces the old
@@ -5391,18 +5653,21 @@ fn compileVariantConstructorArm(
             fields.len()
         ));
     }
+    let sty = ctx
+        .subject_ptypes
+        .borrow()
+        .get(&scratch_local)
+        .cloned()
+        .unwrap_or_else(|| PlumType::TVar("_".to_string()));
-    let variant_idx = *ctx.gc_types.variant_type_idx.get(name).ok_or_else(|| {
+    let variant_idx = ctx.gc_types.variantIdx(&sty, name).ok_or_else(|| {
         format!(
-            "codegen: variant '{}' missing from the GC type registry",
+            "codegen: variant '{}' of {} missing from the GC type registry",
-            name
+            name, sty
         )
     })?;
-    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),
+    let inst_types = instFields(info, &sty);
-        None => field_types.clone(),
+    let field_types = inst_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
@@ -5498,7 +5763,7 @@ fn compileFieldPatterns(
     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 decl_ty = &field_types[fpos];
+    let decl_ty = &inst_types[fpos];
     let field_ty = &inst_types[fpos];
     let decl_vt = plumTypeToValtype(decl_ty);
     let inst_vt = plumTypeToValtype(field_ty);
@@ -5663,8 +5928,8 @@ fn compileFieldPatterns(
                     n
                 ));
             }
-            let variant_idx = *ctx.gc_types.variant_type_idx.get(n).ok_or_else(|| {
+            let variant_idx = ctx.gc_types.variantIdx(field_ty, n).ok_or_else(|| {
-                format!("codegen: variant '{}' missing from the GC type registry", n)
+                format!("codegen: variant '{}' of {} missing from the GC type registry", n, field_ty)
             })?;
             Instruction::LocalGet(container_local).encode(body);
             Instruction::StructGet {
@@ -5774,10 +6039,10 @@ fn compileFieldPatterns(
                     inner_fields.len()
                 ));
             }
-            let inner_variant_idx = *ctx.gc_types.variant_type_idx.get(name).ok_or_else(|| {
+            let inner_variant_idx = ctx.gc_types.variantIdx(field_ty, name).ok_or_else(|| {
                 format!(
-                    "codegen: variant '{}' missing from the GC type registry",
+                    "codegen: variant '{}' of {} missing from the GC type registry",
-                    name
+                    name, field_ty
                 )
             })?;
             let key = pat as *const ast::CasePattern as usize;
@@ -5786,8 +6051,8 @@ fn compileFieldPatterns(
                     .to_string()
             })?;
             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);
+            let inner_field_types = inner_inst_types.clone();
             Instruction::LocalGet(container_local).encode(body);
             Instruction::StructGet {
@@ -5891,9 +6156,10 @@ fn compileExpr(
                 // value (e.g. `each(double)`) — push its zero-capture trampoline
                 // closure's (pre-built by the `start` function) global.
                 None => {
+                    let fty = namedRefType(name, expr, ctx.types, ctx.func_sigs);
                     let global_idx = *ctx
                         .named_fn_values
-                        .get(name.as_str())
+                        .get(&(name.clone(), fty))
                         .ok_or_else(|| format!("undeclared variable '{}'", name))?;
                     Instruction::GlobalGet(global_idx).encode(body);
                 }
@@ -5935,34 +6201,16 @@ fn compileExpr(
                         enum_name
                     )
                 })?;
-            let success_idx =
-                *ctx.gc_types
-                    .variant_type_idx
-                    .get(success_name)
+            let success_idx = ctx.gc_types.variantIdx(&inner_ty, success_name).ok_or_else(|| {
-                    .ok_or_else(|| {
-                        format!(
-                            "codegen: variant '{}' missing from the GC type registry",
+                format!("codegen: variant '{}' of {} missing from the GC type registry", success_name, inner_ty)
-                            success_name
-                        )
-                    })?;
+            })?;
-            let failure_idx =
-                *ctx.gc_types
-                    .variant_type_idx
-                    .get(failure_name)
+            let failure_idx = ctx.gc_types.variantIdx(&inner_ty, failure_name).ok_or_else(|| {
-                    .ok_or_else(|| {
-                        format!(
-                            "codegen: variant '{}' missing from the GC type registry",
+                format!("codegen: variant '{}' of {} missing from the GC type registry", failure_name, inner_ty)
-                            failure_name
-                        )
-                    })?;
+            })?;
             // The payload slot is declared at its generic type (`T` -> `$Obj`); the
             // value this expression yields is at its instantiated type.
-            let raw_success_ty = success_info
-                .field_types
-                .first()
-                .cloned()
-                .unwrap_or(PlumType::TUnit);
             let success_ty = inferLocalType(expr, ctx);
+            let raw_success_ty = success_ty.clone();
             let success_vt = plumTypeToValtype(&success_ty);
             let key = expr as *const ast::Expr as usize;
@@ -5979,22 +6227,20 @@ fn compileExpr(
             // 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.as_ref().and_then(plum_checker::nominalName) {
-                Some(outer_enum) if outer_enum != enum_name => {
-                    plum_checker::tryOperatorVariants(outer_enum, &cctx)
+                Some(outer_enum) => plum_checker::tryOperatorVariants(outer_enum, &cctx)
-                        .map(|(_, _, fname, _)| fname)
+                    .map(|(_, _, fname, _)| fname),
-                }
                 _ => None,
             };
             let mut rewrap: Option<(u32, i32)> = None;
             if let Some(outer_err_name) = outer_err {
+                let outer_ty = ctx.ret_type.clone().unwrap_or(PlumType::TUnit);
-                let outer_idx = *ctx
+                let outer_idx = ctx
                     .gc_types
-                    .variant_type_idx
-                    .get(outer_err_name)
+                    .variantIdx(&outer_ty, outer_err_name)
                     .ok_or_else(|| {
                         format!(
-                            "codegen: variant '{}' missing from the GC type registry",
+                            "codegen: variant '{}' of {} missing from the GC type registry",
-                            outer_err_name
+                            outer_err_name, outer_ty
                         )
                     })?;
                 if outer_idx != failure_idx {
@@ -6057,32 +6303,14 @@ fn compileExpr(
                         enum_name
                     )
                 })?;
-            let success_idx =
-                *ctx.gc_types
-                    .variant_type_idx
-                    .get(success_name)
+            let success_idx = ctx.gc_types.variantIdx(&left_ty, success_name).ok_or_else(|| {
-                    .ok_or_else(|| {
-                        format!(
-                            "codegen: variant '{}' missing from the GC type registry",
+                format!("codegen: variant '{}' of {} missing from the GC type registry", success_name, left_ty)
-                            success_name
-                        )
-                    })?;
+            })?;
-            let failure_idx =
-                *ctx.gc_types
-                    .variant_type_idx
-                    .get(failure_name)
+            let failure_idx = ctx.gc_types.variantIdx(&left_ty, failure_name).ok_or_else(|| {
-                    .ok_or_else(|| {
-                        format!(
-                            "codegen: variant '{}' missing from the GC type registry",
+                format!("codegen: variant '{}' of {} missing from the GC type registry", failure_name, left_ty)
-                            failure_name
-                        )
-                    })?;
+            })?;
-            let raw_success_ty = success_info
-                .field_types
-                .first()
-                .cloned()
-                .unwrap_or(PlumType::TUnit);
             let success_ty = inferLocalType(expr, ctx);
+            let raw_success_ty = success_ty.clone();
             let success_vt = plumTypeToValtype(&success_ty);
             let key = expr as *const ast::Expr as usize;
@@ -6235,6 +6463,17 @@ fn compileExpr(
                 }
                 // `TVar`/`TUnit` share `Int`'s `i64` wasm representation (see
                 // `plumTypeToValtype`) — an unresolved generic defaults the same way.
+                PlumType::TByte => {
+                    match c.op {
+                        ast::CmpOp::Lt => Instruction::I32LtU,
+                        ast::CmpOp::Lte => Instruction::I32LeU,
+                        ast::CmpOp::Eq => Instruction::I32Eq,
+                        ast::CmpOp::Neq | ast::CmpOp::NotEq2 => Instruction::I32Ne,
+                        ast::CmpOp::Gte => Instruction::I32GeU,
+                        ast::CmpOp::Gt => Instruction::I32GtU,
+                    }
+                    .encode(body);
+                }
                 PlumType::TInt | PlumType::TVar(_) | PlumType::TUnit => {
                     match c.op {
                         ast::CmpOp::Lt => Instruction::I64LtS,
@@ -6336,7 +6575,7 @@ fn compileExpr(
                     .is_some_and(|info| info.field_types == [ty.clone()])
             });
             if (call.name == "Int" || call.name == "Float" || call.name == "Byte")
-                && !ctx.func_ids.contains_key(&call.name)
+                && !ctx.known_fns.contains(&call.name)
                 && !is_same_type_variant_wrap
                 && single_arg_ty.is_some()
             {
@@ -6362,7 +6601,7 @@ fn compileExpr(
                 compileClosureCall(call, expr, body, ctx, state)?;
             // `Bad(x)` / `Bad()` — an uppercase name the checker typed as a tag
             // union is a tag literal, even when a declared variant shares its name.
-            } else if !ctx.func_ids.contains_key(&call.name)
+            } else if !ctx.known_fns.contains(&call.name)
                 && call.args.len() <= 1
                 && call
                     .name
@@ -6404,6 +6643,7 @@ fn compileExpr(
                     &init_call,
                     &PlumType::TNamed(call.name.clone()),
                     expr,
+                    false,
                     body,
                     ctx,
                     state,
@@ -6411,16 +6651,10 @@ fn compileExpr(
             } 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)
+                let (func_idx, sig) = resolveCallee(ctx, expr, false, &call.name)
                     .ok_or_else(|| format!("unknown function '{}'", call.name))?;
                 compileCallArgs(&call.name, &call.args, sig, body, ctx, state)?;
-                let func_idx = ctx
-                    .func_ids
-                    .get(&call.name)
-                    .ok_or_else(|| format!("unknown function '{}'", call.name))?;
-                Instruction::Call(*func_idx).encode(body);
+                Instruction::Call(func_idx).encode(body);
                 coerceCallResult(&sig.decl_ret, expr, body, ctx);
             }
         }
@@ -6443,7 +6677,8 @@ fn compileExpr(
                     compileTagLiteral(n, None, body, ctx, state)?
                 }
                 Some(info) if info.field_types.is_empty() => {
+                    let ety = enumTypeOfExpr(expr, info, ctx);
-                    let global_idx = *ctx.singleton_globals.get(n)
+                    let global_idx = *ctx.singleton_globals.get(&(ety, n.clone()))
                     .unwrap_or_else(|| panic!("internal codegen error: payload-free variant '{}' has no singleton global", n));
                     Instruction::GlobalGet(global_idx).encode(body);
                 }
@@ -6511,6 +6746,7 @@ fn compileExpr(
                 &init_call,
                 &PlumType::TNamed(call.type_name.clone()),
                 expr,
+                false,
                 body,
                 ctx,
                 state,
@@ -6535,21 +6771,22 @@ fn compileExpr(
                 .enum_variants
                 .get(&call.type_name)
                 .expect("just checked is_some");
+            let ety = enumTypeOfExpr(expr, info, ctx);
+            let field_tys = plum_checker::variantFields(info, &ety);
-            let variant_idx = *ctx
+            let variant_idx = ctx
                 .gc_types
-                .variant_type_idx
-                .get(&call.type_name)
+                .variantIdx(&ety, &call.type_name)
                 .ok_or_else(|| {
                     format!(
-                        "codegen: variant '{}' missing from the GC type registry",
+                        "codegen: variant '{}' of {} missing from the GC type registry",
-                        call.type_name
+                        call.type_name, ety
                     )
                 })?;
             let field_names = info.field_names.clone();
             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) => compileExprInto(&fa.value, &info.field_types[field_idx], body, ctx, state)?,
+                    Some(fa) => compileExprInto(&fa.value, &field_tys[field_idx], 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
@@ -6595,7 +6832,7 @@ fn compileExpr(
                     compileFieldRead(&attr.object, field_name, &obj_ty, expr, body, ctx, state)?
                 }
                 ast::AttrKind::Method(call) => {
-                    compileMethodCall(&attr.object, call, &obj_ty, expr, body, ctx, state)?
+                    compileMethodCall(&attr.object, call, &obj_ty, expr, false, body, ctx, state)?
                 }
             }
         }
@@ -6644,6 +6881,24 @@ fn coerceCallResultTo(decl_ret: &PlumType, want: &PlumType, body: &mut Vec<u8>,
 /// 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.
+/// The wasm function (and signature) a call expression invokes: its checked
+/// instantiation if the callee is generic, else the plain function `plain_key`.
+fn resolveCallee<'c>(
+    ctx: &'c LocalCtx,
+    call_expr: &ast::Expr,
+    implicit: bool,
+    plain_key: &str,
+) -> Option<(u32, &'c FuncSig)> {
+    let ptr = call_expr as *const ast::Expr as usize;
+    if let Some(id) = ctx.call_inst.get(&(ctx.unit_inst, ptr, implicit)) {
+        return ctx.inst_funcs.get(id).map(|(f, s)| (*f, s));
+    }
+    match (ctx.func_ids.get(plain_key), ctx.func_sigs.get(plain_key)) {
+        (Some(f), Some(s)) => Some((*f, s)),
+        _ => None,
+    }
+}
 fn compileCallArgs(
     func_key: &str,
     args: &[ast::Arg],
@@ -6682,7 +6937,7 @@ fn compileCallArgs(
                     None => compileExpr(argExprOf(arg), body, ctx, state)?,
                 }
             }
-            compileDefaultArgs(func_key, args.len(), body, ctx, state)?;
+            compileDefaultArgs(func_key, sig, args.len(), body, ctx, state)?;
         }
     }
     Ok(())
@@ -6714,6 +6969,10 @@ fn compileFieldRead(
         }
     };
     let want = &inferLocalType(expr, ctx);
+    let ety = match obj_ty {
+        PlumType::TStr => PlumType::TNamed("Str".to_string()),
+        t => t.clone(),
+    };
     // 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.
@@ -6722,20 +6981,15 @@ fn compileFieldRead(
             .iter()
             .position(|(n, _)| n == field_name)
             .ok_or_else(|| format!("codegen: no field '{}' on enum '{}'", field_name, class_name))?;
-        let super_type_idx = *ctx
+        let super_type_idx = ctx.gc_types.superIdx(&ety).ok_or_else(|| {
-            .gc_types
-            .enum_super_type_idx
-            .get(&class_name)
-            .ok_or_else(|| {
-                format!("codegen: enum '{}' missing from the GC type registry", class_name)
+            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);
-        coerceTy(&params[field_idx].1, want, body, ctx.gc_types);
         return Ok(());
     }
     // Not a discriminant enum: `class_name` is an ordinary enum, and the checker
@@ -6755,16 +7009,16 @@ fn compileFieldRead(
         .iter()
         .position(|n| n == field_name)
         .expect("just found by this field name");
-    let variant_type_idx = *ctx
+    let variant_type_idx = ctx
         .gc_types
-        .variant_type_idx
-        .get(variant_name)
+        .variantIdx(&ety, variant_name)
         .ok_or_else(|| {
             format!(
-                "codegen: variant '{}' missing from the GC type registry",
+                "codegen: variant '{}' of {} missing from the GC type registry",
-                variant_name
+                variant_name, ety
             )
         })?;
+    let _ = (info, want);
     compileExpr(object, body, ctx, state)?;
     Instruction::RefCastNonNull(HeapType::Concrete(variant_type_idx)).encode(body);
     Instruction::StructGet {
@@ -6772,7 +7026,6 @@ fn compileFieldRead(
         field_index: fld(field_idx),
     }
     .encode(body);
-    coerceTy(&info.field_types[field_idx], want, body, ctx.gc_types);
     Ok(())
 }
@@ -6824,10 +7077,29 @@ fn compileMethodCall(
     call: &ast::FnCall,
     obj_ty: &PlumType,
     result_expr: &ast::Expr,
+    implicit: bool,
     body: &mut Vec<u8>,
     ctx: &LocalCtx,
     state: &mut ModuleState,
 ) -> Result<(), String> {
+    // A call the checker resolved to a generic instantiation.
+    if let Some((func_idx, sig)) = ctx
+        .call_inst
+        .get(&(ctx.unit_inst, result_expr as *const ast::Expr as usize, implicit))
+        .and_then(|id| ctx.inst_funcs.get(id))
+        .map(|(f, s)| (*f, s))
+    {
+        let recv = plum_checker::methodReceiverName(obj_ty).unwrap_or_default();
+        if matches!(object, ast::Expr::TypeName(n) if *n == recv) {
+            pushSelfPlaceholder(sig.params[0], body);
+        } else {
+            compileExpr(object, body, ctx, state)?;
+        }
+        compileCallArgs(&call.name, &call.args, sig, body, ctx, state)?;
+        Instruction::Call(func_idx).encode(body);
+        coerceCallResult(&sig.decl_ret, result_expr, body, ctx);
+        return Ok(());
+    }
     // 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(_)) {
@@ -6892,7 +7164,12 @@ fn compileMethodCall(
     // 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);
+        let _ = &dispatch_name;
+        let vt = ctx
+            .func_sigs
+            .get(&key)
+            .and_then(|s| s.params.first().copied())
+            .unwrap_or(ValType::I32);
         pushSelfPlaceholder(vt, body);
     } else {
         if let Some(variant) = &box_variant {
@@ -6971,14 +7248,12 @@ fn compileDynCall(
 /// same as before this feature existed.
 fn compileDefaultArgs(
     func_key: &str,
+    sig: &FuncSig,
     supplied_count: usize,
     body: &mut Vec<u8>,
     ctx: &LocalCtx,
     state: &mut ModuleState,
 ) -> Result<(), String> {
-    let Some(sig) = ctx.func_sigs.get(func_key) else {
-        return Ok(());
-    };
     for (i, default) in sig.param_defaults.iter().enumerate().skip(supplied_count) {
         let default_expr = default.as_ref().ok_or_else(|| {
             format!(
@@ -6997,11 +7272,13 @@ fn compileDefaultArgs(
 fn compileVariantConstruction(
     info: &EnumVariantInfo,
     call: &ast::FnCall,
-    _expr: &ast::Expr,
+    expr: &ast::Expr,
     body: &mut Vec<u8>,
     ctx: &LocalCtx,
     state: &mut ModuleState,
 ) -> Result<(), String> {
+    let ety = enumTypeOfExpr(expr, info, ctx);
+    let field_tys = plum_checker::variantFields(info, &ety);
     if call.args.len() != info.field_types.len() {
         return Err(format!(
             "codegen: variant '{}' expects {} arg(s), got {}",
@@ -7010,20 +7287,19 @@ fn compileVariantConstruction(
             call.args.len()
         ));
     }
-    let variant_type_idx = *ctx
+    let variant_type_idx = ctx
         .gc_types
-        .variant_type_idx
-        .get(&call.name)
+        .variantIdx(&ety, &call.name)
         .ok_or_else(|| {
             format!(
-                "codegen: variant '{}' missing from the GC type registry",
+                "codegen: variant '{}' of {} missing from the GC type registry",
-                call.name
+                call.name, ety
             )
         })?;
     if info.field_types.is_empty() {
         // Pre-allocated singleton (this migration plan's Decision 2) — not a fresh
         // struct.new per reference.
-        let global_idx = *ctx.singleton_globals.get(&call.name).ok_or_else(|| {
+        let global_idx = *ctx.singleton_globals.get(&(ety.clone(), call.name.clone())).ok_or_else(|| {
             format!(
                 "codegen: payload-free variant '{}' has no singleton global",
                 call.name
@@ -7044,7 +7320,7 @@ fn compileVariantConstruction(
             ast::Arg::Keyword { value, .. } => value,
             ast::Arg::Pair { value, .. } => value,
         };
-        match info.field_types.get(i) {
+        match field_tys.get(i) {
             Some(d) => compileExprInto(arg_expr, d, body, ctx, state)?,
             None => compileExpr(arg_expr, body, ctx, state)?,
         }
@@ -7155,7 +7431,7 @@ fn compileInterpolatedString(
                         } 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)?;
+                            compileMethodCall(expr, &to_str, &other, expr, true, body, ctx, state)?;
                         } else {
                             return Err(format!(
                                 "codegen: interpolating a value of type {} is not yet supported",
@@ -7184,7 +7460,7 @@ fn compileClosureLiteral(
     ctx: &LocalCtx,
     _state: &mut ModuleState,
 ) -> Result<(), String> {
-    let key = cl as *const ast::Closure as usize;
+    let key = (ctx.unit_idx, cl as *const ast::Closure as usize);
     let info = ctx.closures.get(&key).ok_or_else(|| {
         "internal codegen error: closure literal was not discovered by the discovery pre-pass"
             .to_string()
@@ -7210,18 +7486,12 @@ fn compileClosureLiteral(
     Ok(())
 }
-/// Compiles a call to a closure-typed local via `call_indirect`, using the erased
+/// Compiles a call to a closure-typed local via `call_indirect` with the typed
-/// closure ABI (`ClosureSigKey`): every argument is converted to `anyref`
+/// closure ABI: push the env, each argument in its own representation, then the
-/// (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`).
-/// 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).
+/// table index (the `call_indirect` operand).
 fn compileClosureCall(
     call: &ast::FnCall,
-    call_expr: &ast::Expr,
+    _call_expr: &ast::Expr,
     body: &mut Vec<u8>,
     ctx: &LocalCtx,
     state: &mut ModuleState,
@@ -7231,16 +7501,17 @@ 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;
+    let Some(PlumType::TFun(ps, r)) = ctx.local_decl_types.get(&call.name) else {
+        return Err(format!("codegen: '{}' is not a function-typed local", call.name));
+    };
+    let key = closureSigKey(ps, r, ctx.gc_types);
-    let type_index = *ctx.closure_call_types.get(&call.args.len()).ok_or_else(|| {
+    let type_index = *ctx.closure_call_types.get(&key).ok_or_else(|| {
         format!(
-            "internal codegen error: no call_indirect type for closure '{}' with {} args",
+            "internal codegen error: no call_indirect type for closure '{}' of type fn{:?}",
-            call.name,
+            call.name, key
-            call.args.len()
         )
     })?;
-    let any = ValType::Ref(RefType::ANYREF);
-    // env (closure struct field 1)
     Instruction::LocalGet(closure_local).encode(body);
     Instruction::RefCastNonNull(HeapType::Concrete(closure_type_idx)).encode(body);
     Instruction::StructGet {
@@ -7248,11 +7519,12 @@ fn compileClosureCall(
         field_index: 1,
     }
     .encode(body);
-    // real arguments, boxed to the erased ABI
-    for arg in &call.args {
+    for (i, arg) in call.args.iter().enumerate() {
+        match ps.get(i) {
+            Some(p) => compileExprInto(argExprOf(arg), p, body, ctx, state)?,
-        compileExprAs(argExprOf(arg), Some(any), body, ctx, state)?;
+            None => compileExpr(argExprOf(arg), body, ctx, state)?,
+        }
     }
-    // table index (closure struct field 0) — the call_indirect operand
     Instruction::LocalGet(closure_local).encode(body);
     Instruction::RefCastNonNull(HeapType::Concrete(closure_type_idx)).encode(body);
     Instruction::StructGet {
@@ -7265,13 +7537,6 @@ 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 {
-        coerceTy(&anyTy(), &inferLocalType(call_expr, ctx), body, ctx.gc_types);
-    }
     Ok(())
 }
@@ -7287,22 +7552,19 @@ fn closureCallReturnsUnit(name: &str, ctx: &LocalCtx) -> bool {
 }
 /// Compiles a closure literal's own body into a standalone wasm function with the
-/// erased closure ABI `(env: anyref, a1: anyref, ..., an: anyref) -> anyref`
+/// typed closure ABI `(env: anyref, p1: T1, ..., pn: Tn) -> R` (see `ClosureSigKey`).
-/// (see `ClosureSigKey`). Local 0 is the env pointer; locals `1..=n` are the raw
-/// incoming params; typed locals follow — one per closure param (holding the
+/// Local 0 is the env; locals `1..=n` are the params in their own representation;
-/// raw param unboxed/cast to its real Plum type by the prologue), one per
-/// captured free variable (restored from the env struct), then the body's own
+/// captured free variables (restored from the env struct) and the body's own named
-/// named locals and scratch slots. The tail value is boxed back to `anyref` (a
-/// `Unit` body yields a null `anyref`).
+/// locals and scratch slots follow.
 fn compileClosureBody(
     cl: &ast::Closure,
     info: &ClosureInfo,
     ctx: &CompileCtx,
     state: &mut ModuleState,
+    unit: &UnitRef,
 ) -> Result<Vec<u8>, String> {
     let mut body = Vec::new();
-    // 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 {
@@ -7315,7 +7577,7 @@ fn compileClosureBody(
     }
     let mut collector = Collector {
-        types: &ctx.types,
+        types: unit.types,
         enum_variants: &ctx.enum_variants,
         named: Vec::new(),
         named_set: Default::default(),
@@ -7328,19 +7590,12 @@ fn compileClosureBody(
     };
     collector.walkBlock(&cl.body);
-    // ---- local index layout ----
-    // [env_ptr][raw params][typed params][free-var locals][named...][match][scratch]
+    // ---- local index layout: [env][params][free vars][named...][match][scratch] ----
     let mut locals: HashMap<String, u32> = HashMap::new();
     let mut groups: Vec<ValType> = Vec::new();
-    let mut idx = 0u32;
+    let mut idx = 1u32;
-    idx += 1 + cl.params.len() as u32; // env + raw params (all in the signature)
-    let mut param_prologue: Vec<(u32, u32, PlumType)> = Vec::new(); // (raw, typed, ptype)
-    for (i, (name, pty)) in cl.params.iter().zip(info.param_ptypes.iter()).enumerate() {
-        let vt = plumTypeToValtype(pty);
+    for name in cl.params.iter() {
         locals.insert(name.clone(), idx);
-        groups.push(vt);
-        param_prologue.push((i as u32 + 1, idx, pty.clone()));
         idx += 1;
     }
     for (name, ty) in &info.free_vars {
@@ -7369,8 +7624,8 @@ fn compileClosureBody(
     }
     let nested_class_scratch_base = idx;
-    for vname in &collector.nested_class_scratch_types {
+    for (sty, vname) in &collector.nested_class_scratch_types {
-        let variant_idx = withGcTypes(|r| classOrVariantTypeIdx(r, vname));
+        let variant_idx = withGcTypes(|r| scratchTypeIdx(r, sty, vname));
         groups.push(gcRef(variant_idx));
         idx += 1;
     }
@@ -7388,6 +7643,7 @@ fn compileClosureBody(
         groups.push(ValType::I32); // loop index
         idx += 2;
     }
+    let _ = idx;
     if groups.is_empty() {
         body.push(0);
@@ -7399,17 +7655,10 @@ fn compileClosureBody(
         }
     }
-    // Prologue: convert each raw `anyref` param to its real representation.
-    for (raw, typed, pty) in &param_prologue {
-        Instruction::LocalGet(*raw).encode(&mut body);
-        coerceTy(&anyTy(), pty, &mut body, &ctx.gc_types);
-        Instruction::LocalSet(*typed).encode(&mut body);
-    }
-    // Restore each captured free variable from the env struct (local 0, statically
+    // Restore each captured free variable from the env struct at entry.
-    // `anyref` — `ref.cast` down to THIS closure's own concrete env type) at entry.
     for (i, (name, _)) in info.free_vars.iter().enumerate() {
         let local_idx = *locals.get(name).expect("free var local was assigned above");
-        Instruction::LocalGet(0).encode(&mut body); // env pointer
+        Instruction::LocalGet(0).encode(&mut body);
         Instruction::RefCastNonNull(HeapType::Concrete(info.env_type_idx)).encode(&mut body);
         Instruction::StructGet {
             struct_type_index: info.env_type_idx,
@@ -7429,7 +7678,12 @@ fn compileClosureBody(
         variadic_for_scratch: collector.variadic_for_scratch,
         func_ids: &ctx.func_ids,
         func_sigs: &ctx.func_sigs,
+        inst_funcs: &ctx.inst_funcs,
+        call_inst: &ctx.call_inst,
+        known_fns: &ctx.known_fns,
+        unit_idx: unit.idx,
+        unit_inst: unit.inst,
-        types: &ctx.types,
+        types: unit.types,
         local_decl_types: decl_types,
         closures: &ctx.closures,
         closure_call_types: &ctx.closure_call_types,
@@ -7454,11 +7708,9 @@ fn compileClosureBody(
     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, Some(ret_vt))?;
-        coerceTy(&info.ret_ptype, &anyTy(), &mut body, &ctx.gc_types);
     }
     Instruction::End.encode(&mut body);

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

@@ -1221,7 +1221,7 @@ fn countTypes(bytes: &[u8]) -> usize {
 }
 #[test]
-fn specializations_share_gc_type() {
+fn distinct_instances_get_distinct_gc_types() {
     let prog = |second: &str| {
         format!(
             "{}\
@@ -1238,7 +1238,7 @@ fun main() -> Int = 1
     };
     let same = assertValid(&prog("[A]"));
     let wider = assertValid(&prog("[A, B]"));
-    assert_eq!(countTypes(&same), countTypes(&wider));
+    assert!(countTypes(&same) < countTypes(&wider));
 }
 #[test]
@@ -1742,29 +1742,221 @@ fun main() -> Int =
     assert_eq!(runMerged::<i64>("trylist", src), 41);
 }
+/// Compiles `src` (merged with the real std) and returns every compiled function key/name.
+fn compiledKeys(name: &str, src: &str) -> (Vec<u8>, Vec<String>) {
+    let dir = std::env::temp_dir().join(format!("plum_t3k_{}_{}", name, std::process::id()));
-#[test]
+    std::fs::create_dir_all(&dir).unwrap();
+    let path = dir.join("main.plum");
-fn one_copy_per_generic() {
+    std::fs::write(&path, src).unwrap();
+    let source = plum_core::loadAndMerge(&path, &repoRoot()).expect("load");
+    let r = plum_wasm_codegen::compileSourceWithFunctions(&source).expect("compile");
+    let _ = std::fs::remove_dir_all(&dir);
+    wasmparser::validate(&r.0).expect("valid wasm");
+    r
+}
-    let src = "\
+const STD_HEAD: &str = "\
 import std/Str
 import std/Number
 import std/Try
 import std/List
+";
+#[test]
+fn one_copy_per_distinct_type() {
+    let src = format!("{}\
 fun main() -> Int =
   a := List(1, 2).map(|n| n + 1)
   b := List(\"x\", \"y\").map(|s| s + \"!\")
   a.length() + b.length()
-";
+", STD_HEAD);
-    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");
+    let (_, keys) = compiledKeys("copy2", &src);
-    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();
+    let maps: Vec<&String> = keys.iter().filter(|k| k.starts_with("List[") && k.contains("].map")).collect();
-    assert_eq!(maps.len(), 1, "got {:?}", keys);
+    assert_eq!(maps.len(), 2, "got {:?}", maps);
+    assert!(keys.iter().any(|k| k.starts_with("List[Int].map")), "{:?}", maps);
+    assert!(keys.iter().any(|k| k.starts_with("List[Str].map")), "{:?}", maps);
     assert!(!keys.iter().any(|k| k.contains('$')), "mangled names remain");
+    let src = format!("{}\
+fun main() -> Int =
+  a := List(1, 2).map(|n| n + 1)
+  b := List(3).map(|n| n * 2)
+  a.length() + b.length()
+", STD_HEAD);
+    let (_, keys) = compiledKeys("copy1", &src);
+    let maps: Vec<&String> = keys.iter().filter(|k| k.starts_with("List[") && k.contains("].map")).collect();
+    assert_eq!(maps.len(), 1, "got {:?}", maps);
+}
+#[test]
+fn unreachable_generic_not_emitted() {
+    let src = format!("{}\
+fun neverUsed(x: T) -> T =
+  x
+fun main() -> Int =
+  List(1, 2).length()
+", STD_HEAD);
+    let (_, keys) = compiledKeys("unreach", &src);
+    assert!(!keys.iter().any(|k| k.contains("neverUsed")), "{:?}", keys);
+}
+/// `(function name, body operators as debug strings)` for every function with a name.
+fn namedBodies(bytes: &[u8]) -> Vec<(String, Vec<String>)> {
+    let mut names: std::collections::HashMap<u32, String> = Default::default();
+    let mut bodies = Vec::new();
+    let mut imports = 0u32;
+    for payload in wasmparser::Parser::new(0).parse_all(bytes) {
+        match payload.unwrap() {
+            wasmparser::Payload::ImportSection(s) => {
+                imports = s.count();
+            }
+            wasmparser::Payload::CustomSection(c) => {
+                if let wasmparser::KnownCustom::Name(r) = c.as_known() {
+                    for n in r {
+                        if let wasmparser::Name::Function(m) = n.unwrap() {
+                            for e in m {
+                                let e = e.unwrap();
+                                names.insert(e.index, e.name.to_string());
+                            }
+                        }
+                    }
+                }
+            }
+            wasmparser::Payload::CodeSectionEntry(b) => {
+                let mut ops = Vec::new();
+                let mut r = b.get_operators_reader().unwrap();
+                while !r.eof() {
+                    ops.push(format!("{:?}", r.read().unwrap()));
+                }
+                bodies.push(ops);
+            }
+            _ => {}
+        }
+    }
+    bodies
+        .into_iter()
+        .enumerate()
+        .map(|(i, ops)| (names.get(&(imports + i as u32)).cloned().unwrap_or_default(), ops))
+        .collect()
+}
+#[test]
+fn no_boxes_in_list_int_map() {
+    let src = format!("{}\
+fun main() -> Int =
+  List(1, 2).map(|n| n + 1).length()
+", STD_HEAD);
+    let (bytes, _) = compiledKeys("nobox", &src);
+    let bodies = namedBodies(&bytes);
+    let (name, ops) = bodies
+        .iter()
+        .find(|(n, _)| n.starts_with("List[Int].map"))
+        .expect("List[Int].map compiled");
+    assert!(!ops.is_empty(), "{name}");
+    let box_idx: Vec<u32> = {
+        // function indices of the box helpers
+        let mut v = Vec::new();
+        let mut names: Vec<(u32, String)> = Vec::new();
+        for payload in wasmparser::Parser::new(0).parse_all(&bytes) {
+            if let wasmparser::Payload::CustomSection(c) = payload.unwrap() {
+                if let wasmparser::KnownCustom::Name(r) = c.as_known() {
+                    for n in r {
+                        if let wasmparser::Name::Function(m) = n.unwrap() {
+                            for e in m {
+                                let e = e.unwrap();
+                                names.push((e.index, e.name.to_string()));
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        for (i, n) in names {
+            if n.starts_with("box.") {
+                v.push(i);
+            }
+        }
+        v
+    };
+    assert!(!box_idx.is_empty());
+    for op in ops {
+        for b in &box_idx {
+            assert_ne!(*op, format!("Call {{ function_index: {} }}", b), "{name} boxes: {ops:?}");
+        }
+    }
+}
+#[test]
+fn array_int_native() {
+    let src = format!("{}\
+fun main() -> Int =
+  List(1, 2).length()
+", STD_HEAD);
+    let (bytes, _) = compiledKeys("arrint", &src);
+    let mut found_i64 = false;
+    let mut found_anyref = false;
+    for payload in wasmparser::Parser::new(0).parse_all(&bytes) {
+        if let wasmparser::Payload::TypeSection(s) = payload.unwrap() {
+            for g in s {
+                for t in g.unwrap().types() {
+                    if let wasmparser::CompositeInnerType::Array(a) = &t.composite_type.inner {
+                        if a.0.mutable && a.0.element_type == wasmparser::StorageType::Val(wasmparser::ValType::I64) {
+                            found_i64 = true;
+                        }
+                        if a.0.element_type == wasmparser::StorageType::Val(wasmparser::ValType::Ref(wasmparser::RefType::ANYREF)) {
+                            found_anyref = true;
+                        }
+                    }
+                }
+            }
+        }
+    }
+    assert!(found_i64, "no `array (mut i64)` declared");
+    assert!(!found_anyref, "an anyref array remains");
+}
+#[test]
+fn generic_tag_payload() {
+    let src = format!("{}\
+fun fail(x: T) -> Try[Int, [Bad(T)]] =
+  Err(Bad(x))
+fun main() -> Int =
+  match fail(7)
+    Ok(v) => v
+    Err(Bad(n)) => n
+", STD_HEAD);
+    assert_eq!(runMerged::<i64>("gentag", &src), 7);
+}
+#[test]
+fn closure_typed_abi() {
+    let src = format!("{}\
+fun apply(f: fn(Int) -> Int, x: Int) -> Int =
+  f(x)
+fun main() -> Int =
+  apply(|n| n + 1, 41)
+", STD_HEAD);
+    let (bytes, _) = compiledKeys("clabi", &src);
+    let mut found = false;
+    for payload in wasmparser::Parser::new(0).parse_all(&bytes) {
+        if let wasmparser::Payload::TypeSection(s) = payload.unwrap() {
+            for g in s {
+                for t in g.unwrap().types() {
+                    if let wasmparser::CompositeInnerType::Func(f) = &t.composite_type.inner {
+                        if f.params() == [wasmparser::ValType::Ref(wasmparser::RefType::ANYREF), wasmparser::ValType::I64]
+                            && f.results() == [wasmparser::ValType::I64]
+                        {
+                            found = true;
+                        }
+                    }
+                }
+            }
+        }
+    }
+    assert!(found, "no (anyref, i64) -> i64 closure type");
 }
 // ---- built-in Bool (i32; no `import std/Bool`) ----