7d25f15 | plum | pyrossh

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

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

7d25f15 — Peter John 2026-10-26T10:03:07+05:30

refactor!: delete the monomorphizer; List on Array; reject bare generic types

Files changed (17) hide show

plum-checker/src/lib.rs +119 -149
plum-checker/src/monomorphize.rs +0 -3287
plum-checker/tests/checker_tests.rs +55 -118
plum-checker/tests/monomorphize_tests.rs +0 -191
plum-cli/src/main.rs +19 -23
plum-examples/functions.plum +4 -4
plum-examples/match.plum +1 -1
plum-examples/types.plum +2 -2
plum-std/Array.plum +12 -10
plum-std/Json.plum +1 -1
plum-std/List.plum +165 -318
plum-std/Map.plum +56 -84
plum-std/Number.plum +1 -1
plum-std/Str.plum +3 -3
plum-std/Testing.plum +1 -6
plum-std/Try.plum +2 -2
plum-wasm-codegen/src/lib.rs +110 -17

plum-checker/src/lib.rs CHANGED Viewed

@@ -2,7 +2,6 @@
 // naming convention), not Rust's idiomatic snake_case — silence the resulting lint.
 #![allow(non_snake_case)]
-pub mod monomorphize;
 pub mod types;
 use plum_core::ast;
@@ -183,8 +182,32 @@ fn bindMatch(pattern: &PlumType, actual: &PlumType, b: &mut Binds) {
     }
 }
+/// A single uppercase letter (`T`, `U`, `K`, ...) is the grammar's only legal
+/// spelling for a generic type parameter.
-fn isGenericName(n: &str) -> bool {
+pub fn isGenericName(n: &str) -> bool {
+    let mut chars = n.chars();
-    monomorphize::isGenericParamName(n)
+    match (chars.next(), chars.next()) {
+        (Some(c), None) => c.is_ascii_uppercase(),
+        _ => false,
+    }
+}
+/// The generic parameter names an `Enum` introduces: its own declared
+/// generics (`enum Link[T] = ...`), else every distinct single-uppercase-letter
+/// variant field type name in first-appearance order.
+pub fn enumGenericParams(e: &ast::Enum) -> Vec<String> {
+    if !e.generics.is_empty() {
+        return e.generics.iter().map(|g| g.name.clone()).collect();
+    }
+    let mut names: Vec<String> = Vec::new();
+    for v in &e.variants {
+        for field_ty in &v.fields {
+            if isGenericName(&field_ty.name) && !names.iter().any(|x| x == &field_ty.name) {
+                names.push(field_ty.name.clone());
+            }
+        }
+    }
+    names
 }
 /// Structural type conversion for UN-monomorphized source: `List[Int]` ->
@@ -371,66 +394,6 @@ fn parseTagUnion(s: &str) -> Option<PlumType> {
     Some(PlumType::TTags(tags))
 }
-/// Replaces every tag-union segment (`[...]`, but not the `[]Byte` slice
-/// spelling) of a mangled name with `Tags`, so specializations that differ
-/// only in their tag unions share one runtime type:
-/// `erasedEnumName("Try$Int$[A,B(Str)]") == "Try$Int$Tags"`.
-pub fn erasedEnumName(name: &str) -> String {
-    let chars: Vec<char> = name.chars().collect();
-    let mut out = String::new();
-    let mut i = 0;
-    while i < chars.len() {
-        if chars[i] == '[' && chars.get(i + 1) != Some(&']') {
-            let mut depth = 0;
-            while i < chars.len() {
-                match chars[i] {
-                    '[' => depth += 1,
-                    ']' => depth -= 1,
-                    _ => {}
-                }
-                i += 1;
-                if depth == 0 {
-                    break;
-                }
-            }
-            out.push_str("Tags");
-        } else {
-            out.push(chars[i]);
-            i += 1;
-        }
-    }
-    out
-}
-/// True when two mangled specialization names (`Try$Int$[A,B]`) are identical
-/// except for their tag-union segments and every `actual` union is a subset of
-/// the matching `expected` one (E is covariant).
-pub fn tagUnionSegmentsCompatible(expected: &str, actual: &str, ctx: &CheckCtx) -> bool {
-    let e_segs = splitTopLevel(expected, '$');
-    let a_segs = splitTopLevel(actual, '$');
-    if e_segs.len() != a_segs.len() || e_segs.len() < 2 {
-        return false;
-    }
-    let mut saw_union = false;
-    for (e, a) in e_segs.iter().zip(a_segs.iter()) {
-        if e == a {
-            continue;
-        }
-        let both_unions = e.starts_with('[')
-            && !e.starts_with("[]")
-            && a.starts_with('[')
-            && !a.starts_with("[]");
-        if !both_unions {
-            return false;
-        }
-        saw_union = true;
-        if unify(&plumTypeFromName(e), &plumTypeFromName(a), ctx).is_err() {
-            return false;
-        }
-    }
-    saw_union
-}
 /// Reserved `TypeEnv` key holding the enclosing function's declared return type.
 const RETURN_KEY: &str = "$return";
 /// `TypeEnv` key prefix marking a name as a top-level function (a local of the
@@ -585,12 +548,6 @@ pub fn unify(t1: &PlumType, t2: &PlumType, ctx: &CheckCtx) -> Result<(), String>
             }
             Ok(())
         }
-        // Two specializations differing only in their tag-union segments.
-        (PlumType::TNamed(a), PlumType::TNamed(b))
-            if a != b && tagUnionSegmentsCompatible(a, b, ctx) =>
-        {
-            Ok(())
-        }
         // A bare enum variant name (`Red`) can be used directly as a type — e.g.
         // a fn param `v: Red` — meaning "a `Color` value that is specifically
         // the `Red` variant". A variant's OWN constructions/references always
@@ -778,23 +735,7 @@ pub struct CheckCtx<'a> {
 /// `plum-wasm-codegen`, which needs the same tables to resolve `self`, field access,
 /// and method dispatch during code generation.
 pub fn buildGlobalTables(source: &ast::Source) -> (TypeEnv, MethodEnv, EnumVariants, EnumParams) {
-    buildTables(source, false)
-}
-/// `generic == true` builds the structural tables for UN-monomorphized source
-/// (`TApp`/`TParam`, generic schemes, trait signatures); `false` is the legacy
-/// shape codegen uses on monomorphized source.
-pub fn buildTables(
-    source: &ast::Source,
-    generic: bool,
-) -> (TypeEnv, MethodEnv, EnumVariants, EnumParams) {
-    let conv = |t: &ast::Type| {
-        if generic {
-            plumTypeFromAstG(t)
+    let conv = plumTypeFromAstG;
-        } else {
-            plumTypeFromAst(t)
-        }
-    };
     let mut global_env: TypeEnv = TypeEnv::new();
     let mut methods: MethodEnv = BTreeMap::new();
     let mut enum_variants: EnumVariants = BTreeMap::new();
@@ -877,11 +818,7 @@ pub fn buildTables(
                             field_types,
                             field_names,
                             values: v.values.clone(),
-                            generics: if generic {
-                                monomorphize::enumGenericParams(e)
+                            generics: enumGenericParams(e),
-                            } else {
-                                Vec::new()
-                            },
                         },
                     );
                 }
@@ -916,7 +853,7 @@ pub fn buildTables(
                 let fn_ty = PlumType::TFun(param_types, Box::new(ret));
                 if let Some(recv) = &f.type_param {
                     methods.insert((recv.clone(), f.name.clone()), fn_ty);
-                } else if generic {
+                } else {
                     global_env.insert(
                         format!("{}{}", GLOBAL_KEY, f.name),
                         TypeScheme::mono(PlumType::TUnit),
@@ -930,8 +867,6 @@ pub fn buildTables(
                             body: Box::new(fn_ty),
                         },
                     );
-                } else {
-                    global_env.insert(f.name.clone(), TypeScheme::mono(fn_ty));
                 }
             }
             ast::Item::Const(c) => {
@@ -973,13 +908,11 @@ pub fn buildTables(
                     let ret = m.returns.as_ref().map(&conv).unwrap_or(PlumType::TUnit);
                     let sig = PlumType::TFun(params, Box::new(ret));
                     methods.insert((t.name.clone(), m.name.clone()), sig.clone());
-                    if generic {
-                        // Looked up for calls on a bounded `TParam`.
+                    // Looked up for calls on a bounded `TParam`.
-                        global_env.insert(
+                    global_env.insert(
-                            format!("{}{}:{}", TRAIT_KEY, t.name, m.name),
+                        format!("{}{}:{}", TRAIT_KEY, t.name, m.name),
-                            TypeScheme::mono(sig),
+                        TypeScheme::mono(sig),
-                        );
+                    );
-                    }
                 }
             }
             _ => {}
@@ -1122,11 +1055,89 @@ pub fn typedSource(source: &ast::Source) -> CheckResult<TypedInfo> {
     })
 }
+/// A generic type named without type arguments (`p: Parcel` for `enum
+/// Parcel[T]`) has no known payload representation at runtime, so it is
+/// rejected in signatures and field types. Inside the generic's own methods the
+/// bare name is allowed (it means the receiver's own type).
+fn checkBareGenericTypes(source: &ast::Source) -> Vec<CheckError> {
+    let generic_enums: BTreeMap<&str, usize> = source
+        .items
+        .iter()
+        .filter_map(|i| match i {
+            ast::Item::Enum(e) if !e.generics.is_empty() => Some((e.name.as_str(), e.generics.len())),
+            _ => None,
+        })
+        .collect();
+    let mut errors = Vec::new();
+    if generic_enums.is_empty() {
+        return errors;
+    }
+    fn walk(
+        t: &ast::Type,
+        scope: Option<&str>,
+        line: usize,
+        column: usize,
+        generic_enums: &BTreeMap<&str, usize>,
+        errors: &mut Vec<CheckError>,
+    ) {
+        if t.generics.is_empty() && scope != Some(t.name.as_str()) {
+            if generic_enums.contains_key(t.name.as_str()) {
+                errors.push(CheckError::at(
+                    line,
+                    column,
+                    format!(
+                        "generic type '{0}' needs type arguments, e.g. {0}[T]",
+                        t.name
+                    ),
+                ));
+            }
+        }
+        for g in &t.generics {
+            walk(g, scope, line, column, generic_enums, errors);
+        }
+    }
+    for item in &source.items {
+        match item {
+            ast::Item::Fn(f) => {
+                let scope = f.type_param.as_deref();
+                let mut w = |t: &ast::Type| walk(t, scope, f.line, f.column, &generic_enums, &mut errors);
+                for p in &f.params {
+                    match &p.ty {
+                        ast::ParamType::Type(t) | ast::ParamType::Variadic(t) => w(t),
+                        ast::ParamType::Fn(ps, ret) => {
+                            ps.iter().for_each(&mut w);
+                            if let Some(r) = ret {
+                                w(r);
+                            }
+                        }
+                    }
+                }
+                if let Some(r) = &f.returns {
+                    w(r);
+                }
+            }
+            ast::Item::Enum(e) => {
+                for ty in e
+                    .variants
+                    .iter()
+                    .flat_map(|v| v.fields.iter())
+                    .chain(e.params.iter().map(|p| &p.ty))
+                {
+                    walk(ty, Some(e.name.as_str()), e.line, e.column, &generic_enums, &mut errors);
+                }
+            }
+            _ => {}
+        }
+    }
+    errors
+}
 fn checkSourceInner(source: &ast::Source) -> CheckResult<()> {
     // Generic items are checked once, structurally (`TApp`/`TParam`), on the
     // ORIGINAL source — no monomorphization.
     let mut errors: Vec<CheckError> = checkTraitConformance(source);
+    errors.extend(checkBareGenericTypes(source));
-    let (global_env, methods, enum_variants, enum_params) = buildTables(source, true);
+    let (global_env, methods, enum_variants, enum_params) = buildGlobalTables(source);
     let min_required = buildMinRequiredArgs(source);
     let ctx = CheckCtx {
         methods: &methods,
@@ -1784,10 +1795,10 @@ fn coverCtors(ty: &PlumType, ctx: &CheckCtx) -> Option<(String, Vec<CoverCtor>)>
             }
             vs.sort_by_key(|(_, i)| i.tag);
             Some((
-                variantBaseName(enum_name).to_string(),
+                enum_name.to_string(),
                 vs.into_iter()
                     .map(|(k, i)| CoverCtor {
-                        name: variantBaseName(k).to_string(),
+                        name: k.to_string(),
                         // A discriminant enum's field types are its shared
                         // params, which patterns never destructure.
                         fields: if ctx.enum_params.contains_key(enum_name) {
@@ -1843,7 +1854,7 @@ fn coverRows<'a>(
             if patCatchAll(r[0]) {
                 row.extend(std::iter::repeat(&COVER_WILDCARD).take(c.fields.len()));
             } else if let Some((n, fs)) = patCtor(r[0]) {
-                if tagLiteralName(variantBaseName(n)) != c.name {
+                if n != c.name {
                     continue;
                 }
                 if let ast::CasePattern::Name(_) = r[0] {
@@ -2383,14 +2394,6 @@ pub(crate) fn lookupFieldType(
     }
 }
-/// A mangled variant name's own unmangled base (`"Ok$Int$Str"` -> `"Ok"`,
-/// `"End"` -> `"End"`) — `monomorphize::mangle` always joins the original
-/// variant name and its resolved type args with `$`, so the base is simply
-/// everything before the first `$`.
-fn variantBaseName(name: &str) -> &str {
-    name.split('$').next().unwrap_or(name)
-}
 /// Finds the "success" (`Ok`) and "failure" (`Err`) variants
 /// belonging to the same enum as `enum_name`, for the `?` operator (`Expr::Try`)
 /// — used identically by the checker (`inferExpr`) and codegen (`inferLocalType`
@@ -2407,7 +2410,7 @@ pub fn tryOperatorVariants<'a>(
         if info.enum_name != enum_name {
             continue;
         }
-        match variantBaseName(vname) {
+        match vname.as_str() {
             "Ok" => success = Some((vname.as_str(), info)),
             "Err" => failure = Some((vname.as_str(), info)),
             _ => {}
@@ -2419,37 +2422,10 @@ pub fn tryOperatorVariants<'a>(
     }
 }
-/// Prefix the monomorphizer puts on a tag literal whose name a declared variant
-/// also uses, at a site whose expected type is a tag union naming it
-/// (`Err(Bad)` in `-> Try[Int, [Bad]]` next to `enum Rating = | Bad(...)`).
-/// Not a legal identifier character, so it can't clash with source names.
-pub const TAG_MARKER: char = '#';
-/// The tag name a tag-literal expression name stands for (drops `TAG_MARKER`).
-pub fn tagLiteralName(n: &str) -> &str {
-    n.strip_prefix(TAG_MARKER).unwrap_or(n)
-}
-/// True if `n` is the base name of a generic enum, or of one of its variants,
-/// that only survives monomorphization under mangled names (`Ok` ->
-/// `Ok$Int$[X]`, `Try` -> `Try$Int$[X]`).
-fn isGenericEnumBaseName(n: &str, ctx: &CheckCtx) -> bool {
-    let base = |k: &str| k.split_once('$').map(|(b, _)| b == n).unwrap_or(false);
-    !ctx.enum_variants.contains_key(n)
-        && ctx
-            .enum_variants
-            .iter()
-            .any(|(k, info)| base(k) || base(&info.enum_name))
-}
 /// True if `n` is an uppercase name that is not a declared type, variant, method
 /// receiver, builtin type or const — i.e. a structural tag literal.
 fn isTagLiteralName(n: &str, ctx: &CheckCtx) -> bool {
-    if n.starts_with(TAG_MARKER) {
-        return true;
-    }
     n.chars().next().is_some_and(|c| c.is_uppercase())
-        && !isGenericEnumBaseName(n, ctx)
         && !matches!(
             n,
             "Int" | "Float" | "Bool" | "Str" | "Byte" | "Unit" | "Self"
@@ -2776,7 +2752,7 @@ fn inferExprInner(
                     Ok(substVars(&result, &binds))
                 }
                 None if isTagLiteralName(n, ctx) => Ok(PlumType::TTags(BTreeMap::from([(
-                    tagLiteralName(n).to_string(),
+                    n.to_string(),
                     None,
                 )]))),
                 // Unmodeled/builtin type name: allow, codegen will catch.
@@ -3077,16 +3053,10 @@ fn inferExprInner(
                         None => None,
                     };
                     Ok(PlumType::TTags(BTreeMap::from([(
-                        tagLiteralName(&call.name).to_string(),
+                        call.name.to_string(),
                         payload,
                     )])))
                 }
-                // `Ok(3)` that nothing pinned to a concrete specialization (no
-                // typed param/field/return to take `E` from) — it is never a tag.
-                Err(_) if isGenericEnumBaseName(&call.name, ctx) => Err(format!(
-                    "cannot infer the type parameters of '{}' here: use it where its full type is known (a typed parameter, field or return)",
-                    call.name
-                )),
                 Err(_) => Ok(PlumType::TVar("_".to_string())), // unknown fn: allow, codegen will catch
             }
         }

plum-checker/src/monomorphize.rs DELETED Viewed

@@ -1,3287 +0,0 @@
-use crate::types::PlumType;
-use plum_core::ast;
-use std::collections::BTreeMap;
-/// A single uppercase letter (`T`, `U`, `K`, ...) is the grammar's only legal
-/// spelling for a generic type parameter — this is how we recognize one, since
-/// `ast::Fn` (unlike `ast::Enum`/`ast::Trait`) carries no explicit generics
-/// declaration list.
-pub fn isGenericParamName(name: &str) -> bool {
-    let mut chars = name.chars();
-    match (chars.next(), chars.next()) {
-        (Some(c), None) => c.is_ascii_uppercase(),
-        _ => false,
-    }
-}
-/// Collects every distinct single-uppercase-letter type name appearing
-/// anywhere in `t`, RECURSING into `t.generics` — so `List[T]` (a container
-/// type applied to the bare letter `T`) is recognized as introducing `T`,
-/// not just a bare `T` on its own. Order is first-appearance, depth-first.
-fn collectGenericParamNames(t: &ast::Type, names: &mut Vec<String>) {
-    if isGenericParamName(&t.name) && !names.iter().any(|x| x == &t.name) {
-        names.push(t.name.clone());
-    }
-    for g in &t.generics {
-        collectGenericParamNames(g, names);
-    }
-}
-/// The generic parameter names implicitly introduced by a `Fn` — every distinct
-/// single-uppercase-letter type name appearing in its params or return type
-/// (including nested inside a container type like `List[T]`, not just a bare
-/// `T` on its own — see `collectGenericParamNames`), in first-appearance order.
-pub fn fnGenericParams(f: &ast::Fn) -> Vec<String> {
-    let mut names: Vec<String> = Vec::new();
-    for p in &f.params {
-        match &p.ty {
-            ast::ParamType::Type(t) => collectGenericParamNames(t, &mut names),
-            ast::ParamType::Variadic(t) => collectGenericParamNames(t, &mut names),
-            // TODO: closures/fn-value params don't yet participate in generic
-            // parameter inference.
-            ast::ParamType::Fn(_, _) => {}
-        }
-    }
-    if let Some(r) = &f.returns {
-        collectGenericParamNames(r, &mut names);
-    }
-    names
-}
-/// The generic parameter names an `Enum` introduces — its OWN declared
-/// generics (`enum Link[T] = ...`) if it declares any, else (for an
-/// enum that doesn't) every distinct
-/// single-uppercase-letter variant field type name, in first-appearance
-/// order — the older, purely-implicit inference this replaces.
-pub fn enumGenericParams(e: &ast::Enum) -> Vec<String> {
-    if !e.generics.is_empty() {
-        return e.generics.iter().map(|g| g.name.clone()).collect();
-    }
-    let mut names: Vec<String> = Vec::new();
-    for v in &e.variants {
-        for field_ty in &v.fields {
-            if isGenericParamName(&field_ty.name) && !names.iter().any(|x| x == &field_ty.name) {
-                names.push(field_ty.name.clone());
-            }
-        }
-    }
-    names
-}
-/// Where to infer a method's OWN generic param's concrete binding from, at one
-/// call site — see `methodOwnGenericParams`.
-#[derive(Debug, Clone, Copy)]
-enum ExtraGenericSource {
-    /// `f.params[i]`'s declared type IS the bare letter itself (e.g. `List.reduce`'s
-    /// `acc: U`) — infer directly from that argument's own value.
-    Param(usize),
-    /// `f.params[i]` is `fn(...) -> <letter>` (e.g. `List.map`'s `cb: fn(T) -> U`) —
-    /// the argument must be a closure literal; infer by evaluating its body with
-    /// its own params seeded from the closure type's OTHER (already class-level-
-    /// concrete) param types.
-    ClosureReturn(usize),
-}
-/// The generic letters `f`'s signature introduces BEYOND `owner_params` (its
-/// enclosing class/enum's own declared generic params) — e.g. `List[T].map`'s
-/// `U`, distinct from `List[T]`'s own `T`. Unlike `fnGenericParams`, this DOES
-/// look inside closure-typed (`fn(...) -> ...`) param types, since that's
-/// exactly where a callback-taking method's own generic tends to live (a
-/// plain bare-letter param like `reduce`'s `acc: U` is also covered, via the
-/// same detection `fnGenericParams` already does for non-closure params). A
-/// closure's return type can ALSO nest the extra letter inside a container
-/// (`Link.andThen`'s `cb: fn(T) -> Link[U]`), not just be the bare
-/// letter itself (`List.map`'s `cb: fn(T) -> U`) — `collectGenericParamNames`
-/// recurses to find either shape; `resolveMethodOwnGenerics`'s
-/// `ClosureReturn` handling knows how to bind a nested one back out.
-fn methodOwnGenericParams(
-    f: &ast::Fn,
-    owner_params: &[String],
-) -> Vec<(String, ExtraGenericSource)> {
-    let mut result: Vec<(String, ExtraGenericSource)> = Vec::new();
-    for (i, p) in f.params.iter().enumerate() {
-        match &p.ty {
-            ast::ParamType::Type(t)
-                if isGenericParamName(&t.name) && !owner_params.iter().any(|o| o == &t.name) =>
-            {
-                if !result.iter().any(|(n, _)| n == &t.name) {
-                    result.push((t.name.clone(), ExtraGenericSource::Param(i)));
-                }
-            }
-            ast::ParamType::Fn(_, Some(ret)) => {
-                let mut ret_names: Vec<String> = Vec::new();
-                collectGenericParamNames(ret, &mut ret_names);
-                for name in ret_names {
-                    if !owner_params.iter().any(|o| o == &name)
-                        && !result.iter().any(|(n, _)| n == &name)
-                    {
-                        result.push((name, ExtraGenericSource::ClosureReturn(i)));
-                    }
-                }
-            }
-            _ => {}
-        }
-    }
-    result
-}
-/// A resolved binding from a generic item's parameter names to concrete types for
-/// one instantiation site, e.g. `{"a": Int}` for `Box(value: 5)`.
-#[derive(Debug, Clone)]
-pub struct Substitution(pub BTreeMap<String, PlumType>);
-impl Substitution {
-    fn get(&self, name: &str) -> Option<&PlumType> {
-        self.0.get(name)
-    }
-}
-/// Converts a resolved concrete `PlumType` back into the `ast::Type` shape needed
-/// to substitute into a declared field/param/return type position. Only ever
-/// called with types resolved from a real call-site argument's inferred type, so
-/// `TVar`/`TFun` (which never arise from a concrete argument) are an internal-error
-/// case rather than something this needs to model.
-fn plumTypeToAstType(t: &PlumType) -> ast::Type {
-    let name = match t {
-        PlumType::TInt => "Int".to_string(),
-        PlumType::TFloat => "Float".to_string(),
-        PlumType::TBool => "Bool".to_string(),
-        PlumType::TStr => "Str".to_string(),
-        PlumType::TByte => "Byte".to_string(),
-        PlumType::TByteSlice => "[]Byte".to_string(),
-        PlumType::TUnit => "Unit".to_string(),
-        PlumType::TNamed(n) | PlumType::TApp(n, _) => n.clone(),
-        PlumType::TParam(n) => n.clone(),
-        PlumType::TVar(_)
-        | PlumType::TFun(_, _)
-        | PlumType::TVariadic(_)
-        | PlumType::TTags(_) => t.to_string(),
-    };
-    ast::Type {
-        name,
-        generics: vec![],
-    }
-}
-fn substituteType(ty: &ast::Type, subst: &Substitution) -> ast::Type {
-    if ty.generics.is_empty() {
-        if let Some(concrete) = subst.get(&ty.name) {
-            return plumTypeToAstType(concrete);
-        }
-    }
-    ast::Type {
-        name: ty.name.clone(),
-        generics: ty
-            .generics
-            .iter()
-            .map(|g| substituteType(g, subst))
-            .collect(),
-    }
-}
-/// Mangles a generic item's base name and its resolved concrete type arguments
-/// (in the item's own generic-parameter declaration order) into the internal name
-/// used for its specialized copy, e.g. `Box` + `[Int]` -> `"Box$Int"`.
-pub fn mangle(base: &str, type_args: &[PlumType]) -> String {
-    let mut out = base.to_string();
-    for t in type_args {
-        out.push('$');
-        out.push_str(&t.to_string());
-    }
-    out
-}
-/// Produces a concrete, specialized copy of a generic function (or method) under
-/// `mangled_name`. `new_type_param` overrides the receiver-type name for a method
-/// whose receiver class was itself specialized (e.g. a method declared on `Box`
-/// becomes a method on `Box$Int`); pass the original `f.type_param.clone()`
-/// unchanged for a plain free function. The body is left structurally identical
-/// here — its own call sites are rewritten separately (Task 2), since expressions
-/// don't carry declared-type annotations the way fields/params/return types do.
-pub fn specializeFn(
-    f: &ast::Fn,
-    subst: &Substitution,
-    mangled_name: &str,
-    new_type_param: Option<String>,
-) -> ast::Fn {
-    ast::Fn {
-        name: mangled_name.to_string(),
-        line: f.line,
-        column: f.column,
-        type_param: new_type_param,
-        is_extern: f.is_extern,
-        params: f
-            .params
-            .iter()
-            .map(|p| ast::Param {
-                name: p.name.clone(),
-                ty: match &p.ty {
-                    ast::ParamType::Type(t) => ast::ParamType::Type(substituteType(t, subst)),
-                    ast::ParamType::Variadic(t) => {
-                        ast::ParamType::Variadic(substituteType(t, subst))
-                    }
-                    ast::ParamType::Fn(params, ret) => ast::ParamType::Fn(
-                        params.iter().map(|t| substituteType(t, subst)).collect(),
-                        ret.as_ref().map(|r| Box::new(substituteType(r, subst))),
-                    ),
-                },
-                default: p.default.clone(),
-            })
-            .collect(),
-        returns: f.returns.as_ref().map(|r| substituteType(r, subst)),
-        body: {
-            let mut body = f.body.clone();
-            match &mut body {
-                ast::FnBody::Block(b) => substituteTypesInBlock(b, subst),
-                ast::FnBody::Expr(e) => substituteTypesInExpr(e, subst),
-                ast::FnBody::Extern => {}
-            }
-            body
-        },
-    }
-}
-/// Rewrites every explicit generic-type-argument annotation reachable inside
-/// `block` (currently only `ClassCall.generics`, e.g. the `[X, Y]` in
-/// `Map[X, Y](...)`) through `subst` — the SAME substitution `specializeFn`
-/// already applies to a method's own params/return, just extended to its
-/// BODY. Without this, a method with its own extra generic param(s) (beyond
-/// its receiver's) that writes an explicit bracketed construction using one
-/// of those letters keeps the literal, un-substituted letter ("X") after
-/// specialization: `resolveClassInstantiation` then treats "X" as a real
-/// (nonexistent) class name, silently minting bogus `List$X`/`Pair$X`
-/// "specializations" that corrupt unrelated template compilation. See the
-/// `plum_map_map_gaps_2026_09` memory (gap 1) for the discovery writeup.
-fn substituteTypesInBlock(block: &mut ast::Block, subst: &Substitution) {
-    for stmt in &mut block.stmts {
-        substituteTypesInStmt(stmt, subst);
-    }
-}
-fn substituteTypesInStmt(stmt: &mut ast::Stmt, subst: &Substitution) {
-    match stmt {
-        ast::Stmt::Assign(a) => {
-            for v in &mut a.values {
-                substituteTypesInExpr(v, subst);
-            }
-            for t in &mut a.targets {
-                if let ast::AssignTarget::Field(obj, _) = t {
-                    substituteTypesInExpr(obj, subst);
-                }
-            }
-        }
-        ast::Stmt::Break | ast::Stmt::Continue | ast::Stmt::Todo => {}
-        ast::Stmt::Crash(e) => substituteTypesInExpr(e, subst),
-        ast::Stmt::Assert(c) => substituteTypesInExpr(&mut c.cond, subst),
-        ast::Stmt::For(f) => {
-            substituteTypesInExpr(&mut f.iter, subst);
-            substituteTypesInBlock(&mut f.body, subst);
-        }
-        ast::Stmt::While(w) => {
-            substituteTypesInExpr(&mut w.condition, subst);
-            substituteTypesInBlock(&mut w.body, subst);
-        }
-        ast::Stmt::If(i) => {
-            substituteTypesInExpr(&mut i.condition, subst);
-            substituteTypesInBlock(&mut i.body, subst);
-            for ei in &mut i.else_ifs {
-                substituteTypesInExpr(&mut ei.condition, subst);
-                substituteTypesInBlock(&mut ei.body, subst);
-            }
-            if let Some(e) = &mut i.else_ {
-                substituteTypesInBlock(e, subst);
-            }
-        }
-        ast::Stmt::Match(m) => {
-            for s in &mut m.subjects {
-                substituteTypesInExpr(s, subst);
-            }
-            for c in &mut m.cases {
-                substituteTypesInBlock(&mut c.body, subst);
-            }
-        }
-        ast::Stmt::Return(Some(e)) => substituteTypesInExpr(e, subst),
-        ast::Stmt::Return(None) => {}
-        ast::Stmt::Expr(e, ..) => substituteTypesInExpr(e, subst),
-    }
-}
-fn substituteTypesInArg(arg: &mut ast::Arg, subst: &Substitution) {
-    match arg {
-        ast::Arg::Positional(e) => substituteTypesInExpr(e, subst),
-        ast::Arg::Keyword { value, .. } => substituteTypesInExpr(value, subst),
-        ast::Arg::Pair { value, .. } => substituteTypesInExpr(value, subst),
-    }
-}
-fn substituteTypesInExpr(expr: &mut ast::Expr, subst: &Substitution) {
-    match expr {
-        ast::Expr::Binary(b) => {
-            substituteTypesInExpr(&mut b.left, subst);
-            substituteTypesInExpr(&mut b.right, subst);
-        }
-        ast::Expr::Unary(u) => substituteTypesInExpr(&mut u.operand, subst),
-        ast::Expr::Bool(b) => {
-            substituteTypesInExpr(&mut b.left, subst);
-            substituteTypesInExpr(&mut b.right, subst);
-        }
-        ast::Expr::Not(inner) => substituteTypesInExpr(inner, subst),
-        ast::Expr::Try(inner) => substituteTypesInExpr(inner, subst),
-        ast::Expr::Elvis(e) => {
-            substituteTypesInExpr(&mut e.left, subst);
-            substituteTypesInExpr(&mut e.right, subst);
-        }
-        ast::Expr::Compare(c) => {
-            substituteTypesInExpr(&mut c.left, subst);
-            substituteTypesInExpr(&mut c.right, subst);
-        }
-        ast::Expr::Ternary(t) => {
-            substituteTypesInExpr(&mut t.condition, subst);
-            substituteTypesInExpr(&mut t.then, subst);
-            substituteTypesInExpr(&mut t.else_, subst);
-        }
-        ast::Expr::FnCall(call) => {
-            for arg in &mut call.args {
-                substituteTypesInArg(arg, subst);
-            }
-        }
-        ast::Expr::ClassCall(call) => {
-            for g in &mut call.generics {
-                *g = substituteType(g, subst);
-            }
-            for fa in &mut call.fields {
-                substituteTypesInExpr(&mut fa.value, subst);
-            }
-        }
-        ast::Expr::Attribute(attr) => {
-            substituteTypesInExpr(&mut attr.object, subst);
-            if let ast::AttrKind::Method(call) = &mut attr.attr {
-                for arg in &mut call.args {
-                    substituteTypesInArg(arg, subst);
-                }
-            }
-        }
-        ast::Expr::Paren(inner) => substituteTypesInExpr(inner, subst),
-        ast::Expr::String(s) => {
-            for part in &mut s.parts {
-                if let ast::StringPart::Interp(e) = part {
-                    substituteTypesInExpr(e, subst);
-                }
-            }
-        }
-        ast::Expr::Closure(cl) => substituteTypesInBlock(&mut cl.body, subst),
-        ast::Expr::Int(_)
-        | ast::Expr::Float(_)
-        | ast::Expr::Self_
-        | ast::Expr::Var(_)
-        | ast::Expr::TypeName(_) => {}
-    }
-}
-/// Produces a concrete, specialized copy of a generic enum under `mangled_name`,
-/// substituting every variant field type name that matches one of the enum's
-/// generic parameters with its resolved concrete type's name.
-///
-/// Variant names are ALSO mangled here, with the same suffix as the enum's own
-/// name (e.g. `Next` -> `Next$Int`) — even a payload-free variant like `End`.
-/// This is necessary because the runtime `EnumVariants` table (built by
-/// `buildGlobalTables`) is keyed by bare variant name globally: without this,
-/// two specializations of the same generic enum would both register a variant
-/// literally named `Next`, colliding in that flat table.
-pub fn specializeEnum(e: &ast::Enum, subst: &Substitution, mangled_name: &str) -> ast::Enum {
-    let params = enumGenericParams(e);
-    let type_args: Vec<PlumType> = params
-        .iter()
-        .filter_map(|p| subst.get(p).cloned())
-        .collect();
-    ast::Enum {
-        name: mangled_name.to_string(),
-        line: e.line,
-        column: e.column,
-        generics: vec![],
-        implements: e.implements.clone(),
-        params: e.params.clone(),
-        variants: e
-            .variants
-            .iter()
-            .map(|v| ast::EnumVariant {
-                name: mangle(&v.name, &type_args),
-                fields: v.fields.iter().map(|f| substituteType(f, subst)).collect(),
-                field_names: v.field_names.clone(),
-                values: v.values.clone(),
-            })
-            .collect(),
-    }
-}
-use crate::types::{TypeEnv, TypeScheme};
-use crate::{CheckCtx, EnumParams, EnumVariantInfo, EnumVariants, MethodEnv};
-use std::collections::BTreeSet;
-enum PendingSpecialization<'a> {
-    Fn {
-        base: &'a ast::Fn,
-        subst: Substitution,
-        mangled: String,
-        new_receiver: Option<String>,
-    },
-    Enum {
-        base: &'a ast::Enum,
-        subst: Substitution,
-        mangled: String,
-    },
-}
-/// True if `pat` binds `name` anywhere within it (a `Name` sub-pattern, at any
-/// nesting depth inside a `Class` constructor pattern) — used by
-/// `renameVarInStmt`'s `Match` case to recognize when a NESTED case pattern
-/// re-shadows the name currently being renamed, in which case that nested
-/// case's body refers to a different (shadowing) binding and must be left alone.
-fn caseBindsName(pat: &ast::CasePattern, name: &str) -> bool {
-    match pat {
-        ast::CasePattern::Name(n) => n == name,
-        ast::CasePattern::Class { fields, .. } => fields.iter().any(|f| caseBindsName(f, name)),
-        _ => false,
-    }
-}
-/// Renames every `Expr::Var(old)` to `Expr::Var(new)` within `block`, used by
-/// `Monomorphizer::dedupLocalName` to rename a match-case/for-loop binding
-/// (plus every reference to it) once its usage is known to be confined to that
-/// one block — see `local_types_by_name`'s doc comment for why this is needed
-/// at all. Purely syntactic (no type information needed): stops descending into
-/// any NESTED scope that re-binds `old` itself (a nested `for` over the same
-/// name, or a nested `match` case whose pattern binds it again), since that
-/// inner scope's occurrences of `old` are a different, shadowing variable, not
-/// the one being renamed.
-fn renameVarInBlock(block: &mut ast::Block, old: &str, new: &str) {
-    for stmt in &mut block.stmts {
-        renameVarInStmt(stmt, old, new);
-    }
-}
-fn renameVarInStmt(stmt: &mut ast::Stmt, old: &str, new: &str) {
-    match stmt {
-        ast::Stmt::Assign(a) => {
-            for v in &mut a.values {
-                renameVarInExpr(v, old, new);
-            }
-            for t in &mut a.targets {
-                match t {
-                    ast::AssignTarget::Var(n) => {
-                        if n == old {
-                            *n = new.to_string();
-                        }
-                    }
-                    ast::AssignTarget::Field(obj, _) => renameVarInExpr(obj, old, new),
-                }
-            }
-        }
-        ast::Stmt::Return(Some(e)) => renameVarInExpr(e, old, new),
-        ast::Stmt::Return(None) | ast::Stmt::Break | ast::Stmt::Continue | ast::Stmt::Todo => {}
-        ast::Stmt::Crash(e) => renameVarInExpr(e, old, new),
-        ast::Stmt::Assert(c) => renameVarInExpr(&mut c.cond, old, new),
-        ast::Stmt::Expr(e, ..) => renameVarInExpr(e, old, new),
-        ast::Stmt::If(if_) => {
-            renameVarInExpr(&mut if_.condition, old, new);
-            renameVarInBlock(&mut if_.body, old, new);
-            for ei in &mut if_.else_ifs {
-                renameVarInExpr(&mut ei.condition, old, new);
-                renameVarInBlock(&mut ei.body, old, new);
-            }
-            if let Some(else_block) = &mut if_.else_ {
-                renameVarInBlock(else_block, old, new);
-            }
-        }
-        ast::Stmt::While(w) => {
-            renameVarInExpr(&mut w.condition, old, new);
-            renameVarInBlock(&mut w.body, old, new);
-        }
-        ast::Stmt::For(f) => {
-            renameVarInExpr(&mut f.iter, old, new);
-            if !f.vars.iter().any(|v| v == old) {
-                renameVarInBlock(&mut f.body, old, new);
-            }
-        }
-        ast::Stmt::Match(m) => {
-            for s in &mut m.subjects {
-                renameVarInExpr(s, old, new);
-            }
-            for case in &mut m.cases {
-                if !case.patterns.iter().any(|p| caseBindsName(p, old)) {
-                    renameVarInBlock(&mut case.body, old, new);
-                }
-            }
-        }
-    }
-}
-fn renameVarInExpr(expr: &mut ast::Expr, old: &str, new: &str) {
-    match expr {
-        ast::Expr::Var(n) => {
-            if n == old {
-                *n = new.to_string();
-            }
-        }
-        ast::Expr::ClassCall(call) => {
-            for fa in &mut call.fields {
-                renameVarInExpr(&mut fa.value, old, new);
-            }
-        }
-        ast::Expr::FnCall(call) => {
-            for arg in &mut call.args {
-                renameVarInArg(arg, old, new);
-            }
-        }
-        ast::Expr::Attribute(attr) => {
-            renameVarInExpr(&mut attr.object, old, new);
-            if let ast::AttrKind::Method(call) = &mut attr.attr {
-                for arg in &mut call.args {
-                    renameVarInArg(arg, old, new);
-                }
-            }
-        }
-        ast::Expr::Binary(b) => {
-            renameVarInExpr(&mut b.left, old, new);
-            renameVarInExpr(&mut b.right, old, new);
-        }
-        ast::Expr::Bool(b) => {
-            renameVarInExpr(&mut b.left, old, new);
-            renameVarInExpr(&mut b.right, old, new);
-        }
-        ast::Expr::Compare(c) => {
-            renameVarInExpr(&mut c.left, old, new);
-            renameVarInExpr(&mut c.right, old, new);
-        }
-        ast::Expr::Not(inner) => renameVarInExpr(inner, old, new),
-        ast::Expr::Try(inner) => renameVarInExpr(inner, old, new),
-        ast::Expr::Elvis(e) => {
-            renameVarInExpr(&mut e.left, old, new);
-            renameVarInExpr(&mut e.right, old, new);
-        }
-        ast::Expr::Unary(u) => renameVarInExpr(&mut u.operand, old, new),
-        ast::Expr::Paren(inner) => renameVarInExpr(inner, old, new),
-        ast::Expr::Ternary(t) => {
-            renameVarInExpr(&mut t.condition, old, new);
-            renameVarInExpr(&mut t.then, old, new);
-            renameVarInExpr(&mut t.else_, old, new);
-        }
-        ast::Expr::String(s) => {
-            for part in &mut s.parts {
-                if let ast::StringPart::Interp(e) = part {
-                    renameVarInExpr(e, old, new);
-                }
-            }
-        }
-        ast::Expr::Int(_) | ast::Expr::Float(_) | ast::Expr::Self_ | ast::Expr::TypeName(_) => {}
-        // Not recursed into — matches `rewriteExpr`'s identical `Closure` case
-        // (closure bodies are compiled/free-variable-captured separately and
-        // aren't otherwise touched by this pass either). A closure capturing a
-        // variable that gets renamed here is a known, narrow residual gap.
-        ast::Expr::Closure(_) => {}
-    }
-}
-fn renameVarInArg(arg: &mut ast::Arg, old: &str, new: &str) {
-    match arg {
-        ast::Arg::Positional(e) => renameVarInExpr(e, old, new),
-        ast::Arg::Keyword { value, .. } => renameVarInExpr(value, old, new),
-        ast::Arg::Pair { value, .. } => renameVarInExpr(value, old, new),
-    }
-}
-struct Monomorphizer<'a> {
-    fns_generic: BTreeMap<String, &'a ast::Fn>,
-    /// Every method declared on a generic enum (e.g. `Try`'s `isOk`/`isErr`,
-    /// or a record-shaped `List`/`Map`'s own methods), keyed by the enum's own
-    /// bare name.
-    methods_generic_on_enum: BTreeMap<String, Vec<&'a ast::Fn>>,
-    /// Bare variant name (e.g. `"Next"`) -> the generic `Enum` it belongs to. Keyed
-    /// by variant name because a construction site (`Next(5)`) parses as a `FnCall`
-    /// whose `name` is the VARIANT, not the enum's own name.
-    enums_generic_by_variant: BTreeMap<String, &'a ast::Enum>,
-    /// Mangled enum name -> {original variant name -> mangled variant name}, e.g.
-    /// `"Link$Int" -> {"Next": "Next$Int", "End": "End$Int"}`. Populated eagerly
-    /// (in `resolveEnumInstantiation`, at the moment an instantiation's concrete
-    /// type arguments become known) rather than waiting for the worklist to actually
-    /// produce that specialization — so both a construction call site and a later
-    /// `match` on the same specialization can rewrite variant names consistently,
-    /// regardless of processing order.
-    enum_variant_mangling: BTreeMap<String, BTreeMap<String, String>>,
-    /// The enum's own bare name -> the generic `Enum` — used to detect a bare
-    /// generic-enum-typed function param (e.g. `o: Link`), distinct from
-    /// `enums_generic_by_variant` (keyed by VARIANT name, used for construction
-    /// sites like `Next(5)`).
-    enums_generic_by_name: BTreeMap<String, &'a ast::Enum>,
-    /// Free functions that are NOT generic by `fnGenericParams`'s lowercase-letter
-    /// convention, but whose param type(s) bare-name a generic enum (e.g.
-    /// `unwrapOr(o: Link, ...)`) — such a function still needs its own
-    /// per-call-site specialization, since its receiver generic enum is
-    /// dropped from the monomorphized output and the bare name would otherwise
-    /// resolve to nothing.
-    fns_bare_generic: BTreeMap<String, &'a ast::Fn>,
-    /// Mangled enum name -> (its own TEMPLATE name, the generic-param
-    /// bindings it was specialized with), e.g. `"List$Int" -> ("List", {"T":
-    /// TInt})`. Populated wherever an enum specialization's `mangled`
-    /// name is first computed. Used by `resolveMethodOwnGenerics` to look up
-    /// a method's OWNER template (to find its original, doubly-generic
-    /// `ast::Fn`) and the receiver's own already-known bindings (e.g. `T`),
-    /// given only the receiver's mangled type name at a method call site.
-    class_specialization_info: BTreeMap<String, (String, BTreeMap<String, PlumType>)>,
-    global_env: TypeEnv,
-    methods: MethodEnv,
-    enum_variants: EnumVariants,
-    enum_params: EnumParams,
-    min_required: crate::MinRequiredArgs,
-    specialized: BTreeSet<String>,
-    enqueued: BTreeSet<String>,
-    worklist: Vec<PendingSpecialization<'a>>,
-    produced: Vec<ast::Item>,
-    /// The declared return type of the function/method currently being rewritten
-    /// by `rewriteFnBody` — consulted by `resolveEnumInstantiation` as a fallback
-    /// when a single variant construction site (e.g. `Ok(5)`) can't pin down every
-    /// one of the enum's generic params by itself (see its doc comment). Reset at
-    /// the top of every `rewriteFnBody` call; never needs saving/restoring since
-    /// closures aren't recursed into by this pass (see `rewriteExpr`'s `Closure` arm).
-    current_return_type: Option<ast::Type>,
-    /// True while `current_return_type` holds a closure argument's declared
-    /// return (see `rewriteMethodClosureArgs`), which may still contain the
-    /// method's own unresolved generic letters.
-    return_type_is_closure_expected: bool,
-    /// The enclosing real function's return type while
-    /// `return_type_is_closure_expected` is set (fallback for letters the
-    /// closure's expected return leaves unresolved).
-    closure_outer_return_type: Option<ast::Type>,
-    /// (receiver name or `None` for a free function, function/method name) ->
-    /// (the generic enum its declared return type names, the concrete type args
-    /// it names them with) — for every function/method whose OWN declared return
-    /// type is a fully-general instantiation of a known generic enum (e.g.
-    /// `-> Try[Int, Str]`). Populated once up front (in `monomorphizeSource`,
-    /// alongside `enums_generic_by_name`) from the ORIGINAL, unmodified signatures
-    /// — unlike everywhere else in this file, this doesn't need the specialization
-    /// to have actually run yet, since the declared signature already says
-    /// everything needed. Consulted by `resolveCallReturnType`.
-    fn_return_generic_enum: BTreeMap<(Option<String>, String), (&'a ast::Enum, Vec<PlumType>)>,
-    /// Every local name's type as first seen in the function currently being
-    /// rewritten (reset per `rewriteFnBody` call, like `current_return_type`).
-    /// Wasm local slots are allocated once per NAME for the whole function (see
-    /// `plum-wasm-codegen`'s `Collector`/`compileFnBody`), not per lexical scope —
-    /// so two unrelated bindings that happen to share a name (e.g. `Ok(v)` in two
-    /// separate, non-overlapping `match` statements) would silently collide on
-    /// one slot if their types ever differ. `dedupLocalName` consults this to
-    /// catch that and rename the second, conflicting binding instead.
-    local_types_by_name: BTreeMap<String, PlumType>,
-    /// Bumped each time `dedupLocalName` needs a fresh name; part of the fresh
-    /// name itself, so collisions between two different renames are impossible.
-    rename_counter: usize,
-}
-impl<'a> Monomorphizer<'a> {
-    /// Like `infer`, but tries `resolveCallReturnType` first — needed anywhere the
-    /// resulting `PlumType` will be used to look up `enum_variant_mangling` (i.e.
-    /// wherever a value might need its constructor-pattern names rewritten later:
-    /// an assignment's recorded local type, or a `match` subject's type).
-    fn inferConcrete(&mut self, e: &ast::Expr, env: &TypeEnv) -> PlumType {
-        self.resolveCallReturnType(e, env)
-            .unwrap_or_else(|| self.infer(e, env))
-    }
-    fn infer(&self, e: &ast::Expr, env: &TypeEnv) -> PlumType {
-        // `env` is a SNAPSHOT of `self.global_env`, cloned once at the top of
-        // whichever `rewriteFnBody` call is currently processing this
-        // statement — any free function specialized (and eagerly registered
-        // into `self.global_env`, e.g. by `resolveFnInstantiation`) SINCE that
-        // clone was taken is invisible to a plain `env.get(...)` lookup, even
-        // though it's already a real, fully-resolved entry. Overlay the LIVE
-        // `self.global_env` underneath `env` (local bindings still shadow it,
-        // same precedence a real nested scope would have) so a call rewritten
-        // to its mangled name earlier in THIS SAME statement (e.g. `l :=
-        // makeList(1, 2, 3)`, immediately needing `makeList$Int`'s freshly
-        // resolved return type) resolves correctly instead of falling back to
-        // `TVar` — which would otherwise cascade into `resolveMethodOwnGenerics`
-        // silently no-op'ing on the very next statement (`l.map(...)`).
-        let mut merged_env = self.global_env.clone();
-        merged_env.extend(env.iter().map(|(k, v)| (k.clone(), v.clone())));
-        let ctx = CheckCtx {
-            methods: &self.methods,
-            enum_variants: &self.enum_variants,
-            enum_params: &self.enum_params,
-            min_required: &self.min_required,
-        };
-        crate::inferExpr(e, &merged_env, &ctx).unwrap_or(PlumType::TVar("_".to_string()))
-    }
-    /// Records `name`'s first-seen type in `local_types_by_name` without
-    /// renaming anything — for a binding whose usage isn't cleanly bounded to a
-    /// single `&mut ast::Block` this pass has in hand at the binding site (e.g.
-    /// a plain `Assign` — its "scope" is however much of the flat function body
-    /// follows it, not a nested block). This still lets a LATER, cleanly-bounded
-    /// binding (`dedupLocalName`, from a `match` arm or `for` loop) detect a
-    /// conflict against it and rename itself accordingly; it just means a
-    /// conflict in the other direction (an `Assign` conflicting with an
-    /// EARLIER match-bound name) isn't caught. Real but narrower residual gap —
-    /// see the `local_types_by_name` doc comment.
-    fn seedLocalType(&mut self, name: &str, ty: &PlumType) {
-        self.local_types_by_name
-            .entry(name.to_string())
-            .or_insert_with(|| ty.clone());
-    }
-    /// Ensures `name` can be bound to `ty` here without colliding with a
-    /// DIFFERENT type already recorded for that same name elsewhere in the
-    /// current function (see `local_types_by_name`'s doc comment for why that's
-    /// otherwise unsafe). If there's no conflict, returns `name` unchanged. If
-    /// there IS one, mints a fresh name, renames every reference to `name`
-    /// within `scope` (a match case body / for-loop body — the full extent this
-    /// particular binding's usage can ever reach) to that fresh name, and
-    /// returns it for the caller to use as the actual binding name instead.
-    fn dedupLocalName(&mut self, name: &str, ty: &PlumType, scope: &mut ast::Block) -> String {
-        self.dedupLocalNameWithGuard(name, ty, scope, None)
-    }
-    /// Same as `dedupLocalName`, but when a match case has its own `when` guard,
-    /// that guard can reference the SAME pattern-bound name the rename below
-    /// patches inside the case body — patch it there too, or the guard is left
-    /// referring to a name `case_env` no longer has (see the caller in
-    /// `manglePattern`).
-    fn dedupLocalNameWithGuard(
-        &mut self,
-        name: &str,
-        ty: &PlumType,
-        scope: &mut ast::Block,
-        guard: Option<&mut ast::Expr>,
-    ) -> String {
-        match self.local_types_by_name.get(name) {
-            None => {
-                self.local_types_by_name
-                    .insert(name.to_string(), ty.clone());
-                name.to_string()
-            }
-            Some(existing) if existing == ty => name.to_string(),
-            Some(_) => {
-                self.rename_counter += 1;
-                let fresh = format!("{}$dup{}", name, self.rename_counter);
-                self.local_types_by_name.insert(fresh.clone(), ty.clone());
-                renameVarInBlock(scope, name, &fresh);
-                if let Some(g) = guard {
-                    renameVarInExpr(g, name, &fresh);
-                }
-                fresh
-            }
-        }
-    }
-    /// Rewrites a function/method body's generic call sites. When `resolve_return`
-    /// is set (for freshly-generated specializations, whose declared return may be
-    /// a generic parameter like `a` — which the current grammar can't even parse,
-    /// leaving `returns: None` — or a generic class), the declared return type is
-    /// re-derived from the concrete inferred type of the body's tail expression.
-    /// For an ordinary (non-generic) top-level function we only rewrite the return
-    /// annotation when it names a generic class used bare (e.g. `-> Box`), which
-    /// the body's construction site has just been specialized to a mangled name.
-    fn rewriteFnBody(&mut self, f: &mut ast::Fn, resolve_return: bool) -> Result<(), String> {
-        self.current_return_type = f.returns.clone();
-        self.return_type_is_closure_expected = false;
-        self.local_types_by_name.clear();
-        let mut env = self.global_env.clone();
-        if let Some(recv) = &f.type_param {
-            env.insert(
-                "self".to_string(),
-                TypeScheme::mono(PlumType::TNamed(recv.clone())),
-            );
-        }
-        for p in &f.params {
-            let ty = match &p.ty {
-                ast::ParamType::Type(t) => crate::plumTypeFromAst(t),
-                ast::ParamType::Variadic(t) => {
-                    PlumType::TVariadic(Box::new(crate::plumTypeFromAst(t)))
-                }
-                ast::ParamType::Fn(params, ret) => {
-                    let param_types = params.iter().map(crate::plumTypeFromAst).collect();
-                    let ret_ty = ret
-                        .as_ref()
-                        .map(|r| crate::plumTypeFromAst(r))
-                        .unwrap_or(PlumType::TUnit);
-                    PlumType::TFun(param_types, Box::new(ret_ty))
-                }
-            };
-            self.local_types_by_name.insert(p.name.clone(), ty.clone());
-            env.insert(p.name.clone(), TypeScheme::mono(ty));
-        }
-        // The function's own return type, resolved for THIS specialization — used
-        // below to resolve a bare payload-free variant (`End`) that's the
-        // BODY'S TAIL EXPRESSION (implicit return), the same way `Stmt::Return`
-        // already does. A tail `Stmt::Expr` never goes through `Stmt::Return`'s
-        // own handling, so without this a trailing bare `End` is left
-        // unmangled and later fails the real checker's return-type unification.
-        let expected_ret = self
-            .current_return_type
-            .clone()
-            .map(|rt| self.resolveFieldType(&rt))
-            .map(|rt| crate::plumTypeFromAst(&rt));
-        let tail: Option<PlumType> = match &mut f.body {
-            ast::FnBody::Expr(e) => {
-                if let Some(expected) = &expected_ret {
-                    self.resolveBareVariantAgainstExpected(e, expected);
-                    self.wrapPrimitiveAgainstExpected(e, expected, &env);
-                }
-                self.rewriteExpr(e, &env)?;
-                Some(self.inferConcrete(e, &env))
-            }
-            ast::FnBody::Block(block) => {
-                if let Some(expected) = &expected_ret {
-                    if let Some(ast::Stmt::Expr(e, ..)) = block.stmts.last_mut() {
-                        self.resolveBareVariantAgainstExpected(e, expected);
-                        self.wrapPrimitiveAgainstExpected(e, expected, &env);
-                    }
-                }
-                self.rewriteBlock(block, &mut env)?;
-                // `inferConcrete` (not plain `infer`) — the tail's type feeds
-                // `maybeRewriteReturn` below, which needs the call's REAL
-                // specialized return type (e.g. `Link$Str`) when the tail is
-                // a call to another function whose OWN declared return type
-                // instantiates a generic enum. Plain `infer` only consults
-                // `self.global_env`, built once from the ORIGINAL source
-                // before any mangling — so a tail like `return otherFn()`
-                // where `otherFn() -> Link[Str]` would infer the bare,
-                // unmangled `Link` here, and `maybeRewriteReturn` would then
-                // permanently freeze this function's OWN return annotation at
-                // that same bare, ungeneric name instead of the concrete
-                // `Link$Str` the body actually produces.
-                match block.stmts.last() {
-                    Some(ast::Stmt::Expr(e, ..)) => Some(self.inferConcrete(e, &env)),
-                    Some(ast::Stmt::Return(Some(e))) => Some(self.inferConcrete(e, &env)),
-                    _ => None,
-                }
-            }
-            // No body to rewrite or infer a tail type from.
-            ast::FnBody::Extern => None,
-        };
-        if let Some(t) = tail {
-            self.maybeRewriteReturn(f, &t, resolve_return);
-        }
-        Ok(())
-    }
-    /// Overwrites `f.returns` with a concrete type derived from the body's tail
-    /// type `t` when the currently-declared return type is genuinely generic or
-    /// unresolved. Never clobbers a real, concrete declared return type — even for
-    /// a specialization (`resolve_return: true`) — so a generic function whose body
-    /// is internally inconsistent with its concrete declared return (e.g.
-    /// `wrong(x: a) -> Int = "hello"`) is left for the checker's normal
-    /// return-type-mismatch logic to REJECT rather than silently rewritten (and
-    /// thereby masked). The overwrite fires only when:
-    ///   - `f.returns` is `None` — the unparseable `-> a` generic-parameter-return
-    ///     case, where the grammar dropped the annotation entirely (this only ever
-    ///     happens for a specialization, which is the only path that can supply a
-    ///     concrete tail type to fill it in); or
-    ///   - the declared return names something still-generic: a generic-parameter
-    ///     letter (e.g. `-> a`) or a generic class used bare (e.g. `-> Box`).
-    /// For the `Some(rt)` arm this condition is identical whether `resolve_return`
-    /// is `true` or `false`; the specialization path differs only in that its tail
-    /// is inferred against a resolved substitution, so a generic-parameter-letter
-    /// return resolves to the specialization's concrete bound type (which the
-    /// ordinary path cannot do). The unparseable-`End` fill-in is gated on
-    /// `resolve_return` so an ordinary void function (`returns: None` meaning "no
-    /// declared return", not "a generic return the grammar dropped") is never given
-    /// a fabricated return type. Never fabricates a return from an un-inferrable
-    /// (`TVar`) tail.
-    fn maybeRewriteReturn(&self, f: &mut ast::Fn, t: &PlumType, resolve_return: bool) {
-        if matches!(t, PlumType::TVar(_) | PlumType::TFun(_, _)) {
-            return;
-        }
-        let needs = match &f.returns {
-            None => resolve_return,
-            Some(rt) => {
-                // A generic enum named WITH concrete type args already
-                // (`-> List[Str]`, `-> Try[Int, Str]`) is already fully
-                // resolved — only a genuinely BARE reference (`-> List`,
-                // `-> Box`, no `[...]` at all) is the "unresolved" shape this
-                // is meant to catch. Without the `rt.generics.is_empty()`
-                // guard, a plain function's ALREADY-concrete `List[Str]`
-                // return annotation got blown away and replaced by whatever
-                // (possibly stale/unmangled) type the body's tail inferred
-                // to, purely because "List" happens to be a known generic
-                // class name — corrupting an otherwise-correct declaration.
-                rt.generics.is_empty()
-                    && (isGenericParamName(&rt.name)
-                        || self.enums_generic_by_name.contains_key(&rt.name))
-            }
-        };
-        if needs {
-            f.returns = Some(ast::Type {
-                name: t.to_string(),
-                generics: vec![],
-            });
-        }
-    }
-    fn rewriteBlock(&mut self, block: &mut ast::Block, env: &mut TypeEnv) -> Result<(), String> {
-        for stmt in &mut block.stmts {
-            self.rewriteStmt(stmt, env)?;
-        }
-        Ok(())
-    }
-    /// Rewrites `pat` (bare-name/constructor pattern) in place: an uppercase variant
-    /// name gets mangled to its specialized form (`Next` -> `Next$Int`) if `mangling`
-    /// says this position's subject is a specialized generic enum; a plain binding
-    /// name is inserted into `case_env` at `ty`. Recurses into a constructor
-    /// pattern's own fields (`Next(Next(v))`), looking up *that* field's own
-    /// mangling table from `self.enum_variant_mangling` — a nested sub-pattern can
-    /// be a specialization independent of its enclosing pattern's.
-    fn manglePattern(
-        &mut self,
-        pat: &mut ast::CasePattern,
-        ty: &PlumType,
-        mangling: Option<&BTreeMap<String, String>>,
-        case_env: &mut TypeEnv,
-        body: &mut ast::Block,
-        mut guard: Option<&mut ast::Expr>,
-    ) {
-        match pat {
-            ast::CasePattern::Name(n) => {
-                let is_variant = n.chars().next().map(|c| c.is_uppercase()).unwrap_or(false)
-                    && self.enum_variants.contains_key(n.as_str());
-                if is_variant {
-                    if let Some(table) = mangling {
-                        if let Some(mangled_variant) = table.get(n) {
-                            *n = mangled_variant.clone();
-                        }
-                    }
-                } else {
-                    let bound = self.dedupLocalNameWithGuard(n, ty, body, guard.as_deref_mut());
-                    if bound != *n {
-                        *n = bound.clone();
-                    }
-                    case_env.insert(bound, TypeScheme::mono(ty.clone()));
-                }
-            }
-            ast::CasePattern::Class { name, fields } => {
-                if let Some(table) = mangling {
-                    if let Some(mangled_variant) = table.get(name) {
-                        *name = mangled_variant.clone();
-                    }
-                }
-                if let Some(info) = self.enum_variants.get(name.as_str()) {
-                    let field_types = info.field_types.clone();
-                    for (f, fty) in fields.iter_mut().zip(field_types.iter()) {
-                        let field_mangling: Option<BTreeMap<String, String>> = match fty {
-                            PlumType::TNamed(n) => self.enum_variant_mangling.get(n).cloned(),
-                            _ => None,
-                        };
-                        self.manglePattern(
-                            f,
-                            fty,
-                            field_mangling.as_ref(),
-                            case_env,
-                            body,
-                            guard.as_deref_mut(),
-                        );
-                    }
-                }
-            }
-            _ => {}
-        }
-    }
-    fn rewriteStmt(&mut self, stmt: &mut ast::Stmt, env: &mut TypeEnv) -> Result<(), String> {
-        match stmt {
-            ast::Stmt::Assign(a) => {
-                for (target, value) in a.targets.iter_mut().zip(a.values.iter_mut()) {
-                    // For a field target (`self.head = End`), resolve the
-                    // value against the field's OWN declared type BEFORE the
-                    // generic rewrite/inference below — same reasoning as
-                    // `ClassCall`'s field values: a bare payload-free variant
-                    // has no type of its own, but the field it's being
-                    // written into does.
-                    if let ast::AssignTarget::Field(object, field_name) = target {
-                        if let PlumType::TNamed(class_name) = self.infer(object, env) {
-                            let ctx = CheckCtx {
-                                methods: &self.methods,
-                                enum_variants: &self.enum_variants,
-                                enum_params: &self.enum_params,
-                                min_required: &self.min_required,
-                            };
-                            if let Ok(field_ty) =
-                                crate::lookupFieldType(&class_name, field_name, &ctx)
-                            {
-                                self.resolveBareVariantAgainstExpected(value, &field_ty);
-                                self.wrapPrimitiveAgainstExpected(value, &field_ty, env);
-                            }
-                        }
-                    }
-                    self.rewriteExpr(value, env)?;
-                    let ty = self.inferConcrete(value, env);
-                    match target {
-                        ast::AssignTarget::Var(name) => {
-                            self.seedLocalType(name, &ty);
-                            env.insert(name.clone(), TypeScheme::mono(ty));
-                        }
-                        ast::AssignTarget::Field(object, _) => {
-                            self.rewriteExpr(object, env)?;
-                        }
-                    }
-                }
-            }
-            ast::Stmt::Return(Some(e)) => {
-                // Same idea as the field-target case above, but against the
-                // enclosing function's own declared return type (`return
-                // End` inside a method returning `Link[Int]`).
-                if let Some(rt) = self.current_return_type.clone() {
-                    let resolved = self.resolveFieldType(&rt);
-                    let expected = crate::plumTypeFromAst(&resolved);
-                    self.resolveBareVariantAgainstExpected(e, &expected);
-                    self.wrapPrimitiveAgainstExpected(e, &expected, env);
-                }
-                self.rewriteExpr(e, env)?;
-            }
-            ast::Stmt::Return(None) => {}
-            ast::Stmt::If(if_) => {
-                self.rewriteExpr(&mut if_.condition, env)?;
-                self.rewriteBlock(&mut if_.body, &mut env.clone())?;
-                for ei in &mut if_.else_ifs {
-                    self.rewriteExpr(&mut ei.condition, env)?;
-                    self.rewriteBlock(&mut ei.body, &mut env.clone())?;
-                }
-                if let Some(else_block) = &mut if_.else_ {
-                    self.rewriteBlock(else_block, &mut env.clone())?;
-                }
-            }
-            ast::Stmt::While(w) => {
-                self.rewriteExpr(&mut w.condition, env)?;
-                self.rewriteBlock(&mut w.body, &mut env.clone())?;
-            }
-            ast::Stmt::For(f) => {
-                self.rewriteExpr(&mut f.iter, env)?;
-                // `for i := range n` binds `i: Int` — but `for v := range
-                // values` over a `...T` variadic param binds `v: T` (whatever
-                // `T` was specialized to), NOT `Int`. Without this check, a
-                // variadic loop var was always (wrongly) recorded as `Int` in
-                // this pass's own type env — harmless whenever `T` really was
-                // `Int` (masking the bug in e.g. `makeList`/`List.add`'s own
-                // `for v := range values` for every `List[Int]` test), but
-                // silently wrong for any other element type (e.g.
-                // `List[Pair[Str, Int]]`), producing bogus inferred types for
-                // anything built from `v` later in the body (like the `T` a
-                // `Node(value: v, ...)` construction infers).
-                let elem_ty = match self.infer(&f.iter, env) {
-                    PlumType::TVariadic(elem) => *elem,
-                    _ => PlumType::TInt,
-                };
-                let mut inner = env.clone();
-                let ast::For { vars, body, .. } = f;
-                for v in vars.iter_mut() {
-                    let bound = self.dedupLocalName(v, &elem_ty, body);
-                    inner.insert(bound.clone(), TypeScheme::mono(elem_ty.clone()));
-                    *v = bound;
-                }
-                self.rewriteBlock(body, &mut inner)?;
-            }
-            ast::Stmt::Expr(e, ..) => self.rewriteExpr(e, env)?,
-            ast::Stmt::Crash(e) => self.rewriteExpr(e, env)?,
-            ast::Stmt::Assert(c) => self.rewriteExpr(&mut c.cond, env)?,
-            ast::Stmt::Match(m) => {
-                for s in &mut m.subjects {
-                    self.rewriteExpr(s, env)?;
-                }
-                // One (type, variant-mangling table) pair per subject — `match a, b`
-                // needs each position's own generic-enum specialization handled
-                // independently, not just the first subject's.
-                let subject_types: Vec<PlumType> = m
-                    .subjects
-                    .iter()
-                    .map(|s| self.inferConcrete(s, env))
-                    .collect();
-                // If a subject's concrete type is a specialized generic enum, its
-                // variant-name mangling table lets us rewrite that position's patterns
-                // (`Next`/`End` -> `Next$Int`/`End$Int`) to reference the correct
-                // specialization, so the checker/codegen's unmodified, bare-name-keyed
-                // `EnumVariants` lookup still resolves each pattern correctly.
-                let variant_manglings: Vec<Option<BTreeMap<String, String>>> = subject_types
-                    .iter()
-                    .map(|ty| match ty {
-                        PlumType::TNamed(n) => self.enum_variant_mangling.get(n).cloned(),
-                        _ => None,
-                    })
-                    .collect();
-                for case in &mut m.cases {
-                    let mut case_env = env.clone();
-                    let ast::Case {
-                        patterns,
-                        guard,
-                        body,
-                    } = case;
-                    for (pat, (subject_ty, variant_mangling)) in patterns
-                        .iter_mut()
-                        .zip(subject_types.iter().zip(variant_manglings.iter()))
-                    {
-                        self.manglePattern(
-                            pat,
-                            subject_ty,
-                            variant_mangling.as_ref(),
-                            &mut case_env,
-                            body,
-                            guard.as_mut(),
-                        );
-                    }
-                    if let Some(g) = guard {
-                        self.rewriteExpr(g, &case_env)?;
-                    }
-                    // A case body's own LAST statement, when it's a bare
-                    // `Stmt::Expr`, is itself an implicit-return position
-                    // whenever this whole `match` is the function's tail
-                    // expression (`first`/`last`'s `End =>` arm ending in a
-                    // bare `End`, for instance) — same reasoning as
-                    // `rewriteFnBody`'s own tail-expression handling, just one
-                    // level down through the match. Resolving against the
-                    // function's OWN declared return type is a no-op unless
-                    // the expression is actually a bare payload-free variant
-                    // of that same enum family, so this is harmless even for
-                    // a match that ISN'T in tail position.
-                    if let Some(rt) = self.current_return_type.clone() {
-                        let resolved = self.resolveFieldType(&rt);
-                        let expected = crate::plumTypeFromAst(&resolved);
-                        if let Some(ast::Stmt::Expr(e, ..)) = body.stmts.last_mut() {
-                            self.resolveBareVariantAgainstExpected(e, &expected);
-                            self.wrapPrimitiveAgainstExpected(e, &expected, &case_env);
-                        }
-                    }
-                    self.rewriteBlock(body, &mut case_env)?;
-                }
-            }
-            ast::Stmt::Break | ast::Stmt::Continue | ast::Stmt::Todo => {}
-        }
-        Ok(())
-    }
-    /// Resolves a `Type(field: value, ...)` construction of a generic,
-    /// record-shaped (single-variant, named-payload) enum — the `type X[T] =
-    /// ...` replacement shape, e.g. `List[T]`/`Map[K, V]`. `ClassCall` is the
-    /// shared AST node this call shape ALSO uses for a non-generic or already-
-    /// mangled enum variant's own named-payload construction (see
-    /// `plum-checker`'s `inferClassCallRaw`) — this only fires for one that's
-    /// still a bare, generic TEMPLATE name.
-    fn resolveClassInstantiation(
-        &mut self,
-        call: &mut ast::ClassCall,
-        env: &TypeEnv,
-    ) -> Result<(), String> {
-        let Some(e) = self
-            .enums_generic_by_name
-            .get(call.type_name.as_str())
-            .copied()
-        else {
-            return Ok(());
-        };
-        let params = enumGenericParams(e);
-        let variant = &e.variants[0];
-        let mut bindings: BTreeMap<String, PlumType> = BTreeMap::new();
-        for gp in &params {
-            if let Some(idx) = variant.fields.iter().position(|t| t.name == *gp) {
-                let field_name = &variant.field_names[idx];
-                if let Some(fa) = call.fields.iter().find(|fa| &fa.name == field_name) {
-                    // A bare payload-free variant reference (`End`) carries
-                    // no type of its own to bind a generic param FROM — skip
-                    // it here; it gets resolved AGAINST the binding (once
-                    // known) below instead, same as every other field.
-                    let is_bare_variant = matches!(&fa.value, ast::Expr::TypeName(n) if self.enums_generic_by_variant.contains_key(n));
-                    if !is_bare_variant {
-                        bindings.insert(gp.clone(), self.infer(&fa.value, env));
-                    }
-                }
-            }
-        }
-        // No field is EVER directly typed as a bare generic param for a type
-        // like `List[T]` (its fields are `Link[Node[T]]`/`Int`, never a bare
-        // `T`) — and even where one exists, constructing with a payload-free
-        // value (`List(head: End, ...)`) gives no VALUE to infer a type from
-        // regardless. Fall back to an explicit `List[Int](...)` annotation at
-        // the call site when field-value inference alone isn't enough.
-        if bindings.len() != params.len() && call.generics.len() == params.len() {
-            let explicit_generics = call.generics.clone();
-            for (p, gt) in params.iter().zip(explicit_generics.iter()) {
-                if !bindings.contains_key(p) {
-                    // `resolveFieldType` first (not a bare `plumTypeFromAst`) —
-                    // `gt` may itself be a generic-with-args type (e.g. the
-                    // `Pair[Str, Int]` in `List[Pair[Str, Int]](...)`), which
-                    // `plumTypeFromAst` alone would silently flatten to the
-                    // bare, unmangled `TNamed("Pair")` (it drops `.generics`
-                    // entirely) — exactly the same recursive resolution
-                    // `resolveFieldType` already does for a field's own
-                    // declared type, just applied here to an explicit
-                    // call-site type argument instead.
-                    let resolved = self.resolveFieldType(gt);
-                    bindings.insert(p.clone(), crate::plumTypeFromAst(&resolved));
-                }
-            }
-        }
-        // Still not fully resolved — fall back to the enclosing function's own
-        // declared return type, exactly like `resolveEnumInstantiation` already
-        // does for a generic-enum construction site that can't see every
-        // parameter from its own arguments. This is what makes `fun
-        // makeList(values: ...T) -> List[T] = List(head: End, ...).add(values)`
-        // work: the bare `List(...)` construction gives no type witness at all
-        // (every field value is a payload-free `End`/`0`), but by the time
-        // THIS function is specialized for a concrete `T`, `current_return_type`
-        // has already been substituted to e.g. `List[Int]` by `specializeFn`.
-        if bindings.len() != params.len() {
-            if let Some(rt) = self.current_return_type.clone() {
-                if rt.name == call.type_name && rt.generics.len() == params.len() {
-                    for (p, gt) in params.iter().zip(rt.generics.iter()) {
-                        if !bindings.contains_key(p) {
-                            // See the matching comment on the `call.generics`
-                            // fallback above — `gt` needs the same recursive
-                            // `resolveFieldType` resolution before dropping
-                            // into `plumTypeFromAst`.
-                            let resolved = self.resolveFieldType(gt);
-                            bindings.insert(p.clone(), crate::plumTypeFromAst(&resolved));
-                        }
-                    }
-                }
-            }
-        }
-        if bindings.len() != params.len() {
-            return Err(format!(
-                "monomorphize: could not resolve all generic parameters for '{}' at this call site — pass them explicitly, e.g. '{}[Int](...)'",
-                call.type_name, call.type_name
-            ));
-        }
-        let mangled = self.ensureEnumSpecialized(e, &params, bindings);
-        // Now that every generic param is bound, resolve any bare
-        // payload-free-variant field values (`End`) against THIS
-        // specialization's own field types — codegen only ever sees the
-        // mangled specialization (the generic template is dropped), so a
-        // still-bare `End` would be an unresolvable reference by the time it
-        // gets there.
-        if let Some(info) = self.enum_variants.get(&mangled).cloned() {
-            for fa in &mut call.fields {
-                if let Some(idx) = info.field_names.iter().position(|n| n == &fa.name) {
-                    let expected = info.field_types[idx].clone();
-                    self.resolveBareVariantAgainstExpected(&mut fa.value, &expected);
-                    self.resolveGenericVariantAgainstExpected(&mut fa.value, &expected);
-                    self.wrapPrimitiveAgainstExpected(&mut fa.value, &expected, env);
-                }
-            }
-        }
-        call.type_name = mangled;
-        Ok(())
-    }
-    /// The `Arg`'s underlying expression, regardless of whether it was passed
-    /// positionally or by keyword — the same three-way match repeated at every
-    /// call site in this file, pulled out once for `resolveMethodOwnGenerics`.
-    fn argExprAt(call: &ast::FnCall, i: usize) -> Option<&ast::Expr> {
-        call.args.get(i).map(|arg| match arg {
-            ast::Arg::Positional(e) => e,
-            ast::Arg::Keyword { value, .. } => value,
-            ast::Arg::Pair { value, .. } => value,
-        })
-    }
-    /// Rewrites every closure-literal argument of a method call's OWN generic
-    /// construction sites BEFORE anything else touches that argument. Must run
-    /// ahead of the generic "walk every arg" rewrite in `rewriteExpr`'s
-    /// `Attribute` arm — that generic walk seeds a closure's params as
-    /// unconstrained `TVar`s (it has no way to know a method's declared
-    /// closure-param types), and once a construction inside a closure body
-    /// (e.g. `andThen`'s `|n| Next(n / 2)`) gets mangled against a WRONG
-    /// (`TVar`-derived) binding, nothing downstream can fix it —
-    /// `resolveEnumInstantiation` only fires for a bare, still-unmangled
-    /// variant name, so a premature wrong rewrite sticks permanently. Called
-    /// unconditionally for every method call (regardless of whether it turns
-    /// out to have its own extra generics — an ORDINARY method's closure arg,
-    /// e.g. `List.any(|x| ...)`, needs its body rewritten too, just seeded
-    /// from `method`'s own declared closure-param types with no extra
-    /// generic involved). Falls back to `env` as-is (the same behavior the
-    /// generic walk used to provide) for a receiver that isn't a resolvable
-    /// generic specialization, or a method not found on it.
-    fn rewriteMethodClosureArgs(
-        &mut self,
-        object: &ast::Expr,
-        call: &mut ast::FnCall,
-        env: &TypeEnv,
-    ) -> Result<(), String> {
-        let mut method_and_bindings: Option<(&'a ast::Fn, BTreeMap<String, PlumType>)> = None;
-        if let PlumType::TNamed(mangled_receiver) = self.inferConcrete(object, env) {
-            if let Some((template_name, class_bindings)) = self
-                .class_specialization_info
-                .get(&mangled_receiver)
-                .cloned()
-            {
-                let method = self
-                    .methods_generic_on_enum
-                    .get(template_name.as_str())
-                    .and_then(|methods| methods.iter().find(|m| m.name == call.name).copied());
-                if let Some(method) = method {
-                    method_and_bindings = Some((method, class_bindings));
-                }
-            }
-        }
-        for (i, arg) in call.args.iter_mut().enumerate() {
-            let arg_expr = match arg {
-                ast::Arg::Positional(e) => e,
-                ast::Arg::Keyword { value, .. } => value,
-                ast::Arg::Pair { value, .. } => value,
-            };
-            let ast::Expr::Closure(cl) = arg_expr else {
-                continue;
-            };
-            let closure_param_tys: Vec<PlumType> = match &method_and_bindings {
-                Some((method, class_bindings)) => match method.params.get(i).map(|p| &p.ty) {
-                    Some(ast::ParamType::Fn(params, _)) => params
-                        .iter()
-                        .map(|t| substituteType(t, &Substitution(class_bindings.clone())))
-                        .map(|t| crate::plumTypeFromAst(&t))
-                        .collect(),
-                    _ => Vec::new(),
-                },
-                None => Vec::new(),
-            };
-            // The closure's own declared return, with the receiver's bindings
-            // substituted (`andThen`'s `cb: fn(T) -> Try[U, E]` on a
-            // `Try[Int, [Bad]]` receiver -> `Try[U, [Bad]]`). A bare `Ok(n * 2)`
-            // in the closure body can only pin `T`, never `E`; without this it
-            // fell back to the ENCLOSING function's return type (wrong scope)
-            // and stayed unmangled, so `resolveMethodOwnGenerics` couldn't
-            // recover `U`. Only a non-bare-letter return is used (a bare
-            // `fn(T) -> U` says nothing more than the outer fallback did).
-            let closure_expected_ret: Option<ast::Type> = match &method_and_bindings {
-                Some((method, class_bindings)) => match method.params.get(i).map(|p| &p.ty) {
-                    Some(ast::ParamType::Fn(_, Some(ret))) if !ret.generics.is_empty() => {
-                        Some(substituteType(ret, &Substitution(class_bindings.clone())))
-                    }
-                    _ => None,
-                },
-                None => None,
-            };
-            let mut closure_env = env.clone();
-            for (p, ty) in cl.params.iter().zip(closure_param_tys.iter()) {
-                closure_env.insert(p.clone(), TypeScheme::mono(ty.clone()));
-            }
-            for p in &cl.params {
-                closure_env
-                    .entry(p.clone())
-                    .or_insert_with(|| TypeScheme::mono(PlumType::TVar("_".to_string())));
-            }
-            if let Some(expected) = closure_expected_ret {
-                let saved_ret = self.current_return_type.replace(expected);
-                let saved_flag = std::mem::replace(&mut self.return_type_is_closure_expected, true);
-                // Nested closures keep the outermost real function's return.
-                let saved_outer = if saved_flag {
-                    self.closure_outer_return_type.clone()
-                } else {
-                    std::mem::replace(&mut self.closure_outer_return_type, saved_ret.clone())
-                };
-                let result = self.rewriteBlock(&mut cl.body, &mut closure_env);
-                self.current_return_type = saved_ret;
-                self.return_type_is_closure_expected = saved_flag;
-                self.closure_outer_return_type = saved_outer;
-                result?;
-            } else {
-                self.rewriteBlock(&mut cl.body, &mut closure_env)?;
-            }
-        }
-        Ok(())
-    }
-    /// If `call` invokes a method that has generic param(s) of its OWN, beyond
-    /// its receiver enum's own (e.g. `List[T].map`'s `U`) — a shape
-    /// `registerEnumMethodSignatures`/the `PendingSpecialization::Enum`
-    /// worklist arm deliberately skip producing anything for — infers those
-    /// extra param(s) from `call`'s own arguments (a plain arg's own type for a
-    /// bare-letter param, or a closure argument's INFERRED BODY TYPE for a
-    /// closure-typed param whose return is the letter), then specializes+
-    /// registers a new per-CALL-SITE mangled method (e.g. `"map$Str"`) — the
-    /// same idea as a truly generic free function's own `fns_generic`/
-    /// `resolveFnInstantiation`, just combined with the receiver's own already-
-    /// known enum-level bindings (e.g. `T = Int`) — and rewrites `call.name`
-    /// to it. No-op if `object`'s type isn't a specialization this pass has
-    /// recorded `class_specialization_info` for, or the method has no extra
-    /// generics of its own (the ordinary, already-handled case).
-    fn resolveMethodOwnGenerics(
-        &mut self,
-        object: &ast::Expr,
-        call: &mut ast::FnCall,
-        env: &TypeEnv,
-    ) -> Result<(), String> {
-        let PlumType::TNamed(mangled_receiver) = self.inferConcrete(object, env) else {
-            return Ok(());
-        };
-        let Some((template_name, class_bindings)) = self
-            .class_specialization_info
-            .get(&mangled_receiver)
-            .cloned()
-        else {
-            return Ok(());
-        };
-        let method = self
-            .methods_generic_on_enum
-            .get(template_name.as_str())
-            .and_then(|methods| methods.iter().find(|m| m.name == call.name).copied());
-        let Some(method) = method else { return Ok(()) };
-        let owner_params: Vec<String> = class_bindings.keys().cloned().collect();
-        let extra = methodOwnGenericParams(method, &owner_params);
-        if extra.is_empty() {
-            return Ok(());
-        }
-        let mut full_bindings = class_bindings.clone();
-        for (letter, source) in &extra {
-            match *source {
-                ExtraGenericSource::Param(i) => {
-                    let arg_expr = Self::argExprAt(call, i)
-                        .ok_or_else(|| format!("monomorphize: '{}.{}' call is missing arg {} needed to infer its own generic parameter '{}'", template_name, call.name, i, letter))?;
-                    full_bindings.insert(letter.clone(), self.infer(arg_expr, env));
-                }
-                ExtraGenericSource::ClosureReturn(i) => {
-                    // The closure's body was already rewritten (any generic
-                    // construction inside it, e.g. `andThen`'s `Next(n / 2)`,
-                    // already mangled to its real specialization) by
-                    // `rewriteMethodClosureArgs`, called before this — just
-                    // re-seed the same closure-param env to infer its
-                    // (already-rewritten) tail type, not rewrite it again.
-                    let (closure_param_tys, declared_ret): (Vec<PlumType>, Option<ast::Type>) =
-                        match &method.params[i].ty {
-                            ast::ParamType::Fn(params, ret) => (
-                                params
-                                    .iter()
-                                    .map(|t| {
-                                        substituteType(t, &Substitution(class_bindings.clone()))
-                                    })
-                                    .map(|t| crate::plumTypeFromAst(&t))
-                                    .collect(),
-                                ret.as_deref().cloned(),
-                            ),
-                            _ => (Vec::new(), None),
-                        };
-                    let arg_expr = Self::argExprAt(call, i)
-                        .ok_or_else(|| format!("monomorphize: '{}.{}' call is missing arg {} needed to infer its own generic parameter '{}'", template_name, call.name, i, letter))?;
-                    let ast::Expr::Closure(cl) = arg_expr else {
-                        return Err(format!(
-                            "monomorphize: '{}.{}' needs a closure literal argument (not a stored value) to infer its own generic parameter '{}'",
-                            template_name, call.name, letter
-                        ));
-                    };
-                    let mut closure_env = env.clone();
-                    for (p, ty) in cl.params.iter().zip(closure_param_tys.iter()) {
-                        closure_env.insert(p.clone(), TypeScheme::mono(ty.clone()));
-                    }
-                    let bound = match cl.body.stmts.last() {
-                        Some(ast::Stmt::Expr(e, ..)) => self.infer(e, &closure_env),
-                        Some(ast::Stmt::Return(Some(e))) => self.infer(e, &closure_env),
-                        _ => PlumType::TUnit,
-                    };
-                    // A bare closure return (`cb: fn(T) -> U`, e.g. `List.map`)
-                    // binds `letter` directly to the closure's whole inferred
-                    // type. A NESTED one (`cb: fn(T) -> Link[U]`, e.g.
-                    // `Link.andThen`) instead needs `bound` (the closure's
-                    // ACTUAL concrete return, e.g. `Link$Int`) matched back
-                    // against the DECLARED shape `Link[U]` to recover what
-                    // `U` itself was — `bindGenericArg` (shared with
-                    // `resolveFnInstantiation`'s free-function argument
-                    // binding) does exactly that structural extraction.
-                    match &declared_ret {
-                        Some(declared) if !declared.generics.is_empty() => {
-                            self.bindGenericArg(declared, &bound, &mut full_bindings);
-                        }
-                        _ => {
-                            full_bindings.insert(letter.clone(), bound);
-                        }
-                    }
-                }
-            }
-        }
-        for (letter, _) in &extra {
-            if !full_bindings.contains_key(letter) {
-                return Err(format!(
-                    "monomorphize: '{}.{}' could not resolve its own generic parameter '{}' from this call site",
-                    template_name, call.name, letter
-                ));
-            }
-        }
-        let extra_type_args: Vec<PlumType> = extra
-            .iter()
-            .map(|(l, _)| full_bindings[l].clone())
-            .collect();
-        // Receiver-qualified (not just `mangle(&call.name, &extra_type_args)`)
-        // because `self.specialized`/`self.enqueued` (below, inherited from the
-        // generic-FREE-function machinery this reuses) are FLAT sets keyed by
-        // this bare string alone, globally across the whole program — without
-        // the receiver folded in, two unrelated receivers whose OWN method
-        // happens to mangle to the same suffix (e.g. `Link[Int].map` and
-        // `List[Int].map` both producing `"map$Str"`) would collide: the
-        // second one popped would find the first's bare name already in
-        // `specialized` and silently skip producing its own body.
-        let mangled_method = format!(
-            "{}${}",
-            mangled_receiver,
-            mangle(&call.name, &extra_type_args)
-        );
-        let key = (mangled_receiver.clone(), mangled_method.clone());
-        if !self.methods.contains_key(&key) {
-            // Eagerly resolve a full signature right now (mirroring
-            // `registerClassMethodSignatures`) so THIS SAME statement (e.g.
-            // `list.map(f).toStr()`) can resolve the call's result type
-            // immediately — separately from the fresh, UNRESOLVED copy queued
-            // below for the worklist to turn into a real body (its own
-            // `resolveFnParamTypes`/`resolveFnReturnType` need to run around
-            // `rewriteFnBody`, not before it, per their own ordering rules).
-            let mut sig_method = specializeFn(
-                method,
-                &Substitution(full_bindings.clone()),
-                &mangled_method,
-                Some(mangled_receiver.clone()),
-            );
-            self.resolveFnSignature(&mut sig_method);
-            let param_types: Vec<PlumType> = sig_method
-                .params
-                .iter()
-                .map(|p| match &p.ty {
-                    ast::ParamType::Type(t) => crate::plumTypeFromAst(t),
-                    ast::ParamType::Variadic(t) => {
-                        PlumType::TVariadic(Box::new(crate::plumTypeFromAst(t)))
-                    }
-                    ast::ParamType::Fn(params, ret) => {
-                        let param_types = params.iter().map(crate::plumTypeFromAst).collect();
-                        let ret_ty = ret
-                            .as_ref()
-                            .map(|r| crate::plumTypeFromAst(r))
-                            .unwrap_or(PlumType::TUnit);
-                        PlumType::TFun(param_types, Box::new(ret_ty))
-                    }
-                })
-                .collect();
-            let ret = sig_method
-                .returns
-                .as_ref()
-                .map(crate::plumTypeFromAst)
-                .unwrap_or(PlumType::TUnit);
-            self.methods
-                .insert(key, PlumType::TFun(param_types, Box::new(ret)));
-            self.enqueued.insert(mangled_method.clone());
-            self.worklist.push(PendingSpecialization::Fn {
-                base: method,
-                subst: Substitution(full_bindings),
-                mangled: mangled_method.clone(),
-                new_receiver: Some(mangled_receiver),
-            });
-        }
-        call.name = mangled_method;
-        Ok(())
-    }
-    /// Without this, a method call chained directly onto a FRESH
-    /// enum construction in the same statement (`Next(4).filter(...)`, or
-    /// any `SomeVariant(...).method(...)` one-liner for a generic enum) could
-    /// never resolve: the receiver's specialization is only ENQUEUED here,
-    /// not fully produced until the worklist drains (well after the current
-    /// forward pass over top-level items finishes), so `self.methods` had no
-    /// entry yet for `(mangled, method_name)` when `inferExpr` needed one —
-    /// silently falling back to an unresolved type, which then couldn't tell
-    /// a `match` on the result which mangled variant names to rewrite its
-    /// patterns to, surfacing many statements later and confusingly as a
-    /// codegen-time "variant missing from the GC type registry" panic.
-    fn registerEnumMethodSignatures(
-        &mut self,
-        e: &'a ast::Enum,
-        mangled: &str,
-        bindings: &BTreeMap<String, PlumType>,
-    ) {
-        let Some(methods) = self.methods_generic_on_enum.get(e.name.as_str()).cloned() else {
-            return;
-        };
-        let owner_params = enumGenericParams(e);
-        self.registerMethodSignatures(&e.name, mangled, methods, &owner_params, bindings);
-    }
-    /// Shared body of `registerClassMethodSignatures`/`registerEnumMethodSignatures`
-    /// — eagerly resolves and registers (into `self.methods`) the `(mangled,
-    /// method_name) -> TFun` signature of every ORDINARY (no generic params
-    /// of its own — see the skip below) method in `methods`, for the
-    /// specialization named `mangled` under `bindings`, without producing the
-    /// actual `ast::Fn` bodies (that still only happens once the worklist
-    /// entry for this specialization is popped). If this specialization is
-    /// itself already nested (`isSelfNested`), skips (only) a method whose
-    /// return type would construct yet another nested specialization
-    /// (`methodMentionsTemplate`) — the self-nesting landmine. Deliberately
-    /// NOT a blanket skip for every method whenever `mangled` is
-    /// self-nested: `List$List$Int`'s own `add`/`get`/etc are perfectly
-    /// finite regardless (their return types don't mention `List` at all)
-    /// and are needed for `chunk`'s own body (`result.add(piece)`) to even
-    /// compile — only `chunk`/`partition` THEMSELVES, called again on an
-    /// already-nested `List$List$Int`, would recurse into a third level and
-    /// must be skipped.
-    fn registerMethodSignatures(
-        &mut self,
-        template_name: &str,
-        mangled: &str,
-        methods: Vec<&'a ast::Fn>,
-        owner_params: &[String],
-        bindings: &BTreeMap<String, PlumType>,
-    ) {
-        let already_nested = self.isSelfNested(template_name, bindings);
-        for method in methods {
-            // See the matching comment in the `PendingSpecialization::Class`/
-            // `PendingSpecialization::Enum` worklist arms — a method with its
-            // OWN extra generic param(s) is resolved per-call-site by
-            // `resolveMethodOwnGenerics` instead.
-            if !methodOwnGenericParams(method, owner_params).is_empty() {
-                continue;
-            }
-            if already_nested && Self::methodMentionsTemplate(method, template_name) {
-                continue;
-            }
-            let key = (mangled.to_string(), method.name.clone());
-            if self.methods.contains_key(&key) {
-                continue;
-            }
-            let mut specialized_method = specializeFn(
-                method,
-                &Substitution(bindings.clone()),
-                &method.name,
-                Some(mangled.to_string()),
-            );
-            self.resolveFnSignature(&mut specialized_method);
-            let param_types: Vec<PlumType> = specialized_method
-                .params
-                .iter()
-                .map(|p| match &p.ty {
-                    ast::ParamType::Type(t) => crate::plumTypeFromAst(t),
-                    ast::ParamType::Variadic(t) => {
-                        PlumType::TVariadic(Box::new(crate::plumTypeFromAst(t)))
-                    }
-                    ast::ParamType::Fn(params, ret) => {
-                        let param_types = params.iter().map(crate::plumTypeFromAst).collect();
-                        let ret_ty = ret
-                            .as_ref()
-                            .map(|r| crate::plumTypeFromAst(r))
-                            .unwrap_or(PlumType::TUnit);
-                        PlumType::TFun(param_types, Box::new(ret_ty))
-                    }
-                })
-                .collect();
-            let ret = specialized_method
-                .returns
-                .as_ref()
-                .map(crate::plumTypeFromAst)
-                .unwrap_or(PlumType::TUnit);
-            self.methods
-                .insert(key, PlumType::TFun(param_types, Box::new(ret)));
-        }
-    }
-    /// If `expr` is a bare reference to a payload-free variant of a GENERIC
-    /// enum (`End`), and `expected` names a SPECIFIC specialization of that
-    /// same enum (`Link$Node$Int`), rewrites `expr`'s name to that
-    /// specialization's own mangled variant name (`End$Node$Int`) and
-    /// ensures that specialization is registered — codegen only ever knows
-    /// about specializations (the generic template enum is dropped entirely),
-    /// so an un-rewritten bare reference would be unresolvable by the time it
-    /// gets there. No-op if `expr` isn't a bare generic-enum variant, or
-    /// `expected` doesn't name a specialization of the SAME enum.
-    fn resolveBareVariantAgainstExpected(&mut self, expr: &mut ast::Expr, expected: &PlumType) {
-        self.markTagsAgainstExpected(expr, expected);
-        let ast::Expr::TypeName(n) = expr else { return };
-        let Some(e) = self.enums_generic_by_variant.get(n.as_str()).copied() else {
-            return;
-        };
-        let PlumType::TNamed(mangled) = expected else {
-            return;
-        };
-        if !mangled.starts_with(&format!("{}$", e.name)) {
-            return;
-        }
-        if let Some(table) = self.enum_variant_mangling.get(mangled) {
-            if let Some(mangled_variant) = table.get(n) {
-                *n = mangled_variant.clone();
-            }
-        }
-    }
-    /// A tag literal (`Bad` / `Bad(x)`) whose expected type is a tag union
-    /// naming it, but whose name a declared variant also uses (`enum Rating =
-    /// | Bad(...)`): prefixes it with `crate::TAG_MARKER` so the checker and
-    /// codegen treat it as the tag, not the variant. Recurses into an
-    /// already-specialized variant construction's payloads (`Err$Int$[Bad](Bad)`)
-    /// against that variant's own field types.
-    fn markTagsAgainstExpected(&self, expr: &mut ast::Expr, expected: &PlumType) {
-        let collides = |n: &str| {
-            self.enum_variants.contains_key(n) || self.enums_generic_by_variant.contains_key(n)
-        };
-        match expr {
-            ast::Expr::Paren(inner) => self.markTagsAgainstExpected(inner, expected),
-            ast::Expr::TypeName(n) => {
-                if let PlumType::TTags(tags) = expected {
-                    if matches!(tags.get(n.as_str()), Some(None)) && collides(n) {
-                        *n = format!("{}{}", crate::TAG_MARKER, n);
-                    }
-                }
-            }
-            ast::Expr::FnCall(call) => {
-                if let PlumType::TTags(tags) = expected {
-                    if call.args.len() == 1
-                        && matches!(tags.get(call.name.as_str()), Some(Some(_)))
-                        && collides(&call.name)
-                    {
-                        call.name = format!("{}{}", crate::TAG_MARKER, call.name);
-                    }
-                    return;
-                }
-                if self.enums_generic_by_variant.contains_key(call.name.as_str()) {
-                    return; // not specialized yet: no concrete field types
-                }
-                if let Some(info) = self.enum_variants.get(call.name.as_str()) {
-                    for (arg, ft) in call.args.iter_mut().zip(info.field_types.iter()) {
-                        let e = match arg {
-                            ast::Arg::Positional(e) => e,
-                            ast::Arg::Keyword { value, .. } => value,
-                            ast::Arg::Pair { value, .. } => value,
-                        };
-                        self.markTagsAgainstExpected(e, ft);
-                    }
-                }
-            }
-            _ => {}
-        }
-    }
-    /// `Ok(3)` passed where a concrete `Try$Int$[X]` is expected (a typed
-    /// param or field): a generic variant whose own payload can't pin every
-    /// enum param takes its specialization from that expected type instead —
-    /// the arg/field analogue of `resolveEnumInstantiation`'s return-type
-    /// fallback. Also marks colliding tag payloads (`Err(Bad)`).
-    fn resolveGenericVariantAgainstExpected(&mut self, expr: &mut ast::Expr, expected: &PlumType) {
-        if let ast::Expr::FnCall(call) = expr {
-            if let Some(e) = self.enums_generic_by_variant.get(call.name.as_str()).copied() {
-                if let PlumType::TNamed(mangled) = expected {
-                    if mangled.starts_with(&format!("{}$", e.name)) {
-                        if let Some(mv) = self
-                            .enum_variant_mangling
-                            .get(mangled)
-                            .and_then(|table| table.get(&call.name))
-                        {
-                            call.name = mv.clone();
-                        }
-                    }
-                }
-            }
-        }
-        self.markTagsAgainstExpected(expr, expected);
-    }
-    /// If `expr`'s own inferred type is a builtin primitive (`Int`/`Float`)
-    /// and `expected` names a "union" enum with a bare-primitive-wrap variant
-    /// matching that exact primitive (`enum Number = | Int | Float` — see
-    /// `buildGlobalTables`'s primitive bare-wrap condition), rewrites `expr`
-    /// in place into that variant's constructor call (`5` -> `Int(5)`),
-    /// reusing the ordinary positional-variant-construction codegen path
-    /// (`compileVariantConstruction`) unchanged. This is the primitive
-    /// analogue of the class bare-wrap sugar's `ClassCall`->`FnCall` rewrite
-    /// just below — unlike that one (which fires unconditionally, keyed only
-    /// on the constructed name), this MUST be expected-type-directed: `Int`/
-    /// `Float` are used as bare primitives everywhere in the language and
-    /// can't be globally reinterpreted as "the enum-wrapped value". No-op if
-    /// `expected` isn't such an enum, or `expr` isn't already exactly that
-    /// primitive type (a genuine mismatch is left for `unify`/`unifyArg` to
-    /// catch elsewhere).
-    fn wrapPrimitiveAgainstExpected(
-        &mut self,
-        expr: &mut ast::Expr,
-        expected: &PlumType,
-        env: &TypeEnv,
-    ) {
-        let PlumType::TNamed(enum_name) = expected else {
-            return;
-        };
-        let actual = self.infer(expr, env);
-        if !matches!(actual, PlumType::TInt | PlumType::TFloat) {
-            return;
-        }
-        let owner = self
-            .enum_variants
-            .iter()
-            .find(|(_, info)| &info.enum_name == enum_name && info.field_types == [actual.clone()]);
-        if let Some((variant_name, _)) = owner {
-            let inner = expr.clone();
-            *expr = ast::Expr::FnCall(ast::FnCall {
-                name: variant_name.clone(),
-                args: vec![ast::Arg::Positional(inner)],
-            });
-        }
-    }
-    /// True if the specialization about to be processed is ITSELF already a
-    /// nested instance of `template_name` — one of `bindings`'s VALUES is
-    /// either `template_name` itself or a recorded specialization OF it
-    /// (via `class_specialization_info`), e.g. `List$Int`'s `T` bound to
-    /// `Int` is NOT self-nested, but `List$List$Int`'s `T` bound to
-    /// `List$Int` IS. Guards the self-nesting landmine (a method returning
-    /// its OWN owning class/enum nested in itself, e.g. `List[T].chunk() ->
-    /// List[List[T]]`): resolving `chunk`'s return type for a specialization
-    /// that's ALREADY nested would create yet another, deeper nested
-    /// specialization, forever — and because this eager registration
-    /// happens once per WORKLIST entry (processed iteratively, not
-    /// recursively), a plain call-stack-scoped recursion guard tried first
-    /// was NOT enough to stop it (confirmed: hung 20+s with only that).
-    /// Combined with `methodMentionsTemplate` (only reachable, and only
-    /// meaningful, when this is true) — a specialization's OWN `add`/`get`/
-    /// etc are perfectly finite regardless of nesting and must NOT be
-    /// skipped, only a method whose return type would construct yet ANOTHER
-    /// nested specialization.
-    fn isSelfNested(&self, template_name: &str, bindings: &BTreeMap<String, PlumType>) -> bool {
-        bindings.values().any(|t| match t {
-            PlumType::TNamed(n) => {
-                n == template_name
-                    || self
-                        .class_specialization_info
-                        .get(n.as_str())
-                        .map(|(base, _)| base == template_name)
-                        .unwrap_or(false)
-            }
-            _ => false,
-        })
-    }
-    /// True if `method`'s OWN declared return type mentions `template_name`
-    /// anywhere (at any nesting depth, INCLUDING the top level — unlike a
-    /// naive structural check, depth doesn't matter here: this is only ever
-    /// consulted once `isSelfNested` has already confirmed the CURRENT
-    /// specialization is itself nested, at which point even a top-level
-    /// `List[...]` return needs a new, deeper nested specialization). See
-    /// `isSelfNested`'s doc comment for the full picture.
-    fn methodMentionsTemplate(method: &ast::Fn, template_name: &str) -> bool {
-        fn mentions(ty: &ast::Type, template_name: &str) -> bool {
-            ty.name == template_name || ty.generics.iter().any(|g| mentions(g, template_name))
-        }
-        method
-            .returns
-            .as_ref()
-            .map(|ret| mentions(ret, template_name))
-            .unwrap_or(false)
-    }
-    /// Fills `out` with a binding for every bare generic-letter type occurring
-    /// in `declared` (possibly nested inside a container type, e.g. `T` inside
-    /// `List[T]`), given `actual` — the ACTUAL concrete `PlumType` an argument
-    /// declared as `declared` was inferred to have. The bare case (`declared`
-    /// IS the letter, e.g. `a: T`) binds it directly to `actual`. The
-    /// container case (`declared` is `List[T]`/`Link[T]`/`Try[T, E]`,
-    /// `actual` is that container's own mangled specialization like
-    /// `List$Int`) looks up `actual`'s recorded `class_specialization_info`
-    /// (the SAME table `resolveMethodOwnGenerics` already trusts for a
-    /// method's own receiver) to recover the concrete type EACH of the
-    /// container's own generic params was bound to, then recurses — so
-    /// `List[T]` against `List$Int` binds `T -> Int`, and (one level deeper)
-    /// `List[Link[T]]` against `List$Link$Int` binds `T -> Int` too. A
-    /// mismatch (wrong container, or `actual` isn't even a named/specialized
-    /// type) silently binds nothing for that param, same as before this
-    /// existed — `resolveFnInstantiation`'s caller already rejects an
-    /// incomplete `bindings` set with a clear error.
-    fn bindGenericArg(
-        &self,
-        declared: &ast::Type,
-        actual: &PlumType,
-        out: &mut BTreeMap<String, PlumType>,
-    ) {
-        if declared.generics.is_empty() {
-            if isGenericParamName(&declared.name) {
-                out.entry(declared.name.clone())
-                    .or_insert_with(|| actual.clone());
-            }
-            return;
-        }
-        let PlumType::TNamed(mangled) = actual else {
-            return;
-        };
-        let Some((template_name, class_bindings)) =
-            self.class_specialization_info.get(mangled.as_str())
-        else {
-            return;
-        };
-        if template_name != &declared.name {
-            return;
-        }
-        let owner_params: Vec<String> = self
-            .enums_generic_by_name
-            .get(template_name.as_str())
-            .map(|e| enumGenericParams(e))
-            .unwrap_or_default();
-        for (declared_arg, owner_param) in declared.generics.iter().zip(owner_params.iter()) {
-            if let Some(bound) = class_bindings.get(owner_param) {
-                self.bindGenericArg(declared_arg, bound, out);
-            }
-        }
-    }
-    fn resolveFnInstantiation(
-        &mut self,
-        call: &mut ast::FnCall,
-        env: &TypeEnv,
-    ) -> Result<(), String> {
-        let Some(f) = self.fns_generic.get(call.name.as_str()).copied() else {
-            return Ok(());
-        };
-        let params = fnGenericParams(f);
-        let mut bindings: BTreeMap<String, PlumType> = BTreeMap::new();
-        for (param, arg) in f.params.iter().zip(call.args.iter()) {
-            let declared = match &param.ty {
-                ast::ParamType::Type(t) => Some(t),
-                ast::ParamType::Variadic(t) => Some(t),
-                // TODO: fn-value params don't yet resolve to a generic parameter.
-                ast::ParamType::Fn(_, _) => None,
-            };
-            if let Some(declared) = declared {
-                let arg_expr = match arg {
-                    ast::Arg::Positional(e) => e,
-                    ast::Arg::Keyword { value, .. } => value,
-                    ast::Arg::Pair { value, .. } => value,
-                };
-                let actual = self.infer(arg_expr, env);
-                self.bindGenericArg(declared, &actual, &mut bindings);
-            }
-        }
-        if bindings.len() != params.len() {
-            return Err(format!(
-                "monomorphize: could not resolve all generic parameters for '{}' at this call site",
-                call.name
-            ));
-        }
-        let type_args: Vec<PlumType> = params.iter().map(|p| bindings[p].clone()).collect();
-        let mangled = mangle(&call.name, &type_args);
-        if !self.specialized.contains(&mangled) && !self.enqueued.contains(&mangled) {
-            self.enqueued.insert(mangled.clone());
-            // Eagerly resolve and register this specialization's full signature
-            // into `global_env` right now (mirroring `registerClassMethodSignatures`
-            // for classes) — otherwise a statement in the SAME pass over the
-            // caller's body that needs this call's concrete return type (e.g.
-            // `l := makeList(1, 2, 3)` immediately followed by `l.map(...)`,
-            // where `resolveMethodOwnGenerics` needs `l`'s type to already be the
-            // mangled `"List$Int"`, not a fallback `TVar`) would see nothing —
-            // `global_env` was otherwise only updated once the worklist entry
-            // below is popped, which happens well after this whole top-level
-            // item has already been rewritten.
-            let mut sig_fn = specializeFn(f, &Substitution(bindings.clone()), &mangled, None);
-            self.resolveFnSignature(&mut sig_fn);
-            let param_types: Vec<PlumType> = sig_fn
-                .params
-                .iter()
-                .map(|p| match &p.ty {
-                    ast::ParamType::Type(t) => crate::plumTypeFromAst(t),
-                    ast::ParamType::Variadic(t) => {
-                        PlumType::TVariadic(Box::new(crate::plumTypeFromAst(t)))
-                    }
-                    ast::ParamType::Fn(params, ret) => {
-                        let param_types = params.iter().map(crate::plumTypeFromAst).collect();
-                        let ret_ty = ret
-                            .as_ref()
-                            .map(|r| crate::plumTypeFromAst(r))
-                            .unwrap_or(PlumType::TUnit);
-                        PlumType::TFun(param_types, Box::new(ret_ty))
-                    }
-                })
-                .collect();
-            let ret = sig_fn
-                .returns
-                .as_ref()
-                .map(crate::plumTypeFromAst)
-                .unwrap_or(PlumType::TUnit);
-            self.global_env.insert(
-                mangled.clone(),
-                TypeScheme::mono(PlumType::TFun(param_types, Box::new(ret))),
-            );
-            self.worklist.push(PendingSpecialization::Fn {
-                base: f,
-                subst: Substitution(bindings),
-                mangled: mangled.clone(),
-                new_receiver: None,
-            });
-        }
-        call.name = mangled;
-        Ok(())
-    }
-    /// The bare names of any generic class or enum referenced directly (not via a
-    /// lowercase-letter generic parameter) in `f`'s param types — e.g. `"Link"` for
-    /// `unwrapOr(o: Link, default: Int) -> Int`. See `fns_bare_generic`'s doc
-    /// comment for why such a function needs its own specialization.
-    fn fnBareGenericRefs(&self, f: &ast::Fn) -> Vec<String> {
-        let mut names: Vec<String> = Vec::new();
-        for p in &f.params {
-            let t = match &p.ty {
-                ast::ParamType::Type(t) => t,
-                ast::ParamType::Variadic(t) => t,
-                // TODO: fn-value params don't yet participate in bare-generic resolution.
-                ast::ParamType::Fn(_, _) => continue,
-            };
-            // A param already fully instantiated with concrete type arguments
-            // (`headers: Map[Str, Str]`) is NOT a bare reference to the generic
-            // template — only the truly bare spelling (`headers: Map`, no `[...]`
-            // at all) needs this function's own per-call-site specialization.
-            // Without this check, ANY function taking an already-concrete
-            // generic-typed param (however unrelated to its own logic) was
-            // wrongly routed through `fns_bare_generic`'s worklist instead of
-            // the ordinary per-item pass, silently dropping it from `m.produced`
-            // under its original name — the caller's own inferred return type
-            // (via `fn_return_generic_enum`, which doesn't consult this
-            // classification at all) still looked correct, masking the missing
-            // function until codegen.
-            if !t.generics.is_empty() {
-                continue;
-            }
-            let n = &t.name;
-            if self.enums_generic_by_name.contains_key(n.as_str()) && !names.iter().any(|x| x == n)
-            {
-                names.push(n.clone());
-            }
-        }
-        names
-    }
-    /// Resolves a call to an otherwise-ordinary function whose param type(s)
-    /// bare-name a generic class/enum, specializing it per call site exactly like a
-    /// truly-generic function — reusing the same `PendingSpecialization::Fn`
-    /// worklist entry and the unmodified `specializeFn`, whose substitution
-    /// mechanism already replaces any type whose bare name matches a substitution
-    /// key (it doesn't care whether that key came from a lowercase-letter generic
-    /// parameter or a bare generic class/enum reference).
-    fn resolveBareGenericFnInstantiation(
-        &mut self,
-        call: &mut ast::FnCall,
-        env: &TypeEnv,
-    ) -> Result<(), String> {
-        let Some(f) = self.fns_bare_generic.get(call.name.as_str()).copied() else {
-            return Ok(());
-        };
-        let refs = self.fnBareGenericRefs(f);
-        let mut bindings: BTreeMap<String, PlumType> = BTreeMap::new();
-        for (param, arg) in f.params.iter().zip(call.args.iter()) {
-            let n = match &param.ty {
-                ast::ParamType::Type(t) => t.name.clone(),
-                ast::ParamType::Variadic(t) => t.name.clone(),
-                // TODO: fn-value params don't yet resolve to a bare generic reference.
-                ast::ParamType::Fn(_, _) => String::new(),
-            };
-            if refs.contains(&n) {
-                let arg_expr = match arg {
-                    ast::Arg::Positional(e) => e,
-                    ast::Arg::Keyword { value, .. } => value,
-                    ast::Arg::Pair { value, .. } => value,
-                };
-                bindings
-                    .entry(n)
-                    .or_insert_with(|| self.infer(arg_expr, env));
-            }
-        }
-        if bindings.len() != refs.len() {
-            return Err(format!(
-                "monomorphize: could not resolve all generic parameters for '{}' at this call site",
-                call.name
-            ));
-        }
-        let type_args: Vec<PlumType> = refs.iter().map(|p| bindings[p].clone()).collect();
-        let mangled = mangle(&call.name, &type_args);
-        if !self.specialized.contains(&mangled) && !self.enqueued.contains(&mangled) {
-            self.enqueued.insert(mangled.clone());
-            self.worklist.push(PendingSpecialization::Fn {
-                base: f,
-                subst: Substitution(bindings),
-                mangled: mangled.clone(),
-                new_receiver: None,
-            });
-        }
-        call.name = mangled;
-        Ok(())
-    }
-    /// Resolves a construction of a generic enum's variant (e.g. `Next(5)` for
-    /// `enum Link = | Next(a) | End`), rewriting `call.name` from the bare
-    /// variant name (`Next`) to its mangled form (`Next$Int`) once the enum's own
-    /// concrete instantiation is known. Mangling is eager and deterministic — it
-    /// doesn't wait for the worklist to actually produce the specialized `ast::Enum`
-    /// (see `enum_variant_mangling`'s doc comment).
-    ///
-    /// A variant that carries no generic fields (e.g. `End`) can't pin down the
-    /// enum's type parameters on its own, so such a construction site is left alone
-    /// here — some other construction site (e.g. `Next(5)`) is what drives the
-    /// specialization. (A bare `End` used as a *value*, not a call, is
-    /// `ast::Expr::TypeName` and doesn't go through this function at all — see the
-    /// plan's Global Constraints for that narrower, documented residual limitation.)
-    fn resolveEnumInstantiation(
-        &mut self,
-        call: &mut ast::FnCall,
-        env: &TypeEnv,
-    ) -> Result<(), String> {
-        let Some(e) = self
-            .enums_generic_by_variant
-            .get(call.name.as_str())
-            .copied()
-        else {
-            return Ok(());
-        };
-        let params = enumGenericParams(e);
-        let Some(variant) = e.variants.iter().find(|v| v.name == call.name) else {
-            return Ok(());
-        };
-        // A payload whose param the enclosing return type pins to a tag union
-        // (`return Err(Bad)` in `-> Try[Int, [Bad]]`) is that tag, even when a
-        // declared variant shares its name — mark it before inferring from it.
-        if let Some(rt) = self.current_return_type.clone() {
-            if rt.name == e.name && rt.generics.len() == params.len() {
-                for (field_ty, arg) in variant.fields.iter().zip(call.args.iter_mut()) {
-                    let Some(pi) = params.iter().position(|p| p == &field_ty.name) else {
-                        continue;
-                    };
-                    let gt = &rt.generics[pi];
-                    if gt.generics.is_empty() && isGenericParamName(&gt.name) {
-                        continue;
-                    }
-                    let resolved = self.resolveFieldType(gt);
-                    let expected = crate::plumTypeFromAst(&resolved);
-                    if matches!(expected, PlumType::TTags(_)) {
-                        let arg_expr = match arg {
-                            ast::Arg::Positional(e) => e,
-                            ast::Arg::Keyword { value, .. } => value,
-                            ast::Arg::Pair { value, .. } => value,
-                        };
-                        self.markTagsAgainstExpected(arg_expr, &expected);
-                    }
-                }
-            }
-        }
-        let mut bindings: BTreeMap<String, PlumType> = BTreeMap::new();
-        for (field_ty, arg) in variant.fields.iter().zip(call.args.iter()) {
-            if params.contains(&field_ty.name) {
-                let arg_expr = match arg {
-                    ast::Arg::Positional(e) => e,
-                    ast::Arg::Keyword { value, .. } => value,
-                    ast::Arg::Pair { value, .. } => value,
-                };
-                bindings
-                    .entry(field_ty.name.clone())
-                    .or_insert_with(|| self.infer(arg_expr, env));
-            }
-        }
-        // This single construction site couldn't pin down every generic parameter
-        // by itself — e.g. `Ok(5)` only ever supplies `Try`'s `T`, never its `E`
-        // (no `Ok` call site can, since `Err`'s payload is a disjoint field). Fall
-        // back to the enclosing function's declared return type, if it names this
-        // same enum with an explicit, fully-general `[...]` instantiation (e.g.
-        // `-> Try[Int, Str]`) — that's the one other place a type this
-        // construction site can't see on its own is written down on purpose.
-        if bindings.len() != params.len() {
-            if let Some(rt) = self.current_return_type.clone() {
-                if rt.name == e.name && rt.generics.len() == params.len() {
-                    for (p, gt) in params.iter().zip(rt.generics.iter()) {
-                        // A closure's expected return can still name the
-                        // method's own not-yet-inferred letter (`U` in
-                        // `Try[U, [Bad]]`) — that's what this site is about
-                        // to determine, not a binding to copy.
-                        // Fall back to the enclosing function's return (the
-                        // pre-closure-expected behavior), so `return
-                        // x.andThen(|n| Err(Bad))` in a `-> Try[Int, [Bad]]`
-                        // function still pins `T`.
-                        if self.return_type_is_closure_expected
-                            && gt.generics.is_empty()
-                            && isGenericParamName(&gt.name)
-                        {
-                            if bindings.contains_key(p) {
-                                continue;
-                            }
-                            if let Some(outer) = self.closure_outer_return_type.clone() {
-                                if outer.name == e.name && outer.generics.len() == params.len() {
-                                    let og = &outer.generics[params.iter().position(|q| q == p).unwrap()];
-                                    let resolved = self.resolveFieldType(og);
-                                    bindings.insert(p.clone(), crate::plumTypeFromAst(&resolved));
-                                }
-                            }
-                            continue;
-                        }
-                        if !bindings.contains_key(p) {
-                            // See the matching comment in
-                            // `resolveClassInstantiation` — `gt` needs
-                            // `resolveFieldType`'s recursive resolution
-                            // before `plumTypeFromAst`, or a generic-with-args
-                            // type argument (e.g. `Try[Link[Int], Str]`)
-                            // would have its own nested generics silently
-                            // dropped.
-                            let resolved = self.resolveFieldType(gt);
-                            bindings.insert(p.clone(), crate::plumTypeFromAst(&resolved));
-                        }
-                    }
-                }
-            }
-        }
-        // Still couldn't pin down every generic parameter (e.g. a payload-free
-        // `None`, or no informative return-type annotation either). Leave it for
-        // another site to drive.
-        if bindings.len() != params.len() {
-            return Ok(());
-        }
-        let mangled = self.ensureEnumSpecialized(e, &params, bindings);
-        call.name = self.enum_variant_mangling[&mangled][&variant.name].clone();
-        Ok(())
-    }
-    /// `Type(1, 2, 3)` — a bare-positional-args call on a GENERIC record-shaped
-    /// enum name that declares an `init` method (e.g. `List`'s own
-    /// `init(values: ...T)`) — is sugar for `Type.init(1, 2, 3)` (see
-    /// `plum-checker`'s `inferExpr` / `plum-wasm-codegen`'s matching `FnCall`
-    /// handling, which run AFTER monomorphization and only ever see concrete,
-    /// mangled names). Infers `init`'s own generic bindings from `call.args`'
-    /// types (mirroring `resolveEnumInstantiation`'s args-based inference for
-    /// a variant's fields), specializes the enum for them, and rewrites
-    /// `call.name` to the mangled name — same rewrite target
-    /// `resolveClassInstantiation` uses for the named `Type(field: value, ...)`
-    /// call shape, just reached from a differently-shaped call site.
-    fn resolveClassInitInstantiation(
-        &mut self,
-        call: &mut ast::FnCall,
-        env: &TypeEnv,
-    ) -> Result<(), String> {
-        let Some(e) = self.enums_generic_by_name.get(call.name.as_str()).copied() else {
-            return Ok(());
-        };
-        let Some(init_fn) = self
-            .methods_generic_on_enum
-            .get(call.name.as_str())
-            .and_then(|methods| methods.iter().find(|f| f.name == "init").copied())
-        else {
-            return Ok(());
-        };
-        let params = enumGenericParams(e);
-        let mut bindings: BTreeMap<String, PlumType> = BTreeMap::new();
-        for (i, arg) in call.args.iter().enumerate() {
-            let Some(param) = init_fn.params.get(i).or_else(|| init_fn.params.last()) else {
-                break;
-            };
-            let param_ty = match &param.ty {
-                ast::ParamType::Type(t) => Some(t),
-                ast::ParamType::Variadic(t) => Some(t),
-                ast::ParamType::Fn(_, _) => None,
-            };
-            let Some(param_ty) = param_ty else { continue };
-            if params.contains(&param_ty.name) && !bindings.contains_key(&param_ty.name) {
-                let arg_expr = match arg {
-                    ast::Arg::Positional(e) => e,
-                    ast::Arg::Keyword { value, .. } => value,
-                    ast::Arg::Pair { value, .. } => value,
-                };
-                bindings.insert(param_ty.name.clone(), self.infer(arg_expr, env));
-            }
-        }
-        // Same fallback as `resolveEnumInstantiation`/`resolveClassInstantiation` —
-        // an `init` whose args alone can't pin down every generic param (e.g. one
-        // with a fixed, non-generic-typed param alongside the generic one) falls
-        // back to the enclosing function's own declared return type.
-        if bindings.len() != params.len() {
-            if let Some(rt) = self.current_return_type.clone() {
-                if rt.name == call.name && rt.generics.len() == params.len() {
-                    for (p, gt) in params.iter().zip(rt.generics.iter()) {
-                        if !bindings.contains_key(p) {
-                            let resolved = self.resolveFieldType(gt);
-                            bindings.insert(p.clone(), crate::plumTypeFromAst(&resolved));
-                        }
-                    }
-                }
-            }
-        }
-        if bindings.len() != params.len() {
-            return Ok(());
-        }
-        let mangled = self.ensureEnumSpecialized(e, &params, bindings);
-        call.name = mangled;
-        Ok(())
-    }
-    /// Registers (if not already registered) the specialization of generic enum
-    /// `e` at `bindings` — mangling every variant name, teaching `self.enum_variants`
-    /// about each mangled variant (so `self.infer` on an already-rewritten
-    /// construction site resolves correctly instead of falling back to an
-    /// uninformative `TVar`), and enqueueing the specialization to actually be
-    /// produced. Returns the mangled enum name. Shared by `resolveEnumInstantiation`
-    /// (bindings inferred from a construction site's own args, falling back to the
-    /// enclosing return type) and `resolveCallReturnType` (bindings taken directly
-    /// from a callee's *own* declared return type, with no construction site at all
-    /// — see its doc comment).
-    fn ensureEnumSpecialized(
-        &mut self,
-        e: &'a ast::Enum,
-        params: &[String],
-        bindings: BTreeMap<String, PlumType>,
-    ) -> String {
-        let type_args: Vec<PlumType> = params.iter().map(|p| bindings[p].clone()).collect();
-        let mangled = mangle(&e.name, &type_args);
-        self.class_specialization_info
-            .entry(mangled.clone())
-            .or_insert_with(|| (e.name.clone(), bindings.clone()));
-        if !self.enum_variant_mangling.contains_key(&mangled) {
-            // Insert a placeholder table BEFORE recursively resolving any variant's
-            // own field types below — a self-referential generic enum (e.g. a
-            // linked-list `Node[T]`'s own `next: Link[Node[T]]` field) would
-            // otherwise recurse right back into specializing itself here before
-            // this specialization is even marked as in-progress, infinitely. The
-            // recursive re-entry only ever needs this specialization's MANGLED
-            // NAME back (see `resolveFieldType`'s `ast::Type { name: mangled, ...
-            // }` return), not its fully-resolved variant table — that gets
-            // overwritten with the real one below once the recursion unwinds.
-            self.enum_variant_mangling
-                .insert(mangled.clone(), BTreeMap::new());
-            let mut table = BTreeMap::new();
-            for (tag, v) in e.variants.iter().enumerate() {
-                let mangled_variant = mangle(&v.name, &type_args);
-                table.insert(v.name.clone(), mangled_variant.clone());
-                let field_subst = Substitution(bindings.clone());
-                let field_types: Vec<PlumType> = v
-                    .fields
-                    .iter()
-                    .map(|f| {
-                        let substituted = substituteType(f, &field_subst);
-                        let resolved = self.resolveFieldType(&substituted);
-                        crate::plumTypeFromAst(&resolved)
-                    })
-                    .collect();
-                self.enum_variants.insert(
-                    mangled_variant,
-                    EnumVariantInfo {
-                        enum_name: mangled.clone(),
-                        tag: tag as i32,
-                        field_types,
-                        field_names: v.field_names.clone(),
-                        values: v.values.clone(),
-                        generics: Vec::new(),
-                    },
-                );
-            }
-            self.enum_variant_mangling.insert(mangled.clone(), table);
-            // Eagerly registers this specialization's ORDINARY methods'
-            // signatures right now (see `registerEnumMethodSignatures`'s doc
-            // comment) — a method called on this value in the SAME statement
-            // that constructs it (`Next(4).filter(...)`) needs
-            // `self.methods` to already know about it, well before the
-            // worklist entry below is ever popped. MUST run only inside this
-            // `if` (guarded by the `enum_variant_mangling` insert just
-            // above, which marks this exact specialization as already being
-            // set up) — a method whose own return type re-mentions this SAME
-            // specialization (`Link[T]`'s `filter` returning `Link[T]`)
-            // recurses right back into `ensureEnumSpecialized("Link$Int",
-            // ...)`; running this unconditionally on every call (rather than
-            // only the first) recurses infinitely and stack-overflows.
-            self.registerEnumMethodSignatures(e, &mangled, &bindings);
-        }
-        if !self.specialized.contains(&mangled) && !self.enqueued.contains(&mangled) {
-            self.enqueued.insert(mangled.clone());
-            self.worklist.push(PendingSpecialization::Enum {
-                base: e,
-                subst: Substitution(bindings),
-                mangled: mangled.clone(),
-            });
-        }
-        mangled
-    }
-    /// Fully resolves a FIELD's declared type into something that will actually
-    /// exist after monomorphization. `specializeEnum`'s own field substitution
-    /// only replaces a bare generic-param NAME (`T` -> `Int`) — a field declared
-    /// `Link[Node[T]]` becomes `Link[Node[Int]]` this way, which is now
-    /// fully CONCRETE but still names the generic TEMPLATES `Link`/`Node`
-    /// directly, both of which monomorphization deletes from the output (only
-    /// their mangled specializations, e.g. `Node$Int`, survive). Recursively
-    /// resolves any nested generic arguments first (so `Node[Int]` inside
-    /// `Link[Node[Int]]` becomes `Node$Int` before `Link[...]` itself is
-    /// resolved), then — if the type names a known generic enum applied to
-    /// arguments — mangles it to that specialization's real name and enqueues
-    /// the specialization if it hasn't been already, via the same
-    /// `ensureEnumSpecialized` used for enum construction sites. A field
-    /// that's already concrete (no generics), or whose name isn't a known
-    /// generic template, is returned unchanged (or with just its nested
-    /// generics resolved) — this is ALSO called on every ordinary
-    /// (non-generic) enum's fields, not just specialized ones, since a plain
-    /// record-shaped enum can perfectly well have a field like `items:
-    /// List[Int]`.
-    fn resolveFieldType(&mut self, ty: &ast::Type) -> ast::Type {
-        if ty.generics.is_empty() {
-            return ty.clone();
-        }
-        let resolved_args: Vec<ast::Type> = ty
-            .generics
-            .iter()
-            .map(|g| self.resolveFieldType(g))
-            .collect();
-        // A type argument that's STILL a bare single-uppercase-letter name after
-        // resolving means it's a truly free type variable at this point in the
-        // pipeline — e.g. `List[U]` inside `List[T]`'s own `map` method, where
-        // `U` is `map`'s OWN generic param, not `List`'s `T` (already substituted
-        // to a concrete type by the time this runs). Mangling/specializing
-        // against a placeholder name would silently manufacture a bogus
-        // `List$U` "specialization" baked from the letter U itself, so leave the
-        // whole type unresolved instead — see the `map`/method-level-generics
-        // gap noted in `libs/std/list.plum`.
-        if resolved_args.iter().any(|a| isGenericParamName(&a.name)) {
-            return ast::Type {
-                name: ty.name.clone(),
-                generics: resolved_args,
-            };
-        }
-        let type_args: Vec<PlumType> = resolved_args.iter().map(crate::plumTypeFromAst).collect();
-        if let Some(e) = self.enums_generic_by_name.get(ty.name.as_str()).copied() {
-            let params = enumGenericParams(e);
-            if params.len() == type_args.len() {
-                let bindings: BTreeMap<String, PlumType> = params
-                    .iter()
-                    .cloned()
-                    .zip(type_args.iter().cloned())
-                    .collect();
-                let mangled = self.ensureEnumSpecialized(e, &params, bindings);
-                return ast::Type {
-                    name: mangled,
-                    generics: vec![],
-                };
-            }
-        }
-        ast::Type {
-            name: ty.name.clone(),
-            generics: resolved_args,
-        }
-    }
-    /// Resolves every generic-with-args type in `f`'s own signature (params,
-    /// return) via `resolveFieldType`, mutating `f` in place. Must run before
-    /// `f` is pushed to `m.produced` — the real checker rebuilds its tables
-    /// FRESH from that final AST (via `buildGlobalTables`, using the plain
-    /// generics-dropping `plumTypeFromAst`), so whatever a signature still
-    /// says at that point is what the checker sees; a bare unresolved `Node`
-    /// or `List[Int]` left in a param would either dangle or get its generics
-    /// silently dropped again.
-    fn resolveFnSignature(&mut self, f: &mut ast::Fn) {
-        self.resolveFnParamTypes(f);
-        self.resolveFnReturnType(f);
-    }
-    /// Just the params half of `resolveFnSignature` — deliberately split out
-    /// so callers can run this BEFORE `rewriteFnBody` (env seeding needs
-    /// param types already flattened, e.g. `Node[T]` -> `Node$Int`, or a
-    /// field access on a param would fail to resolve) while leaving
-    /// `f.returns` untouched until AFTER the body's been rewritten. The body
-    /// rewrite reads `self.current_return_type` (seeded from `f.returns` as
-    /// originally declared, generics and all) to drive
-    /// `resolveEnumInstantiation`'s fallback for construction sites that
-    /// can't infer every generic param from their own arguments alone (e.g.
-    /// `Err("...")` needs `Try`'s OTHER param, `T`, from the function's
-    /// own `-> Try[Int, Str]` declaration) — flattening the return type
-    /// up front would replace `rt.name` with an already-mangled name that
-    /// fallback's own bare-template-name comparison can never match again.
-    fn resolveFnParamTypes(&mut self, f: &mut ast::Fn) {
-        for p in &mut f.params {
-            match &mut p.ty {
-                ast::ParamType::Type(t) => *t = self.resolveFieldType(t),
-                ast::ParamType::Variadic(t) => *t = self.resolveFieldType(t),
-                // A closure-typed param's own param/return types can equally
-                // name a concrete generic instantiation after substitution
-                // (e.g. `andThen`'s `cb: fn(T) -> Link[U]` becomes `fn(Int)
-                // -> Link[Int]` once `T`/`U` are bound) — leaving them
-                // unresolved meant this param's type, once turned into a
-                // `PlumType` via `plumTypeFromAst` for the body's own type
-                // env, silently flattened to a bare, unmangled `Link`
-                // (`plumTypeFromAst` drops every type's `.generics`
-                // regardless of nesting depth), so a call through the
-                // closure param (`cb(v)`) inferred the wrong, un-mangled
-                // return type.
-                ast::ParamType::Fn(params, ret) => {
-                    for t in params.iter_mut() {
-                        *t = self.resolveFieldType(t);
-                    }
-                    if let Some(r) = ret {
-                        **r = self.resolveFieldType(r);
-                    }
-                }
-            }
-        }
-    }
-    /// The returns half of `resolveFnSignature` — see `resolveFnParamTypes`'s
-    /// doc comment for why this must run AFTER `rewriteFnBody`, not before.
-    fn resolveFnReturnType(&mut self, f: &mut ast::Fn) {
-        if let Some(r) = &mut f.returns {
-            *r = self.resolveFieldType(r);
-        }
-    }
-    /// A construction site (`Ok(5)`) only ever tells us about the TYPE that's being
-    /// PRODUCED — it says nothing about code further downstream that CONSUMES an
-    /// already-specialized generic-enum value returned from calling some other
-    /// (already fully concrete, non-generic) function or method, e.g.
-    /// `match parseIt() { Ok(v) => ... }` where `fun parseIt() -> Try[Int, Str]`.
-    /// `self.infer` can't help there either: it's built from `buildGlobalTables`,
-    /// which (like every other `PlumType` site) drops a declared type's generic
-    /// args entirely (`plumTypeFromAst` maps `Try[Int, Str]` to the bare
-    /// `TNamed("Try")`) — so it has no way to know this call's result is the
-    /// SPECIALIZED `Try$Int$Str`, not the generic template.
-    ///
-    /// This resolves that one specific, common shape directly from the callee's own
-    /// declaration (recorded in `fn_return_generic_enum` during classification) —
-    /// bypassing `self.infer` entirely, since the answer is already fully known
-    /// from the signature and doesn't depend on this call site's arguments at all.
-    /// Returns `None` for anything else (an ordinary call, a call to a function
-    /// whose return isn't a generic-enum instantiation, ...), meaning "fall back to
-    /// `self.infer` as before."
-    fn resolveCallReturnType(&mut self, e: &ast::Expr, env: &TypeEnv) -> Option<PlumType> {
-        let (recv, name) = match e {
-            ast::Expr::FnCall(call) => (None, call.name.clone()),
-            ast::Expr::Attribute(attr) => match &attr.attr {
-                ast::AttrKind::Method(call) => {
-                    let recv = match crate::methodReceiverName(&self.infer(&attr.object, env)) {
-                        Some(r) => r,
-                        None => return None,
-                    };
-                    (Some(recv), call.name.clone())
-                }
-                ast::AttrKind::Field(_) => return None,
-            },
-            _ => return None,
-        };
-        let (enum_ref, type_args) = self.fn_return_generic_enum.get(&(recv, name))?.clone();
-        let params = enumGenericParams(enum_ref);
-        let bindings: BTreeMap<String, PlumType> = params.iter().cloned().zip(type_args).collect();
-        Some(PlumType::TNamed(
-            self.ensureEnumSpecialized(enum_ref, &params, bindings),
-        ))
-    }
-    fn rewriteExpr(&mut self, expr: &mut ast::Expr, env: &TypeEnv) -> Result<(), String> {
-        match expr {
-            ast::Expr::ClassCall(call) => {
-                // A bare `Int`/`Float` field value being constructed into a
-                // "union" enum field (`Wrapper(value: 5)` where `value:
-                // Number`) or a named-payload enum variant field (`Circle
-                // (radius: 5)`, though there `radius: Int` already matches so
-                // this is a no-op) — a named variant's OWN field types don't
-                // depend on generic specialization, so this can run
-                // unconditionally here regardless of whether `call.type_name`
-                // turns out to be generic or not below.
-                for fa in &mut call.fields {
-                    let expected_ty =
-                        self.enum_variants
-                            .get(call.type_name.as_str())
-                            .and_then(|info| {
-                                info.field_names
-                                    .iter()
-                                    .position(|n| n == &fa.name)
-                                    .map(|i| info.field_types[i].clone())
-                            });
-                    if let Some(expected) = expected_ty {
-                        self.wrapPrimitiveAgainstExpected(&mut fa.value, &expected, env);
-                        self.resolveGenericVariantAgainstExpected(&mut fa.value, &expected);
-                    }
-                }
-                // Runs next (before the generic per-field rewrite below): a
-                // bare payload-free variant field value (`Node(..., next:
-                // End)`) carries no type of its own to infer a generic
-                // param from, and needs the enum's OWN (about-to-be-
-                // specialized) field type to resolve which specialization it
-                // actually means — `resolveClassInstantiation` handles that
-                // internally once it knows the full binding set.
-                self.resolveClassInstantiation(call, env)?;
-                for fa in &mut call.fields {
-                    self.rewriteExpr(&mut fa.value, env)?;
-                }
-                // Bare-type variant sugar (`enum Book = | FantasyBook | ...`,
-                // see `buildGlobalTables`): a class used as its own enum
-                // variant is recorded there with a single self-wrap field type
-                // `TNamed(<same name>)`. Calling it with the class's own
-                // named-field constructor (`FantasyBook(title: ..., ...)`)
-                // should build `Book`, not a bare `FantasyBook` — desugar to
-                // exactly what writing `FantasyBook(FantasyBook(...))` by hand
-                // would produce, reusing the existing variant-construction
-                // (`FnCall`) codegen path unchanged.
-                let is_bare_variant_wrap = self
-                    .enum_variants
-                    .get(call.type_name.as_str())
-                    .map(|info| info.field_types == [PlumType::TNamed(call.type_name.clone())])
-                    .unwrap_or(false);
-                if is_bare_variant_wrap {
-                    let inner = call.clone();
-                    let name = inner.type_name.clone();
-                    *expr = ast::Expr::FnCall(ast::FnCall {
-                        name,
-                        args: vec![ast::Arg::Positional(ast::Expr::ClassCall(inner))],
-                    });
-                }
-            }
-            ast::Expr::FnCall(call) => {
-                // Coerce a bare `Int`/`Float` ARGUMENT into a "union" enum
-                // param (`fun useNumber(n: Number)`) — the one call site
-                // `wrapPrimitiveAgainstExpected` didn't already have (return
-                // position and field construction are handled elsewhere).
-                // Looked up from `env` by the call's CURRENT name, which may
-                // still be an unspecialized generic template at this point —
-                // harmless, since a param typed by one of the function's own
-                // generic params is a bare `TVar`/`TNamed(<param>)`, never a
-                // real enum, so `expected` only resolves to an actual
-                // `Number`-like enum for a param that's genuinely concretely
-                // typed that way (generic function or not). Positional zip
-                // against `param_types` mirrors the same simplification
-                // `resolveFnInstantiation` already makes elsewhere in this
-                // file — a keyword arg out of declared order would zip
-                // against the wrong param, but that's a pre-existing
-                // limitation, not one this feature introduces.
-                if let Some(PlumType::TFun(param_types, _)) =
-                    env.get(call.name.as_str()).map(|s| *s.body.clone())
-                {
-                    for (arg, expected) in call.args.iter_mut().zip(param_types.iter()) {
-                        let e = match arg {
-                            ast::Arg::Positional(e) => e,
-                            ast::Arg::Keyword { value, .. } => value,
-                            ast::Arg::Pair { value, .. } => value,
-                        };
-                        self.wrapPrimitiveAgainstExpected(e, expected, env);
-                        self.resolveGenericVariantAgainstExpected(e, expected);
-                    }
-                }
-                for arg in &mut call.args {
-                    let e = match arg {
-                        ast::Arg::Positional(e) => e,
-                        ast::Arg::Keyword { value, .. } => value,
-                        ast::Arg::Pair { value, .. } => value,
-                    };
-                    self.rewriteExpr(e, env)?;
-                }
-                // A `FnCall` may name a generic free function, a generic enum's
-                // variant, or (bare positional args on a class name, e.g. `List(1,
-                // 2, 3)` — sugar for `List.init(1, 2, 3)`, see `plum-checker`'s own
-                // `inferExpr`/`plum-wasm-codegen`'s matching `ClassCall`/`FnCall`
-                // handling) a generic class with an `init` method; the three name
-                // spaces don't overlap (variants/classes are capitalized, free
-                // functions aren't). Enum and class resolution both run first and
-                // rewrite `call.name` to its mangled form when they resolve —
-                // `fns_generic` is keyed by the ORIGINAL unmangled free-function
-                // names, so a rewritten variant/class name can never accidentally
-                // match it afterward.
-                self.resolveEnumInstantiation(call, env)?;
-                self.resolveClassInitInstantiation(call, env)?;
-                self.resolveFnInstantiation(call, env)?;
-                self.resolveBareGenericFnInstantiation(call, env)?;
-            }
-            ast::Expr::Attribute(attr) => {
-                self.rewriteExpr(&mut attr.object, env)?;
-                if let ast::AttrKind::Method(call) = &mut attr.attr {
-                    // Closure-literal args need their OWN, properly-seeded pass
-                    // (see `rewriteMethodClosureArgs`'s doc comment) BEFORE the
-                    // generic per-arg walk below, which only knows `env` as-is
-                    // and would otherwise seed a closure's params as
-                    // unconstrained `TVar`s — permanently baking in a WRONG
-                    // mangled name for any generic construction inside a
-                    // closure body. The generic walk below skips closures
-                    // entirely as a result; every other arg shape still goes
-                    // through it exactly as before.
-                    self.rewriteMethodClosureArgs(&attr.object, call, env)?;
-                    // Same "union" enum argument coercion as the free-function
-                    // `FnCall` arm above, keyed by (receiver type, method name)
-                    // in `self.methods` instead of a bare function name. Also
-                    // follows the SAME dispatch fallback `plum-wasm-codegen`'s
-                    // `AttrKind::Method` codegen uses (a method not found
-                    // under the receiver's own name might be defined on the
-                    // enum that bare-wraps it, e.g. `Number.min(self, other:
-                    // Number)` dispatched from an `Int` receiver) — without
-                    // this, an OTHER argument like `{3}.min(5)`'s `5` would
-                    // never get boxed into `Number`, even though codegen
-                    // correctly boxes `self` for the very same call, causing
-                    // a wasm validation failure (raw `i64` where the callee
-                    // expects a boxed `Number` struct ref).
-                    let receiver_ty = self.infer(&attr.object, env);
-                    let direct_receiver_name = crate::methodReceiverName(&receiver_ty);
-                    let dispatch_receiver_name = direct_receiver_name.clone().and_then(|name| {
-                        if self
-                            .methods
-                            .contains_key(&(name.clone(), call.name.clone()))
-                        {
-                            Some(name)
-                        } else {
-                            self.enum_variants
-                                .get(name.as_str())
-                                .map(|info| info.enum_name.clone())
-                        }
-                    });
-                    if let Some(receiver_name) = dispatch_receiver_name {
-                        if let Some(PlumType::TFun(param_types, _)) = self
-                            .methods
-                            .get(&(receiver_name, call.name.clone()))
-                            .cloned()
-                        {
-                            for (arg, expected) in call.args.iter_mut().zip(param_types.iter()) {
-                                let e = match arg {
-                                    ast::Arg::Positional(e) => e,
-                                    ast::Arg::Keyword { value, .. } => value,
-                                    ast::Arg::Pair { value, .. } => value,
-                                };
-                                if !matches!(e, ast::Expr::Closure(_)) {
-                                    self.wrapPrimitiveAgainstExpected(e, expected, env);
-                                    self.resolveGenericVariantAgainstExpected(e, expected);
-                                }
-                            }
-                        }
-                    }
-                    for arg in &mut call.args {
-                        let e = match arg {
-                            ast::Arg::Positional(e) => e,
-                            ast::Arg::Keyword { value, .. } => value,
-                            ast::Arg::Pair { value, .. } => value,
-                        };
-                        if matches!(e, ast::Expr::Closure(_)) {
-                            continue;
-                        }
-                        self.rewriteExpr(e, env)?;
-                    }
-                    // Method dispatch on a specialized receiver needs no rewrite here
-                    // in the ORDINARY case: once the receiver's construction site is
-                    // rewritten to its mangled class name, the receiver's inferred
-                    // static type IS that mangled name, and the specialized methods
-                    // were registered under exactly that (mangled receiver, method
-                    // name) key when their class was specialized (see the
-                    // `PendingSpecialization::Class` arm below). A method with generic
-                    // param(s) of its OWN (`List.map`'s `U`) is the exception — that
-                    // one DOES need a rewrite, since no such registration happened for
-                    // it above (see `resolveMethodOwnGenerics`'s own doc comment).
-                    self.resolveMethodOwnGenerics(&attr.object, call, env)?;
-                }
-            }
-            ast::Expr::Binary(b) => {
-                self.rewriteExpr(&mut b.left, env)?;
-                self.rewriteExpr(&mut b.right, env)?;
-            }
-            ast::Expr::Bool(b) => {
-                self.rewriteExpr(&mut b.left, env)?;
-                self.rewriteExpr(&mut b.right, env)?;
-            }
-            ast::Expr::Compare(c) => {
-                self.rewriteExpr(&mut c.left, env)?;
-                self.rewriteExpr(&mut c.right, env)?;
-                // `current != End`: `current`'s side may already be a SPECIFIC
-                // enum specialization (e.g. `Link$Node$Int`) while `End`
-                // itself is still bare (it carries no type of its own) —
-                // resolve each side against the OTHER's type; a no-op unless
-                // that side is actually a bare generic-enum variant.
-                let lt = self.infer(&c.left, env);
-                let rt = self.infer(&c.right, env);
-                self.resolveBareVariantAgainstExpected(&mut c.left, &rt);
-                self.resolveBareVariantAgainstExpected(&mut c.right, &lt);
-            }
-            ast::Expr::Not(inner) => self.rewriteExpr(inner, env)?,
-            ast::Expr::Try(inner) => self.rewriteExpr(inner, env)?,
-            ast::Expr::Unary(u) => self.rewriteExpr(&mut u.operand, env)?,
-            ast::Expr::Paren(inner) => self.rewriteExpr(inner, env)?,
-            ast::Expr::Ternary(t) => {
-                self.rewriteExpr(&mut t.condition, env)?;
-                self.rewriteExpr(&mut t.then, env)?;
-                self.rewriteExpr(&mut t.else_, env)?;
-            }
-            ast::Expr::Elvis(e) => {
-                self.rewriteExpr(&mut e.left, env)?;
-                self.rewriteExpr(&mut e.right, env)?;
-            }
-            // String interpolation can embed arbitrary expressions (including generic
-            // call sites), so recurse into its interpolated parts.
-            ast::Expr::String(s) => {
-                for part in &mut s.parts {
-                    if let ast::StringPart::Interp(e) = part {
-                        self.rewriteExpr(e, env)?;
-                    }
-                }
-            }
-            ast::Expr::Int(_)
-            | ast::Expr::Float(_)
-            | ast::Expr::Self_
-            | ast::Expr::Var(_)
-            | ast::Expr::TypeName(_) => {}
-            ast::Expr::Closure(cl) => {
-                // A closure literal's body can itself contain a generic
-                // construction site (`|v| Next(v)`) that needs rewriting to
-                // its mangled variant/class name, same as anywhere else —
-                // without this, codegen later traps with "variant 'Next'
-                // missing from the GC type registry" the first time such a
-                // closure is actually compiled. The closure's OWN params
-                // aren't bound to any concrete type YET at this point in the
-                // pass (that only happens per-CALL-SITE, in
-                // `resolveMethodOwnGenerics`'s `ClosureReturn` handling) —
-                // seed them as unresolved `TVar`s in a scoped copy of `env`
-                // so a construction that depends on a captured OUTER
-                // variable (not a closure param) still resolves correctly;
-                // one that depends on a closure param itself is a known,
-                // narrower residual gap (see `fnBareGenericRefs`'s sibling
-                // `ParamType::Fn` TODOs).
-                let mut closure_env = env.clone();
-                for p in &cl.params {
-                    closure_env
-                        .entry(p.clone())
-                        .or_insert_with(|| TypeScheme::mono(PlumType::TVar("_".to_string())));
-                }
-                self.rewriteBlock(&mut cl.body, &mut closure_env)?;
-            }
-        }
-        Ok(())
-    }
-}
-/// Runs the whole generics-monomorphization pass over `source`, producing a plain,
-/// fully-concrete `ast::Source` with every generic `Class`/`Fn`/`Enum` template
-/// replaced by zero or more mangled concrete specializations, and every remaining
-/// item's body rewritten so its call sites reference those mangled names. The
-/// result has no generic syntax left in it — `checkSource`/`compileSource` run
-/// on it completely unmodified.
-pub fn monomorphizeSource(source: &ast::Source) -> Result<ast::Source, String> {
-    let (global_env, methods, enum_variants, enum_params) = crate::buildGlobalTables(source);
-    let min_required = crate::buildMinRequiredArgs(source);
-    let mut m = Monomorphizer {
-        fns_generic: BTreeMap::new(),
-        methods_generic_on_enum: BTreeMap::new(),
-        enums_generic_by_variant: BTreeMap::new(),
-        enums_generic_by_name: BTreeMap::new(),
-        enum_variant_mangling: BTreeMap::new(),
-        fns_bare_generic: BTreeMap::new(),
-        global_env,
-        methods,
-        enum_variants,
-        enum_params,
-        min_required,
-        class_specialization_info: BTreeMap::new(),
-        specialized: BTreeSet::new(),
-        enqueued: BTreeSet::new(),
-        worklist: Vec::new(),
-        produced: Vec::new(),
-        current_return_type: None,
-        return_type_is_closure_expected: false,
-        closure_outer_return_type: None,
-        fn_return_generic_enum: BTreeMap::new(),
-        local_types_by_name: BTreeMap::new(),
-        rename_counter: 0,
-    };
-    for item in &source.items {
-        if let ast::Item::Enum(e) = item {
-            if !enumGenericParams(e).is_empty() {
-                m.enums_generic_by_name.insert(e.name.clone(), e);
-                for v in &e.variants {
-                    m.enums_generic_by_variant.insert(v.name.clone(), e);
-                }
-            }
-        }
-    }
-    // Classifies every method by its receiver (generic enum, or neither),
-    // populating `methods_generic_on_enum` — MUST run before the
-    // `fn_return_generic_enum` loop below, which calls `resolveFieldType` and
-    // can therefore trigger `registerEnumMethodSignatures` for a generic enum
-    // as a SIDE EFFECT (e.g. resolving a nested `List[Str]` inside some other
-    // function's `-> Try[List[Str], Str]` return type).
-    // `registerEnumMethodSignatures` looks up `methods_generic_on_enum` and,
-    // finding it not yet populated, silently registers ZERO methods for that
-    // specialization (`Some(methods) = ... else { return }`) — and because the
-    // specialization is marked done at that point (`self.enum_variant_mangling`
-    // already has the mangled name), no later call ever retries it, permanently
-    // leaving e.g. `List$Str.reject` unresolvable for the rest of this pass
-    // (surfacing much later, and confusingly, as a chained method call
-    // inferring to `TVar` deep inside some unrelated enum-construction site).
-    for item in &source.items {
-        if let ast::Item::Fn(f) = item {
-            let receiver_is_generic_enum = f
-                .type_param
-                .as_deref()
-                .map(|r| m.enums_generic_by_name.contains_key(r))
-                .unwrap_or(false);
-            if receiver_is_generic_enum {
-                m.methods_generic_on_enum
-                    .entry(f.type_param.clone().unwrap())
-                    .or_default()
-                    .push(f);
-            } else if f.type_param.is_none() && !fnGenericParams(f).is_empty() {
-                m.fns_generic.insert(f.name.clone(), f);
-            } else if f.type_param.is_none() && !m.fnBareGenericRefs(f).is_empty() {
-                m.fns_bare_generic.insert(f.name.clone(), f);
-            }
-            // A method whose receiver is NOT generic is left as a regular method below,
-            // even if its own params/return happen to use a bare lowercase-letter type
-            // name, or bare-name a generic class/enum — those shapes are out of scope
-            // for this pass; see the plan's Global Constraints.
-        }
-    }
-    // Any function/method (generic or not — this doesn't care either way) whose
-    // OWN declared return type fully instantiates a known generic enum. Must run
-    // after the loop above (needs `enums_generic_by_name` AND `methods_generic_on`
-    // filled — see that loop's doc comment) but is otherwise independent of every
-    // other classification pass here.
-    for item in &source.items {
-        if let ast::Item::Fn(f) = item {
-            if let Some(rt) = &f.returns {
-                if let Some(e) = m.enums_generic_by_name.get(rt.name.as_str()).copied() {
-                    let params = enumGenericParams(e);
-                    if !rt.generics.is_empty() && rt.generics.len() == params.len() {
-                        // `gt` needs `resolveFieldType`'s recursive resolution
-                        // before `plumTypeFromAst`, same as every other site
-                        // that turns a declared `ast::Type` generic argument
-                        // into a `PlumType` — otherwise a nested generic type
-                        // argument (e.g. this method's own `Link[List[Json]]`
-                        // return type) has its `List[Json]` silently flattened
-                        // to bare `List`, and every match on this method's
-                        // return value ends up destructuring against the
-                        // unspecialized (method-less) `List` template instead
-                        // of `List$Json`.
-                        let type_args: Vec<PlumType> = rt
-                            .generics
-                            .iter()
-                            .map(|gt| {
-                                let resolved = m.resolveFieldType(gt);
-                                crate::plumTypeFromAst(&resolved)
-                            })
-                            .collect();
-                        m.fn_return_generic_enum
-                            .insert((f.type_param.clone(), f.name.clone()), (e, type_args));
-                    }
-                }
-            }
-        }
-    }
-    // Pre-resolve every ORDINARY (non-generic, non-generic-receiver) fn/method's
-    // OWN signature into `self.methods`/`self.global_env` before the main
-    // per-item loop below does any body rewriting. Without this, a call to
-    // e.g. `Str.split` (an ordinary method whose return type is the concrete
-    // generic instantiation `List[Str]`) made from another item processed
-    // EARLIER in `source.items`' order — imports are merged in AFTER the
-    // entry file's own items (see `loadAndMerge`), so a stdlib method
-    // commonly sits LATER in this list than the entry-file code that calls
-    // it — would have its return type inferred through the stale, un-mangled
-    // tables `buildGlobalTables` built at the very top of this function
-    // (which drops every declared type's generic args entirely). That
-    // silently bound a generic enum/class construction's type parameter to
-    // the wrong, bare template name instead of the real mangled one (e.g.
-    // `Ok(joined.split(...))`'s `T` resolving to bare `List` instead of
-    // `List$Str`, later rejected by the checker as `expected List, found
-    // List$Str` even though the program was correct). `resolveFnSignature`'s
-    // own side effects (enqueueing a class/enum specialization) are
-    // idempotent — the main loop below re-resolving the same signature again
-    // is harmless.
-    for item in &source.items {
-        if let ast::Item::Fn(f) = item {
-            let receiver_is_generic = f
-                .type_param
-                .as_deref()
-                .map(|r| m.enums_generic_by_name.contains_key(r))
-                .unwrap_or(false);
-            let is_generic_fn = f.type_param.is_none() && !fnGenericParams(f).is_empty();
-            let is_bare_generic_fn =
-                f.type_param.is_none() && m.fns_bare_generic.contains_key(f.name.as_str());
-            if receiver_is_generic || is_generic_fn || is_bare_generic_fn {
-                continue;
-            }
-            let mut sig = f.clone();
-            m.resolveFnSignature(&mut sig);
-            let param_types: Vec<PlumType> = sig
-                .params
-                .iter()
-                .map(|p| match &p.ty {
-                    ast::ParamType::Type(t) => crate::plumTypeFromAst(t),
-                    ast::ParamType::Variadic(t) => {
-                        PlumType::TVariadic(Box::new(crate::plumTypeFromAst(t)))
-                    }
-                    ast::ParamType::Fn(params, ret) => {
-                        let param_types = params.iter().map(crate::plumTypeFromAst).collect();
-                        let ret_ty = ret
-                            .as_ref()
-                            .map(|r| crate::plumTypeFromAst(r))
-                            .unwrap_or(PlumType::TUnit);
-                        PlumType::TFun(param_types, Box::new(ret_ty))
-                    }
-                })
-                .collect();
-            let ret = sig
-                .returns
-                .as_ref()
-                .map(crate::plumTypeFromAst)
-                .unwrap_or(PlumType::TUnit);
-            match &sig.type_param {
-                Some(recv) => {
-                    m.methods.insert(
-                        (recv.clone(), sig.name.clone()),
-                        PlumType::TFun(param_types, Box::new(ret)),
-                    );
-                }
-                None => {
-                    m.global_env.insert(
-                        sig.name.clone(),
-                        TypeScheme::mono(PlumType::TFun(param_types, Box::new(ret))),
-                    );
-                }
-            }
-        }
-    }
-    // Same reasoning for a non-generic enum's variant field types: a
-    // construction (`Holder(t: Ok(5))`) in an item EARLIER than the enum's own
-    // declaration must already see `Try$Int$[X]`, not the stale bare `Try`,
-    // to resolve its field values against (the main loop below refreshes
-    // them again, idempotently, when it reaches the enum).
-    for item in &source.items {
-        if let ast::Item::Enum(e) = item {
-            if !enumGenericParams(e).is_empty() {
-                continue;
-            }
-            for v in &e.variants {
-                if v.fields.is_empty() || !m.enum_variants.contains_key(v.name.as_str()) {
-                    continue;
-                }
-                let field_types: Vec<PlumType> = v
-                    .fields
-                    .iter()
-                    .map(|f| crate::plumTypeFromAst(&m.resolveFieldType(f)))
-                    .collect();
-                if let Some(info) = m.enum_variants.get_mut(v.name.as_str()) {
-                    info.field_types = field_types;
-                }
-            }
-        }
-    }
-    for item in &source.items {
-        match item {
-            ast::Item::Enum(e) if enumGenericParams(e).is_empty() => {
-                let mut e2 = e.clone();
-                for v in &mut e2.variants {
-                    for f in &mut v.fields {
-                        *f = m.resolveFieldType(f);
-                    }
-                }
-                // Refresh `self.enum_variants` with the resolved field types —
-                // `self.enum_variants` was seeded from the ORIGINAL,
-                // pre-monomorphization source (see `buildGlobalTables`, which —
-                // like `plumTypeFromAst` generally — doesn't resolve a field's
-                // own nested generics), so a variant field like `List[Json]` is
-                // still recorded there as bare `List`, not `List$Json`.
-                // Otherwise any LATER inference of a construction site for this
-                // variant (e.g. `self.infer` during another item's own
-                // monomorphization) unifies that stale name against the real,
-                // specialized value's type and fails, and that failure then
-                // gets silently swallowed by `infer`'s `unwrap_or(TVar("_"))`
-                // fallback further up the call chain.
-                for v in &e2.variants {
-                    let existing = m.enum_variants.get(v.name.as_str());
-                    let tag = existing.map(|info| info.tag).unwrap_or(0);
-                    // Bare-type variant sugar (see `buildGlobalTables`): `v.fields`
-                    // is empty in the AST for `| Cat` or `| Int`, but its resolved
-                    // field type was already recorded there (by the initial
-                    // `buildGlobalTables` seeding, before this loop runs) as a
-                    // single self-wrap `TNamed(v.name)` (a record-shaped enum) or
-                    // primitive bare-wrap (`Int`/`Float`) — reuse that same shape
-                    // here instead of clobbering it back to an empty vec.
-                    let existing_field_types = existing
-                        .map(|info| info.field_types.clone())
-                        .unwrap_or_default();
-                    let is_bare_wrap = v.fields.is_empty()
-                        && (existing_field_types == [PlumType::TNamed(v.name.clone())]
-                            || existing_field_types == [crate::plumTypeFromName(&v.name)]);
-                    let (field_types, field_names) = if is_bare_wrap {
-                        (existing_field_types, Vec::new())
-                    } else {
-                        (
-                            v.fields.iter().map(crate::plumTypeFromAst).collect(),
-                            v.field_names.clone(),
-                        )
-                    };
-                    m.enum_variants.insert(
-                        v.name.clone(),
-                        EnumVariantInfo {
-                            enum_name: e2.name.clone(),
-                            tag,
-                            field_types,
-                            field_names,
-                            values: v.values.clone(),
-                            generics: Vec::new(),
-                        },
-                    );
-                }
-                m.produced.push(ast::Item::Enum(e2));
-            }
-            ast::Item::Const(c) => m.produced.push(ast::Item::Const(c.clone())),
-            ast::Item::Trait(t) => m.produced.push(ast::Item::Trait(t.clone())),
-            ast::Item::Test(t) => {
-                let mut t2 = t.clone();
-                let mut env = m.global_env.clone();
-                m.current_return_type = None;
-                m.local_types_by_name.clear();
-                m.rewriteBlock(&mut t2.body, &mut env)?;
-                m.produced.push(ast::Item::Test(t2));
-            }
-            ast::Item::Fn(f) => {
-                let receiver_is_generic = f
-                    .type_param
-                    .as_deref()
-                    .map(|r| m.enums_generic_by_name.contains_key(r))
-                    .unwrap_or(false);
-                let is_generic_fn = f.type_param.is_none() && !fnGenericParams(f).is_empty();
-                let is_bare_generic_fn =
-                    f.type_param.is_none() && m.fns_bare_generic.contains_key(f.name.as_str());
-                if !receiver_is_generic && !is_generic_fn && !is_bare_generic_fn {
-                    let mut f2 = f.clone();
-                    m.resolveFnParamTypes(&mut f2);
-                    m.rewriteFnBody(&mut f2, false)?;
-                    m.resolveFnReturnType(&mut f2);
-                    m.produced.push(ast::Item::Fn(f2));
-                }
-            }
-            _ => {} // generic Enum declarations dropped here — templates only
-        }
-    }
-    let mut guard = 0usize;
-    while let Some(pending) = m.worklist.pop() {
-        guard += 1;
-        if guard > 10_000 {
-            return Err("monomorphize: exceeded specialization limit (possible unbounded generic recursion)".to_string());
-        }
-        match pending {
-            PendingSpecialization::Fn {
-                base,
-                subst,
-                mangled,
-                new_receiver,
-            } => {
-                if !m.specialized.insert(mangled.clone()) {
-                    continue;
-                }
-                let mut specialized_fn = specializeFn(base, &subst, &mangled, new_receiver);
-                m.resolveFnParamTypes(&mut specialized_fn);
-                m.rewriteFnBody(&mut specialized_fn, true)?;
-                m.resolveFnReturnType(&mut specialized_fn);
-                // Register the specialized free function's signature so later bodies
-                // can resolve calls to it during inference.
-                let param_types: Vec<PlumType> = specialized_fn
-                    .params
-                    .iter()
-                    .map(|p| match &p.ty {
-                        ast::ParamType::Type(t) => crate::plumTypeFromAst(t),
-                        ast::ParamType::Variadic(t) => {
-                            PlumType::TVariadic(Box::new(crate::plumTypeFromAst(t)))
-                        }
-                        ast::ParamType::Fn(params, ret) => {
-                            let param_types = params.iter().map(crate::plumTypeFromAst).collect();
-                            let ret_ty = ret
-                                .as_ref()
-                                .map(|r| crate::plumTypeFromAst(r))
-                                .unwrap_or(PlumType::TUnit);
-                            PlumType::TFun(param_types, Box::new(ret_ty))
-                        }
-                    })
-                    .collect();
-                let ret = specialized_fn
-                    .returns
-                    .as_ref()
-                    .map(crate::plumTypeFromAst)
-                    .unwrap_or(PlumType::TUnit);
-                m.global_env.insert(
-                    specialized_fn.name.clone(),
-                    TypeScheme::mono(PlumType::TFun(param_types, Box::new(ret))),
-                );
-                m.produced.push(ast::Item::Fn(specialized_fn));
-            }
-            PendingSpecialization::Enum {
-                base,
-                subst,
-                mangled,
-            } => {
-                if !m.specialized.insert(mangled.clone()) {
-                    continue;
-                }
-                let mut spec_enum = specializeEnum(base, &subst, &mangled);
-                // `specializeEnum` only substitutes a bare generic-param NAME —
-                // a field like `List[T]` becomes `List[Int]`, still a generic
-                // instantiation, not yet a real (mangled) type. Resolve those
-                // the rest of the way now.
-                for v in &mut spec_enum.variants {
-                    for f in &mut v.fields {
-                        *f = m.resolveFieldType(f);
-                    }
-                }
-                m.produced.push(ast::Item::Enum(spec_enum));
-                // Guarded against the self-nesting landmine documented on
-                // `isSelfNested` — without this, `List.chunk() -> List[List[T]]`
-                // would recurse into producing an unbounded chain of
-                // ever-more-nested `List` specializations via THIS SAME loop —
-                // and since this loop runs once per separate WORKLIST pop
-                // rather than recursively, a guard scoped to a single call
-                // stack isn't enough on its own.
-                {
-                    let already_nested = m.isSelfNested(&base.name, &subst.0);
-                    if let Some(methods) =
-                        m.methods_generic_on_enum.get(base.name.as_str()).cloned()
-                    {
-                        let owner_params = enumGenericParams(base);
-                        for method in methods {
-                            // A method with generic param(s) of its OWN (e.g.
-                            // `map`'s `U`, beyond `List[T]`'s own `T`) can't be
-                            // produced HERE — `U` is only known at a particular
-                            // CALL SITE, not at enum-specialization time.
-                            // `resolveMethodOwnGenerics` queues a
-                            // `PendingSpecialization::Fn` for each concrete `U`
-                            // it actually sees used, instead.
-                            if !methodOwnGenericParams(method, &owner_params).is_empty() {
-                                continue;
-                            }
-                            if already_nested
-                                && Monomorphizer::methodMentionsTemplate(method, &base.name)
-                            {
-                                continue;
-                            }
-                            let mut specialized_method =
-                                specializeFn(method, &subst, &method.name, Some(mangled.clone()));
-                            m.resolveFnParamTypes(&mut specialized_method);
-                            m.rewriteFnBody(&mut specialized_method, true)?;
-                            m.resolveFnReturnType(&mut specialized_method);
-                            let param_types: Vec<PlumType> = specialized_method
-                                .params
-                                .iter()
-                                .map(|p| match &p.ty {
-                                    ast::ParamType::Type(t) => crate::plumTypeFromAst(t),
-                                    ast::ParamType::Variadic(t) => {
-                                        PlumType::TVariadic(Box::new(crate::plumTypeFromAst(t)))
-                                    }
-                                    ast::ParamType::Fn(params, ret) => {
-                                        let param_types =
-                                            params.iter().map(crate::plumTypeFromAst).collect();
-                                        let ret_ty = ret
-                                            .as_ref()
-                                            .map(|r| crate::plumTypeFromAst(r))
-                                            .unwrap_or(PlumType::TUnit);
-                                        PlumType::TFun(param_types, Box::new(ret_ty))
-                                    }
-                                })
-                                .collect();
-                            let ret = specialized_method
-                                .returns
-                                .as_ref()
-                                .map(crate::plumTypeFromAst)
-                                .unwrap_or(PlumType::TUnit);
-                            m.methods.insert(
-                                (mangled.clone(), specialized_method.name.clone()),
-                                PlumType::TFun(param_types, Box::new(ret)),
-                            );
-                            m.produced.push(ast::Item::Fn(specialized_method));
-                        }
-                    }
-                }
-            }
-        }
-    }
-    Ok(ast::Source {
-        module: source.module.clone(),
-        imports: source.imports.clone(),
-        items: m.produced,
-        topLevelOrder: Vec::new(),
-    })
-}

plum-checker/tests/checker_tests.rs CHANGED Viewed

@@ -1,7 +1,7 @@
 #![allow(non_snake_case)]
 use plum_checker::types::*;
 use plum_checker::{
-    checkSource, erasedEnumName, plumTypeFromAst, plumTypeFromName, tagUnionSegmentsCompatible,
+    checkSource, plumTypeFromAst, plumTypeFromName,
     typedSource, unify, CheckCtx,
 };
 use plum_core::ast::Type as AstType;
@@ -496,10 +496,10 @@ fn genericClassInstantiatedAtTwoConcreteTypesTypeChecks() {
 enum Box[T] =
   | Box(value: T)
-fun makeIntBox() -> Box =
+fun makeIntBox() -> Box[Int] =
   Box(value: 5)
-fun makeStrBox() -> Box =
+fun makeStrBox() -> Box[Str] =
   Box(value: \"x\")
 ";
     let source = parse(src);
@@ -589,38 +589,6 @@ fun get() -> Int =
     let result = checkSource(&source);
     assert!(result.is_ok(), "expected Ok, got {:?}", result.err());
-    // Directly prove resolution happened: the monomorphized output must contain a
-    // concrete `Maybe$Int` enum whose `Just$Int` variant carries an `Int` field
-    // (not the generic `a`), and must NOT retain the generic `Maybe` template.
-    // The variant name is ALSO mangled (`Just` -> `Just$Int`), the same suffix as
-    // the enum's own name.
-    let mono = plum_checker::monomorphize::monomorphizeSource(&source)
-        .expect("monomorphize should succeed");
-    let opt = mono.items.iter().find_map(|it| match it {
-        Item::Enum(e) if e.name == "Maybe$Int" => Some(e),
-        _ => None,
-    });
-    let opt = opt.expect("expected a specialized `Maybe$Int` enum in the output");
-    let some = opt
-        .variants
-        .iter()
-        .find(|v| v.name == "Just$Int")
-        .expect("expected `Just$Int` (mangled) variant on `Maybe$Int`");
-    assert_eq!(
-        some.fields,
-        vec![Type {
-            name: "Int".to_string(),
-            generics: vec![]
-        }],
-        "Just's field should be concrete Int"
-    );
-    assert!(
-        !mono
-            .items
-            .iter()
-            .any(|it| matches!(it, Item::Enum(e) if e.name == "Maybe")),
-        "the generic `Maybe` template must be dropped from the output"
-    );
 }
 #[test]
@@ -653,24 +621,6 @@ fun useStr() -> Str =
     let result = checkSource(&source);
     assert!(result.is_ok(), "expected Ok, got {:?}", result.err());
-    // Directly prove both specializations exist independently, with distinct
-    // mangled variant names, so neither collides with the other.
-    let mono = plum_checker::monomorphize::monomorphizeSource(&source)
-        .expect("monomorphize should succeed");
-    let has_enum_with_variant = |enum_name: &str, variant_name: &str| {
-        mono.items.iter().any(|it| {
-            matches!(it, Item::Enum(e) if e.name == enum_name
-            && e.variants.iter().any(|v| v.name == variant_name))
-        })
-    };
-    assert!(
-        has_enum_with_variant("Maybe$Int", "Just$Int"),
-        "expected Maybe$Int with Just$Int"
-    );
-    assert!(
-        has_enum_with_variant("Maybe$Str", "Just$Str"),
-        "expected Maybe$Str with Just$Str"
-    );
 }
 #[test]
@@ -691,34 +641,6 @@ fun use() -> Int =
     assert!(result.is_ok(), "expected Ok, got {:?}", result.err());
 }
-#[test]
-#[ignore = "slow (~100s) — exercises the 10,000-specialization runaway-recursion guard; run explicitly with --ignored when touching monomorphize.rs's guard logic"]
-fn unboundedRecursiveGenericInstantiationIsAClearError() {
-    // `recurse` re-wraps its argument in a `Box` on every recursive call, so each
-    // specialization's own body demands a specialization of `recurse` at a STRICTLY
-    // bigger type (`recurse$Int`, then `recurse$Box$Int`, then `recurse$Box$Box$Int`,
-    // ...), forever. This genuinely grows the worklist without bound (unlike a
-    // generic class field merely NAMING a recursive generic type in its own
-    // declaration, which is never itself a call site and so never reaches the
-    // worklist at all) and must fail with a clear, bounded error rather than hang.
-    let src = "\
-enum Box[T] =
-  | Box(value: T)
-fun recurse(v: T) -> Int =
-  b = Box(value: v)
-  recurse(b)
-fun use() -> Int =
-  recurse(5)
-";
-    let source = parse(src);
-    let result = checkSource(&source);
-    assert!(result.is_err());
-    let errs = result.unwrap_err();
-    assert!(errs[0].message.contains("monomorphize"), "got: {:?}", errs);
-}
 #[test]
 fn ordinaryFunctionWithBareGenericEnumParamTypeChecks() {
     // The shape that broke the pre-existing codegen test: an otherwise-ordinary
@@ -728,7 +650,7 @@ enum Maybe[T] =
   | Just(T)
   | Nothing
-fun unwrapOr(o: Maybe, default: Int) -> Int =
+fun unwrapOr(o: Maybe[Int], default: Int) -> Int =
   match o
     Just(v) =>
       v
@@ -742,24 +664,13 @@ fun use() -> Int =
     let result = checkSource(&source);
     assert!(result.is_ok(), "expected Ok, got {:?}", result.err());
-    // Directly prove `unwrapOr` itself got specialized (not left bare/unresolved).
-    let mono = plum_checker::monomorphize::monomorphizeSource(&source)
-        .expect("monomorphize should succeed");
-    let has_specialized_unwrap_or = mono.items.iter().any(|it| {
-        matches!(it, Item::Fn(f)
-        if f.name.starts_with("unwrapOr$") && f.type_param.is_none())
-    });
-    assert!(
-        has_specialized_unwrap_or,
-        "expected a specialized `unwrapOr$...` function in the output"
-    );
 }
 #[test]
 fn ordinaryFunctionWithBareGenericClassParamTypeChecks() {
     // The same shape, for a generic CLASS param instead of an enum — untested until
-    // now, but the identical root cause: `Box` is dropped from the monomorphized
+    // now, but the identical root cause: a generic class param must carry its type
-    // output, so a bare `Box`-typed param would otherwise reference nothing.
+    // arguments.
     let src = "\
 enum Box[T] =
   | Box(value: T)
@@ -767,7 +678,7 @@ enum Box[T] =
   fun getBoxValue() -> T =
     self.value
-fun sumBox(b: Box) -> Int =
+fun sumBox(b: Box[Int]) -> Int =
   b.getBoxValue()
 fun use() -> Int =
@@ -1376,28 +1287,19 @@ fn tagsSubsetUnify() {
 #[test]
 fn nested_union_in_payload() {
     let ctx = emptyCtx();
+    use PlumType::{TApp, TInt, TStr};
+    let try_ = |tags: &str| TApp("Try".into(), vec![TInt, plumTypeFromName(tags)]);
     // Brackets inside a payload must not split the outer segment list.
+    assert!(unify(&try_("[A,B]"), &try_("[A]"), &ctx).is_ok());
+    assert!(unify(&try_("[A]"), &try_("[A,B]"), &ctx).is_err());
+    assert!(unify(&try_("[A(Try)]"), &try_("[A(Try)]"), &ctx).is_ok());
-    assert!(tagUnionSegmentsCompatible(
+    // Non-tag args must match exactly.
-        "Try$Int$[A(Try$Int$[X,Y])]",
+    assert!(unify(
-        "Try$Int$[A(Try$Int$[X])]",
+        &try_("[A]"),
+        &TApp("Try".into(), vec![TStr, plumTypeFromName("[A]")]),
         &ctx
-    ));
-    assert!(!tagUnionSegmentsCompatible(
-        "Try$Int$[A(Try$Int$[X])]",
-        "Try$Int$[A(Try$Int$[Z])]",
-        &ctx
-    ));
-    assert!(tagUnionSegmentsCompatible("Try$Int$[A,B]", "Try$Int$[A]", &ctx));
-    assert!(!tagUnionSegmentsCompatible("Try$Int$[A]", "Try$Int$[A,B]", &ctx));
-    // Non-tag segments must match exactly; arity must match.
-    assert!(!tagUnionSegmentsCompatible("Try$Int$[A]", "Try$Str$[A]", &ctx));
-    assert!(!tagUnionSegmentsCompatible("Try$Int$[A]", "Try$Int", &ctx));
-    assert_eq!(
-        erasedEnumName("Try$Int$[A,B(Try$Int$[X])]"),
-        "Try$Int$Tags"
-    );
+    )
-    assert_eq!(erasedEnumName("Try$[A]$[B,C]"), "Try$Tags$Tags");
-    assert_eq!(erasedEnumName("List$[]Byte"), "List$[]Byte");
+    .is_err());
 }
 #[test]
@@ -1716,8 +1618,8 @@ fun main() =
   r := five().andThen(|n| Ok(n * 2))
 ";
     let source = parseClean(src);
-    let mono = plum_checker::monomorphize::monomorphizeSource(&source);
+    let result = checkSource(&source);
-    assert!(mono.is_ok(), "expected Ok, got {:?}", mono.err());
+    assert!(result.is_ok(), "expected Ok, got {:?}", result.err());
 }
 #[test]
@@ -2302,3 +2204,38 @@ fun go() -> Str =
     let r = checkSource(&parseClean(src));
     assert!(r.is_ok(), "got {:?}", r.err());
 }
+#[test]
+fn bare_generic_type_in_signature_is_rejected() {
+    let src = "\
+enum Parcel[T] =
+  | Delivered(T)
+  | Lost
+fun contentsOr(p: Parcel, default: Int) -> Int =
+  match p
+    Delivered(v) => v
+    Lost => default
+";
+    let errs = checkSource(&parse(src)).unwrap_err();
+    assert!(
+        errs.iter().any(|e| e
+            .message
+            .contains("generic type 'Parcel' needs type arguments, e.g. Parcel[T]")),
+        "got: {:?}",
+        errs
+    );
+}
+#[test]
+fn bare_generic_type_allowed_inside_its_own_methods() {
+    let src = "\
+enum Box[T] =
+  | Box(value: T)
+  fun same(self) -> Box =
+    self
+";
+    let result = checkSource(&parse(src));
+    assert!(result.is_ok(), "got {:?}", result.err());
+}

plum-checker/tests/monomorphize_tests.rs DELETED Viewed

@@ -1,191 +0,0 @@
-#![allow(non_snake_case)]
-use plum_checker::monomorphize::*;
-use plum_checker::types::PlumType;
-use plum_core::ast;
-#[test]
-fn isGenericParamNameAcceptsSingleUppercaseLettersOnly() {
-    assert!(isGenericParamName("T"));
-    assert!(isGenericParamName("W"));
-    assert!(!isGenericParamName("Int"));
-    assert!(!isGenericParamName("TU"));
-    assert!(!isGenericParamName("a"));
-    assert!(!isGenericParamName(""));
-}
-#[test]
-fn fnGenericParamsDetectsImplicitUppercaseLetterTypesInOrder() {
-    let f = ast::Fn {
-        is_extern: false,
-        line: 0,
-        column: 0,
-        name: "pair".to_string(),
-        type_param: None,
-        params: vec![
-            ast::Param {
-                name: "first".to_string(),
-                ty: ast::ParamType::Type(ast::Type {
-                    name: "T".to_string(),
-                    generics: vec![],
-                }),
-                default: None,
-            },
-            ast::Param {
-                name: "second".to_string(),
-                ty: ast::ParamType::Type(ast::Type {
-                    name: "U".to_string(),
-                    generics: vec![],
-                }),
-                default: None,
-            },
-        ],
-        returns: Some(ast::Type {
-            name: "Bool".to_string(),
-            generics: vec![],
-        }),
-        body: ast::FnBody::Block(ast::Block { stmts: vec![] }),
-    };
-    assert_eq!(fnGenericParams(&f), vec!["T".to_string(), "U".to_string()]);
-}
-#[test]
-fn enumGenericParamsDetectsImplicitUppercaseLetterVariantFields() {
-    let e = ast::Enum {
-        line: 0,
-        column: 0,
-        name: "Maybe".to_string(),
-        generics: vec![],
-        implements: vec![],
-        params: vec![],
-        variants: vec![
-            ast::EnumVariant {
-                name: "Just".to_string(),
-                fields: vec![ast::Type {
-                    name: "T".to_string(),
-                    generics: vec![],
-                }],
-                field_names: vec![],
-                values: vec![],
-            },
-            ast::EnumVariant {
-                name: "Nothing".to_string(),
-                fields: vec![],
-                field_names: vec![],
-                values: vec![],
-            },
-        ],
-    };
-    assert_eq!(enumGenericParams(&e), vec!["T".to_string()]);
-}
-#[test]
-fn mangleJoinsBaseNameAndTypeArgs() {
-    assert_eq!(mangle("Box", &[PlumType::TInt]), "Box$Int");
-    assert_eq!(
-        mangle("Pair", &[PlumType::TInt, PlumType::TStr]),
-        "Pair$Int$Str"
-    );
-    assert_eq!(mangle("Green", &[]), "Green");
-}
-#[test]
-fn specializeFnSubstitutesGenericParamAndReturnTypes() {
-    let f = ast::Fn {
-        is_extern: false,
-        line: 0,
-        column: 0,
-        name: "wrap".to_string(),
-        type_param: None,
-        params: vec![ast::Param {
-            name: "value".to_string(),
-            ty: ast::ParamType::Type(ast::Type {
-                name: "T".to_string(),
-                generics: vec![],
-            }),
-            default: None,
-        }],
-        returns: Some(ast::Type {
-            name: "T".to_string(),
-            generics: vec![],
-        }),
-        body: ast::FnBody::Expr(ast::Expr::Var("value".to_string())),
-    };
-    let mut bindings = std::collections::BTreeMap::new();
-    bindings.insert("T".to_string(), PlumType::TInt);
-    let specialized = specializeFn(&f, &Substitution(bindings), "wrap$Int", None);
-    assert_eq!(specialized.name, "wrap$Int");
-    match &specialized.params[0].ty {
-        ast::ParamType::Type(t) => assert_eq!(t.name, "Int"),
-        _ => panic!("expected ParamType::Type"),
-    }
-    assert_eq!(specialized.returns.unwrap().name, "Int");
-}
-#[test]
-fn specializeFnSetsNewReceiverForAMethod() {
-    let f = ast::Fn {
-        is_extern: false,
-        line: 0,
-        column: 0,
-        name: "getValue".to_string(),
-        type_param: Some("Box".to_string()),
-        params: vec![],
-        returns: Some(ast::Type {
-            name: "T".to_string(),
-            generics: vec![],
-        }),
-        body: ast::FnBody::Expr(ast::Expr::Self_),
-    };
-    let mut bindings = std::collections::BTreeMap::new();
-    bindings.insert("T".to_string(), PlumType::TStr);
-    let specialized = specializeFn(
-        &f,
-        &Substitution(bindings),
-        "getValue",
-        Some("Box$Str".to_string()),
-    );
-    assert_eq!(specialized.name, "getValue");
-    assert_eq!(specialized.type_param, Some("Box$Str".to_string()));
-    assert_eq!(specialized.returns.unwrap().name, "Str");
-}
-#[test]
-fn specializeEnumSubstitutesGenericVariantFieldNames() {
-    let e = ast::Enum {
-        line: 0,
-        column: 0,
-        name: "Maybe".to_string(),
-        generics: vec![],
-        implements: vec![],
-        params: vec![],
-        variants: vec![
-            ast::EnumVariant {
-                name: "Just".to_string(),
-                fields: vec![ast::Type {
-                    name: "T".to_string(),
-                    generics: vec![],
-                }],
-                field_names: vec![],
-                values: vec![],
-            },
-            ast::EnumVariant {
-                name: "Nothing".to_string(),
-                fields: vec![],
-                field_names: vec![],
-                values: vec![],
-            },
-        ],
-    };
-    let mut bindings = std::collections::BTreeMap::new();
-    bindings.insert("T".to_string(), PlumType::TInt);
-    let specialized = specializeEnum(&e, &Substitution(bindings), "Maybe$Int");
-    assert_eq!(specialized.name, "Maybe$Int");
-    assert_eq!(
-        specialized.variants[0].fields,
-        vec![ast::Type {
-            name: "Int".to_string(),
-            generics: vec![]
-        }]
-    );
-    assert!(specialized.variants[1].fields.is_empty());
-}

plum-cli/src/main.rs CHANGED Viewed

@@ -149,16 +149,17 @@ fn cmdFormat(file: Option<std::path::PathBuf>, check: bool, use_stdin: bool) ->
 fn compileToWasm(file: &std::path::Path, lib_path: &std::path::Path) -> Result<Vec<u8>> {
     let ast = plum_core::loadAndMerge(file, lib_path).map_err(|e| anyhow::anyhow!("{e}"))?;
-    // Type check
+    // Type check once; codegen reuses the result.
-    if let Err(errors) = plum_checker::checkSource(&ast) {
+    let typed = match plum_wasm_codegen::typeCheck(&ast) {
+        Ok(t) => t,
-        for e in &errors {
+        Err(messages) => {
-            eprintln!("type error: {}", e.message);
+            eprintln!("{messages}");
+            process::exit(1);
         }
-        process::exit(1);
-    }
+    };
-    // Codegen
+    plum_wasm_codegen::compileTyped(&ast, typed)
-    plum_wasm_codegen::compileSource(&ast).map_err(|e| anyhow::anyhow!("codegen error: {e}"))
+        .map_err(|e| anyhow::anyhow!("codegen error: {e}"))
 }
 fn compileToTestWasm(
@@ -167,21 +168,16 @@ fn compileToTestWasm(
 ) -> Result<(Vec<u8>, Vec<String>)> {
     let ast = plum_core::loadAndMerge(file, lib_path).map_err(|e| anyhow::anyhow!("{e}"))?;
-    if let Err(errors) = plum_checker::checkSource(&ast) {
-        // Returns an error (rather than exiting the process directly, as
+    // Returns an error (rather than exiting the process directly, as
-        // `compileToWasm`'s equivalent check still does for the single-file
+    // `compileToWasm`'s equivalent check does for the single-file
-        // `compile`/`run`/`build` commands) so a recursive `plum test <dir>`
+    // `compile`/`run`/`build` commands) so a recursive `plum test <dir>`
-        // sweep can catch it per-file, in `cmdTest`'s directory branch, and
+    // sweep can catch it per-file, in `cmdTest`'s directory branch, and
-        // continue to the rest of the directory instead of the whole run
+    // continue to the rest of the directory instead of the whole run
-        // dying on the first file with a type error.
+    // dying on the first file with a type error. Checked once, on the
-        let messages: Vec<String> = errors
+    // test-desugared source codegen then compiles.
-            .iter()
-            .map(|e| format!("type error: {}", e.message))
+    let prog = plum_wasm_codegen::desugarTests(&ast);
-            .collect();
-        anyhow::bail!(messages.join("\n"));
+    let typed = plum_wasm_codegen::typeCheck(&prog.source).map_err(|m| anyhow::anyhow!(m))?;
-    }
-    let compiled = plum_wasm_codegen::compileTestSource(&ast)
+    let compiled = plum_wasm_codegen::compileTestTyped(&prog, typed)
         .map_err(|e| anyhow::anyhow!("codegen error: {e}"))?;
     // Debug aid: `PLUM_DUMP_WASM=out.wasm plum test file.plum` keeps the module.
     if let Some(path) = std::env::var_os("PLUM_DUMP_WASM") {

plum-examples/functions.plum CHANGED Viewed

@@ -69,20 +69,20 @@ enum Parcel[T] =
   | Delivered(T)
   | Lost
-fun contentsOr(p: Parcel, default: Int) -> Int =
+fun contentsOr(p: Parcel[Int], default: Int) -> Int =
   match p
     Delivered(v) => v
     Lost => default
 # `Str.length()` is not a real, working method — the point of this test is
-# that `Parcel$Str` coexists with `Parcel$Int` and both run correctly, not
+# that `Parcel[Str]` coexists with `Parcel[Int]` and both run correctly, not
 # string processing, so the Str arm returns a fixed literal.
-fun intContentsOr(p: Parcel, default: Int) -> Int =
+fun intContentsOr(p: Parcel[Int], default: Int) -> Int =
   match p
     Delivered(v) => v
     Lost => default
-fun strContentsOr(p: Parcel, default: Int) -> Int =
+fun strContentsOr(p: Parcel[Str], default: Int) -> Int =
   match p
     Delivered(v) => 4
     Lost => default

plum-examples/match.plum CHANGED Viewed

@@ -63,7 +63,7 @@ enum GenericBox[T] =
   | GFull(T)
   | GEmpty
-fun unwrapGenericBox(b: GenericBox) -> Int =
+fun unwrapGenericBox(b: GenericBox[Reading[Int]]) -> Int =
   match b
     GFull(Sample(v)) => v
     GFull(NoSignal) => -1

plum-examples/types.plum CHANGED Viewed

@@ -40,10 +40,10 @@ enum Color =
 fun stringifyColor(v: Red) -> Str =
   "Red"
-fun makeIntBox() -> Box =
+fun makeIntBox() -> Box[Int] =
   Box(value: 5)
-fun makeStrBox() -> Box =
+fun makeStrBox() -> Box[Str] =
   Box(value: "x")
 # ---- record-shaped and sum-type enum regression tests ----

plum-std/Array.plum CHANGED Viewed

@@ -3,20 +3,16 @@ import std/Bool
 import std/Number
 # A fixed-length, O(1)-indexable array of `T`, backed directly by a wasm-gc
-# `array<anyref>` — every `Array[T]` specialization (`Array$Int`, `Array$Str`,
+# `array<anyref>` — `Array[T]` is erased, so every `T` shares the SAME
-# ...) shares the SAME underlying wasm array type (see
+# underlying wasm array type (see
 # `plum-wasm-codegen::GcTypeRegistry::array_type_idx`), exactly like `[]Byte`
-# reuses `Str`'s own array type. `init`/`get`/`set`/`length` are compiler
+# reuses `Str`'s own array type. `init`/`get`/`set`/`length`/`push`/`resize` are compiler
 # intrinsics (see `compileIntrinsicFnBody`) — there's no way to express raw
 # array allocation/indexing in Plum source itself.
 #
-# LIMITATION: `T` must be a reference type (a `type`/`enum` value, `Str`,
+# Elements are stored as `anyref`; `T` is erased, so a primitive `T` (`Int`,
-# `List`, etc.) — every element is stored as a boxed `anyref` and `get`
+# `Float`, ...) is boxed on `set`/`push` and unboxed on `get` at the call
-# narrows it back to `T` via `ref.cast`. A primitive `T` (`Int`/`Float`/`Bool`/
-# `Byte`) is NOT supported (no boxing/unboxing exists yet) and will not
-# codegen correctly. Nothing in `libs/std` instantiates `Array` with a
-# primitive `T` today — the only user is `Map[K, V]`'s bucket array,
+# site, like any other generic edge. `List[T]` is built on this.
-# `Array[List[Pair[K, V]]]`.
 #
 # `init()` is deliberately zero-arg (no `Array[T](n)` constructor exists) —
 # `class_call`'s grammar (`Type[Generics](...)`) only ever accepts `name:
@@ -58,3 +54,9 @@ enum Array[T] =
   # arr.push(v)`.
   fun push(self, v: T) -> Array[T] =
     todo
+  # Returns a NEW array of length `n` holding `self`'s first `min(length, n)`
+  # elements (the remaining slots null-shaped, like `init`/`push`). `List`
+  # grows by doubling through this.
+  fun resize(self, n: Int) -> Array[T] =
+    todo

plum-std/Json.plum CHANGED Viewed

@@ -289,7 +289,7 @@ enum JsonParser =
   fun parseArray(self) -> Try[Json, JsonParseError] =
     self.advance()
     self.skipSpace()
-    items := List[Json](head: End, tail: End, size: 0)
+    items := List[Json]()
     if self.peek() == 93
       self.advance()
       return Ok(JsonList(items))

plum-std/List.plum CHANGED Viewed

@@ -1,24 +1,20 @@
 module std
 import std/Try
+import std/Array
 import std/Buffer
 import std/Number
 import std/Bool
 import std/Str
-# A node stores the data in a list and contains pointers to the previous and next sibling nodes
+# A growable list: `data` is a backing `Array[T]` whose length is the list's
+# capacity, `size` the number of slots in use. Capacity doubles when `push`
+# runs out of room (via `Array.resize`), so `push` is O(1) amortized and
+# `get`/`set` are O(1). The core operations (`init`, `length`, `get`, `set`,
+# `push`, `pop`, `clear`) sit directly on the `Array` intrinsics; everything
-# Private link between nodes (not an error tag, so a domain enum rather than Try).
+# else (`map`, `retain`, `reduce`, `chunk`, ...) is ordinary Plum on top of them.
-enum Link[N] =
-  | Next(N)
-  | End
-enum Node[T] =
-  | Node(value: T, prev: Link[Node[T]], next: Link[Node[T]])
-# A list is a data structure describing a contiguous section of an array stored separately from the slice variable itself.
-# It contains the pointers to the start and end nodes (head, tail) and maintains the size as well
 enum List[T: ToStr](ToStr) =
-  | List(head: Link[Node[T]], tail: Link[Node[T]], size: Int)
+  | List(data: Array[T], size: Int)
   # `List[T](1, 2, 3)` (or, for an empty list, `List[T]()` — explicit
   # generics required either way, since nothing else in a call this shape
@@ -26,42 +22,24 @@ enum List[T: ToStr](ToStr) =
   # `plum-checker`/`plum-wasm-codegen`'s `ClassCall`/`FnCall` handling, which
   # desugars both call shapes to `List.init(...)`.
   fun init(values: ...T) -> List[T] =
-    l := List(head: End, tail: End, size: 0)
+    l := List(data: Array[T](), size: 0)
     for v := range values
-      l.add(v)
+      l.push(v)
     return l
   # gets the element at i'th index of the list
   fun get(self, i: Int) -> Try[T, [OutOfBounds]] =
-    current := self.head
+    if i < 0 || i >= self.size
-    index := 0
-    while current != End
-      match current
-        Next(Node(value, _, next)) =>
-          if index == i
-            return Ok(value)
-          current = next
-          index = index + 1
-        End =>
-          break
-    Err(OutOfBounds)
+      return Err(OutOfBounds)
+    Ok(self.data.get(i))
   # sets the element at i'th index of the list, returning the old value (or Err(OutOfBounds) if i is out of bounds)
   fun set(self, i: Int, v: T) -> Try[T, [OutOfBounds]] =
-    current := self.head
+    if i < 0 || i >= self.size
-    index := 0
-    while current != End
-      match current
-        Next(node) =>
-          if index == i
-            old := node.value
-            node.value = v
-            return Ok(old)
-          current = node.next
-          index = index + 1
-        End =>
-          break
-    Err(OutOfBounds)
+      return Err(OutOfBounds)
+    old := self.data.get(i)
+    self.data.set(i, v)
+    Ok(old)
   # returns the no of elements in the list
   fun length(self) -> Int =
@@ -74,143 +52,86 @@ enum List[T: ToStr](ToStr) =
     if self.length() != other.length()
       return False
     for i := range self.length()
-      if self.get(i).unwrap() != other.get(i).unwrap()
+      if self.data.get(i) != other.data.get(i)
         return False
     return True
+  # appends `v` to the end of the list, doubling the capacity when full
+  fun push(self, v: T) -> Unit =
+    if self.size == self.data.length()
+      cap := self.size == 0 ? 16 : self.size * 2
+      self.data = self.data.resize(cap)
+    self.data.set(self.size, v)
+    self.size = self.size + 1
   # adds the specified elements to the end of the list
   fun add(self, values: ...T) =
     for v := range values
-      node := Node(value: v, prev: self.tail, next: End)
-      match self.tail
-        Next(t) =>
-          t.next = Next(node)
-        End =>
-          self.head = Next(node)
+      self.push(v)
+  # removes and returns the last element, or `Err(ListWasEmpty)` if empty
-      self.tail = Next(node)
+  fun pop(self) -> Try[T, [ListWasEmpty]] =
-      self.size = self.size + 1
+    if self.size == 0
-  # unlinks node from the list, patching its neighbors (or head/tail) to close the gap
-  fun unlink(self, node: Node[T]) =
-    match node.prev
-      Next(p) =>
-        p.next = node.next
-      End =>
-        self.head = node.next
+      return Err(ListWasEmpty)
-    match node.next
-      Next(n) =>
-        n.prev = node.prev
-      End =>
-        self.tail = node.prev
     self.size = self.size - 1
+    Ok(self.data.get(self.size))
-  # removes the element at i'th index of the list
+  # removes the element at i'th index of the list (out of range is a no-op)
   fun removeAt(self, i: Int) =
-    current := self.head
+    if i < 0 || i >= self.size
-    index := 0
-    while current != End
-      match current
-        Next(node) =>
-          if index == i
-            self.unlink(node)
-            return
+      return
+    j := i
-          current = node.next
+    while j < self.size - 1
+      self.data.set(j, self.data.get(j + 1))
-          index = index + 1
+      j = j + 1
-        End =>
+    self.size = self.size - 1
-          break
   # removes the first element equal to v from list
   fun remove(self, v: T) =
-    current := self.head
+    for i := range self.size
-    while current != End
-      match current
-        Next(node) =>
-          if node.value == v
+      if self.data.get(i) == v
-            self.unlink(node)
+        self.removeAt(i)
-            return
+        return
-          current = node.next
-        End =>
-          break
   # removes all objects from this list
   fun clear(self) =
-    self.head = End
-    self.tail = End
     self.size = 0
-  # returns the list with the elements relinked in reverse order.
+  # reverses the list in place, returning it.
-  fun reverse(self) -> List =
+  fun reverse(self) -> List[T] =
+    i := 0
-    current := self.head
+    j := self.size - 1
-    while current != End
+    while i < j
-      match current
-        Next(node) =>
-          next := node.next
-          node.next = node.prev
-          node.prev = next
-          current = next
-        End =>
-          break
-    old_head := self.head
+      tmp := self.data.get(i)
+      self.data.set(i, self.data.get(j))
-    self.head = self.tail
+      self.data.set(j, tmp)
-    self.tail = old_head
+      i = i + 1
+      j = j - 1
     self
-  # Inserts `value` immediately before `node` (which must belong to `self`),
-  # patching neighbors (or `head`) to make room — the insertion-point half of
-  # `sort`'s pointer surgery, split out since `unlink`'s counterpart already
-  # gets its own method.
-  fun insertBefore(self, node: Node[T], value: T) -> Unit =
-    new_node := Node(value: value, prev: node.prev, next: Next(node))
-    match node.prev
-      Next(p) =>
-        p.next = Next(new_node)
-      End =>
-        self.head = Next(new_node)
-    node.prev = Next(new_node)
-    self.size = self.size + 1
-  # Inserts `value` into `self` (assumed already sorted by `before`) at the
-  # position that keeps it sorted — the first position whose existing element
-  # `before(value, existing)` holds for, or the end if none does.
-  fun insertSorted(self, value: T, before: fn(T, T) -> Bool) -> Unit =
-    current := self.head
-    while current != End
-      match current
-        Next(node) =>
-          if before(value, node.value)
-            self.insertBefore(node, value)
-            return
-          current = node.next
-        End =>
-          break
-    self.add(value)
   # Returns a NEW list with `self`'s elements sorted, using `before(a, b)` as
-  # the "does a belong before b" comparator. Insertion sort (O(n^2)) — simple
+  # the "does a belong before b" comparator. Insertion sort (O(n^2)).
-  # and adequate for the list sizes a linked list is already suited to.
   fun sort(self, before: fn(T, T) -> Bool) -> List[T] =
-    result := List(head: End, tail: End, size: 0)
+    result := self.sublist(0, self.size)
+    i := 1
-    current := self.head
+    while i < result.size
+      x := result.data.get(i)
+      j := i - 1
-    while current != End
+      while j >= 0
-      match current
-        Next(Node(value, _, next)) =>
+        if !before(x, result.data.get(j))
-          result.insertSorted(value, before)
-          current = next
-        End =>
           break
+        result.data.set(j + 1, result.data.get(j))
+        j = j - 1
+      result.data.set(j + 1, x)
+      i = i + 1
     return result
   # Returns the first element equal to `search`, or `Err(NotFound)`.
   fun find(self, search: T) -> Try[T, [NotFound]] =
+    for i := range self.size
-    current := self.head
+      value := self.data.get(i)
-    while current != End
-      match current
-        Next(Node(value, _, next)) =>
-          if value == search
+      if value == search
-            return Ok(value)
+        return Ok(value)
-          current = next
-        End =>
-          break
     return Err(NotFound)
   fun contains(self, v: T) -> Bool =
@@ -218,31 +139,15 @@ enum List[T: ToStr](ToStr) =
   # calls f for each elem in the list
   fun each(self, cb: fn(T)) -> Unit =
-    current := self.head
+    for i := range self.size
-    while current != End
+      cb(self.data.get(i))
-      match current
-        Next(Node(value, _, next)) =>
-          cb(value)
-          current = next
-        End =>
-          break
-  # Returns a new list with each element transformed by `cb`.
+  # Returns a new list with each element transformed by `cb`. `U` is a
-  #
-  # `U` here is a generic param of `map` ITSELF, separate from `List[T]`'s own
+  # generic param of `map` itself, separate from `List[T]`'s own `T`.
-  # `T` — resolved per CALL SITE (from `cb`'s own inferred return type), not
-  # when `List[T]` itself is specialized, via `resolveMethodOwnGenerics` in
-  # `plum-checker/src/monomorphize.rs`.
   fun map(self, cb: fn(T) -> U) -> List[U] =
-    result := List(head: End, tail: End, size: 0)
+    result := List[U]()
-    current := self.head
+    for i := range self.size
-    while current != End
-      match current
-        Next(Node(value, _, next)) =>
-          result.add(cb(value))
+      result.push(cb(self.data.get(i)))
-          current = next
-        End =>
-          break
     return result
   # returns a new list with each element flat-mapped
@@ -251,102 +156,65 @@ enum List[T: ToStr](ToStr) =
   # Returns a new list with only the elements `predicate` holds for.
   fun retain(self, predicate: fn(T) -> Bool) -> List[T] =
-    result := List(head: End, tail: End, size: 0)
+    result := List[T]()
+    for i := range self.size
-    current := self.head
+      value := self.data.get(i)
-    while current != End
-      match current
-        Next(Node(value, _, next)) =>
-          if predicate(value)
+      if predicate(value)
-            result.add(value)
+        result.push(value)
-          current = next
-        End =>
-          break
     return result
   # Returns a new list with the elements `predicate` holds for removed.
   fun reject(self, predicate: fn(T) -> Bool) -> List[T] =
-    result := List(head: End, tail: End, size: 0)
+    result := List[T]()
+    for i := range self.size
-    current := self.head
+      value := self.data.get(i)
-    while current != End
-      match current
-        Next(Node(value, _, next)) =>
-          if !predicate(value)
+      if !predicate(value)
-            result.add(value)
+        result.push(value)
-          current = next
-        End =>
-          break
     return result
   fun any(self, predicate: fn(T) -> Bool) -> Bool =
-    current := self.head
+    for i := range self.size
-    while current != End
-      match current
-        Next(Node(value, _, next)) =>
-          if predicate(value)
+      if predicate(self.data.get(i))
-            return True
+        return True
-          current = next
-        End =>
-          break
     return False
   fun every(self, predicate: fn(T) -> Bool) -> Bool =
-    current := self.head
+    for i := range self.size
-    while current != End
-      match current
-        Next(Node(value, _, next)) =>
-          if !predicate(value)
+      if !predicate(self.data.get(i))
-            return False
+        return False
-          current = next
-        End =>
-          break
     return True
   # Folds `self`'s elements into a single value, starting from `acc` and
-  # combining each element in with `cb(accumulatedSoFar, element)`.
+  # combining each element in with `cb(accumulatedSoFar, element)`. `U` is
-  #
-  # `U` is `reduce`'s OWN generic param (the accumulator's type), separate
+  # `reduce`'s own generic param (the accumulator's type).
-  # from `List[T]`'s own `T` — same per-CALL-SITE resolution as `map`'s `U`.
   fun reduce(self, acc: U, cb: fn(U, T) -> U) -> U =
     result := acc
-    current := self.head
+    for i := range self.size
-    while current != End
-      match current
-        Next(Node(value, _, next)) =>
-          result = cb(result, value)
+      result = cb(result, self.data.get(i))
-          current = next
-        End =>
-          break
     return result
   # returns the first element in the list
   fun first(self) -> Try[T, [ListWasEmpty]] =
-    match self.head
+    if self.size == 0
-      Next(Node(value, _, _)) => Ok(value)
-      End => Err(ListWasEmpty)
+      return Err(ListWasEmpty)
+    Ok(self.data.get(0))
   # returns the last element in the list
   fun last(self) -> Try[T, [ListWasEmpty]] =
-    match self.tail
+    if self.size == 0
-      Next(Node(value, _, _)) => Ok(value)
-      End => Err(ListWasEmpty)
+      return Err(ListWasEmpty)
+    Ok(self.data.get(self.size - 1))
   # Returns a new list of the elements at index `[start, end)`, clamped into
   # range (a `start`/`end` outside `[0, length]` is clamped, not an error).
   fun sublist(self, start: Int, end: Int) -> List[T] =
-    result := List(head: End, tail: End, size: 0)
+    result := List[T]()
     s := start < 0 ? 0 : start
     e := end > self.size ? self.size : end
-    current := self.head
-    i := 0
+    i := s
-    while current != End && i < e
-      match current
-        Next(Node(value, _, next)) =>
-          if i >= s
+    while i < e
-            result.add(value)
+      result.push(self.data.get(i))
-          current = next
-          i = i + 1
+      i = i + 1
-        End =>
-          break
     return result
   # The first `n` elements.
@@ -364,7 +232,7 @@ enum List[T: ToStr](ToStr) =
   fun sample(self) -> Try[T, [ListWasEmpty]] =
     if self.size == 0
       return Err(ListWasEmpty)
-    return Ok(self.get(randomInt(self.size)).unwrap())
+    return Ok(self.data.get(randomInt(self.size)))
   # Returns a new list with `self`'s elements in random order (Fisher-Yates).
   fun shuffle(self) -> List[T] =
@@ -372,105 +240,46 @@ enum List[T: ToStr](ToStr) =
     i := result.size - 1
     while i > 0
       j := randomInt(i + 1)
-      vi := result.get(i).unwrap()
+      vi := result.data.get(i)
-      vj := result.get(j).unwrap()
-      result.set(i, vj)
+      result.data.set(i, result.data.get(j))
-      result.set(j, vi)
+      result.data.set(j, vi)
       i = i - 1
     return result
-  # `chunk`/`partition` both return `List[List[T]]` — the SAME generic class
-  # (`List`) nested inside itself as a method's own return type. This used to
-  # be an unconditional stack-overflow landmine for the WHOLE COMPILER (see
-  # `plum-checker/src/monomorphize.rs`'s `isSelfNested`/`methodMentionsTemplate`
-  # doc comments for the full fix) — that danger is now FIXED (2026-09-02).
-  #
-  # A second, more contained bug surfaced once past that: two SEPARATE bare
-  # `List(head: End, tail: End, size: 0)` constructions in the SAME method
-  # body — one for the OUTER `result: List[List[T]]` (matching this
-  # method's own declared return type) and one for an INNER per-chunk
-  # `piece: List[T]` — are ambiguous to `resolveClassInstantiation`'s
-  # `current_return_type` fallback: since `List[T]` and `List[List[T]]` both
-  # have exactly ONE generic argument, the fallback (which only ever
-  # compares ARITY, not identity) can't tell "this bare construction IS the
-  # function's own return value" apart from "this is some OTHER, unrelated
-  # nested construction of the same template that happens to need the same
-  # arity" — so `piece` was silently resolved to the SAME type as `result`
-  # (`List$List$Int` instead of `List$Int`), corrupting its own `add` calls.
-  # Worked around by building `piece` via `self.sublist(...)` instead of a
-  # second bare construction — `sublist` is an ordinary method already
+  # Splits into consecutive sublists of at most `size` elements each.
-  # unambiguously resolved through the RECEIVER's own (already-correct)
-  # binding, no `current_return_type` guessing involved at all.
   fun chunk(self, size: Int) -> List[List[T]] =
-    result := List(head: End, tail: End, size: 0)
+    result := List[List[T]]()
     if size <= 0
       return result
     i := 0
     n := self.length()
     while i < n
-      result.add(self.sublist(i, i + size))
+      result.push(self.sublist(i, i + size))
       i = i + size
     return result
   # Splits into two lists: elements `predicate` holds for, then the rest —
   # in that order. Returns them as a 2-element `List[List[T]]` (`[matched,
-  # unmatched]`) since this language has no tuple type. Deliberately built
+  # unmatched]`) since this language has no tuple type.
-  # from `self.retain(predicate)`/`self.reject(predicate)` rather than two
-  # local `matched`/`unmatched := List(head: End, ...)` bare constructions
-  # — see `chunk`'s doc comment above for exactly why that would be
-  # ambiguous (`matched`/`unmatched` need `List[T]`, but a bare
-  # construction here would resolve via `current_return_type` fallback
-  # against THIS method's own `List[List[T]]` return instead, same arity
-  # coincidence). `retain`/`reject` are each already unambiguous (single
-  # bare construction per method body, matching their own single-level
-  # return type).
   fun partition(self, predicate: fn(T) -> Bool) -> List[List[T]] =
-    result := List(head: End, tail: End, size: 0)
+    result := List[List[T]]()
-    result.add(self.retain(predicate))
+    result.push(self.retain(predicate))
-    result.add(self.reject(predicate))
+    result.push(self.reject(predicate))
     return result
-  # Grouping by an arbitrary key type would need its own generic param
+  # Grouping by an arbitrary key type would need `Map[K, List[T]]`, but
-  # (`groupBy<K>(keyFn: fn(T) -> K) -> Map[K, List[T]]`) resolved from a
-  # closure's return type — the same method-level-generics gap documented on
-  # `List.map` above, PLUS `Map[K, List[T]]` would make `list.plum` depend on
-  # `map.plum`, which already depends on `list.plum`. Not implemented.
+  # `Map.plum` depends on this file. Not implemented.
   fun groupBy(self) =
     todo
-  # Note: NOT written with `each` + a closure-captured "is this the first
-  # element" flag — a closure's captured variables are snapshotted at
-  # CREATION time (see `libs/std/list.plum`'s own `add`/`each` usage
-  # elsewhere), so an assignment to a captured var INSIDE the closure body
-  # does not persist across that closure's own repeated invocations from one
-  # `each` call. A plain `while`/`match` traversal (same idiom as `unlink`)
-  # sidesteps that entirely.
   fun join(self, sep: Str = ",") -> Str =
     res := Buffer()
-    current := self.head
+    for i := range self.size
-    while current != End
-      match current
-        Next(Node(value, _, next)) =>
-          res.write(value.toStr())
-          if next != End
+      if i > 0
-            res.write(sep)
+        res.write(sep)
-          current = next
+      res.write(self.data.get(i).toStr())
-        End =>
-          break
     res.toStr()
-  # `List[T: ToStr](ToStr)` declared implementing `ToStr`
-  # from the start but never actually defined `toStr` — harmless for a
-  # PLAIN `List[Int]`/`List[Str]`/etc (nothing needs to call `.toStr()` on
-  # the LIST ITSELF, just on its elements, which `join` above already
-  # does), but a genuine gap the moment a `List` is used AS another
-  # `List`'s own ELEMENT type (`List[List[T]]`) — the OUTER list's eagerly-
-  # compiled `join`/`toStr` calls `.toStr()` on each element, and an inner
-  # `List[T]` element had no such method to call, failing to compile with
-  # "unknown method 'List$T.toStr'" even for a program that never actually
-  # calls `.toStr()`/`.join()` on the outer list (per the "eager compile
-  # every method for every specialization" architecture noted elsewhere in
-  # this codebase's history).
   fun toStr(self) -> Str =
     return "[" + self.join(",") + "]"
@@ -586,3 +395,41 @@ test "partition splits into elements matching a predicate, then the rest"
   assert parts.length() == 2
   assert parts.get(0).unwrap().join(",") == "2,4,6"
   assert parts.get(1).unwrap().join(",") == "1,3,5"
+test "list_get_set_push_pop: push 1000, get(999), pop until empty, get on empty is Err"
+  l := List[Int]()
+  for i := range 1000
+    l.push(i)
+  assert l.length() == 1000
+  assert l.get(999).unwrap() == 999
+  assert optSumForListTest(l.get(1000)) == -1000
+  assert l.set(500, 7).unwrap() == 500
+  assert l.get(500).unwrap() == 7
+  assert l.pop().unwrap() == 999
+  assert l.length() == 999
+  while l.length() > 0
+    l.pop()
+  assert l.length() == 0
+  assert l.pop().isErr()
+  assert optSumForListTest(l.get(0)) == -1000
+  e := l.get(0)
+  assert e.isErr()
+test "list_growth: length stays exact across the doubling boundaries"
+  l := List[Int]()
+  for i := range 1025
+    l.push(i)
+    n := i + 1
+    if n == 15 || n == 16 || n == 17 || n == 1023 || n == 1024 || n == 1025
+      assert l.length() == n
+      assert l.get(n - 1).unwrap() == i
+      assert l.get(0).unwrap() == 0
+  assert l.get(16).unwrap() == 16
+  assert l.get(1024).unwrap() == 1024
+test "list of strings keeps its elements through growth"
+  l := List[Str]()
+  for i := range 40
+    l.push("s{i}")
+  assert l.get(39).unwrap() == "s39"
+  assert l.get(16).unwrap() == "s16"

plum-std/Map.plum CHANGED Viewed

@@ -6,28 +6,18 @@ import std/Bool
 import std/Number
 import std/Str
-# Any type usable as a `Map` key needs a `hash`, so keys landing in different
+# Any type usable as a `Map` key needs a `hash`. `Map` is compiled once
-# buckets (`hash(k) % BUCKET_COUNT`) can be told apart in O(1) without a full
-# linear scan of the whole map — see `Str.hash`/`Int.hash` in `str.plum`/
+# (erased); `k.hash()` on a `K: Hashable` dispatches at runtime on the key's
-# `int.plum` for the two implementations `libs/std` provides today. Declared
-# here (rather than alongside `ToStr`/`Comparable` in `str.plum`) since `Map`
+# type id (`Str.hash`, `Int.hash` for a boxed Int). Declared here rather than
-# is its only real consumer; like `Comparable`/`Readable`/`Writable`
+# alongside `ToStr` since `Map` is its only real consumer; `Str`/`Int` don't
-# elsewhere in `libs/std`, `Str`/`Int` don't formally list it in their own
-# `implements` clause (that would need them to import `map.plum`, an
+# list it in their `implements` clause (that would make them import this file).
-# unwanted dependency direction for such foundational types) — this is
-# checked the same "unenforced, trust the method exists" way those already
-# are (see the README's note on `checkTraitConformance`).
 trait Hashable =
   hash() -> Int
 # A Pair is a grouping of a key with a value.
 #
-# `toStr` (unlike `Try`'s — see `Try.plum`'s note on `toTryStr`) IS safe as an ordinary method here: `Pair[K, V]` is only
-# ever used as `List[Pair[K, V]]`'s element type inside `Map[K, V]`, and
+# `toStr` exists because `List[T: ToStr]` requires its element type to have one
-# `List[T: ToStr]` already requires its own `T` to support `toStr` —
-# so a `Pair` used as a `List` element always has `K`/`V: ToStr` too,
+# and `Map` stores `List[Pair[K, V]]` buckets.
-# and `List`'s own eagerly-compiled `join`/`toStr` (which call `.toStr()` on
-# every element) need this to exist for every `Map` specialization anyway.
 enum Pair[K, V](ToStr) =
   | Pair(key: K, val: V)
@@ -51,8 +41,7 @@ enum Map[K: Hashable, V] =
   # `Map[Str, Int]()` — explicit generics required (nothing in a no-arg call
   # pins down `K`/`V`), builds `BUCKET_COUNT` empty bucket lists up front via
-  # `Array`'s own `push`-to-grow (see `libs/std/array.plum`'s header comment
+  # `Array`'s `push`-to-grow.
-  # on why `Array` itself has no direct "make me length N" constructor).
   fun init() -> Map[K, V] =
     b := Array[List[Pair[K, V]]]()
     i := 0
@@ -71,15 +60,11 @@ enum Map[K: Hashable, V] =
   # Gets the value for `k`, or `Err(KeyNotFound)` if absent.
   fun get(self, k: K) -> Try[V, [KeyNotFound]] =
-    current := self.buckets.get(self.bucketIndex(k)).head
+    bucket := self.buckets.get(self.bucketIndex(k))
+    for i := range bucket.size
-    while current != End
+      pair := bucket.data.get(i)
-      match current
-        Next(Node(Pair(key, val), _, next)) =>
-          if key == k
+      if pair.key == k
-            return Ok(val)
+        return Ok(pair.val)
-          current = next
-        End =>
-          break
     return Err(KeyNotFound)
   fun has(self, k: K) -> Bool =
@@ -91,17 +76,12 @@ enum Map[K: Hashable, V] =
   # unboundedly or leave a stale value reachable by `get`.
   fun set(self, k: K, v: V) -> Unit =
     bucket := self.buckets.get(self.bucketIndex(k))
-    current := bucket.head
+    for i := range bucket.size
-    while current != End
+      pair := bucket.data.get(i)
-      match current
-        Next(Node(pair, _, next)) =>
-          if pair.key == k
+      if pair.key == k
-            pair.val = v
+        pair.val = v
-            return
+        return
-          current = next
-        End =>
-          break
-    bucket.add(Pair(key: k, val: v))
+    bucket.push(Pair(key: k, val: v))
     self.size = self.size + 1
   # Sets `k`'s value to `v` only if `k` isn't already present.
@@ -112,17 +92,11 @@ enum Map[K: Hashable, V] =
   # Removes `k`'s entry, if present.
   fun remove(self, k: K) -> Unit =
     bucket := self.buckets.get(self.bucketIndex(k))
-    current := bucket.head
+    for i := range bucket.size
-    while current != End
-      match current
-        Next(node) =>
-          if node.value.key == k
+      if bucket.data.get(i).key == k
-            bucket.unlink(node)
+        bucket.removeAt(i)
-            self.size = self.size - 1
+        self.size = self.size - 1
-            return
+        return
-          current = node.next
-        End =>
-          break
   fun length(self) -> Int =
     return self.size
@@ -131,57 +105,38 @@ enum Map[K: Hashable, V] =
     return self.size == 0
   fun clear(self) -> Unit =
-    i := 0
-    while i < self.buckets.length()
+    for i := range self.buckets.length()
       self.buckets.get(i).clear()
-      i = i + 1
     self.size = 0
   # Calls `cb` with each key and value in the map. Order is bucket order,
   # then insertion order within a bucket — NOT overall insertion order (that
   # would need a separate side list to track, which nothing here needs today).
   fun each(self, cb: fn(K, V)) -> Unit =
-    i := 0
-    while i < self.buckets.length()
+    for i := range self.buckets.length()
-      current := self.buckets.get(i).head
+      bucket := self.buckets.get(i)
+      for j := range bucket.size
-      while current != End
+        pair := bucket.data.get(j)
-        match current
-          Next(Node(Pair(key, val), _, next)) =>
-            cb(key, val)
+        cb(pair.key, pair.val)
-            current = next
-          End =>
-            break
-      i = i + 1
   fun keys(self) -> List[K] =
-    result := List(head: End, tail: End, size: 0)
+    result := List[K]()
     self.each(|k, v| result.add(k))
     return result
   fun values(self) -> List[V] =
-    result := List(head: End, tail: End, size: 0)
+    result := List[V]()
     self.each(|k, v| result.add(v))
     return result
   fun map(self, cb: fn(K, V) -> Pair[X, Y]) -> Map[X, Y] =
-    b := Array[List[Pair[X, Y]]]()
-    i := 0
-    while i < BUCKET_COUNT
-      b = b.push(List[Pair[X, Y]]())
-      i = i + 1
-    result := Map(buckets: b, size: 0)
+    result := Map[X, Y]()
-    j := 0
-    while j < self.buckets.length()
+    for i := range self.buckets.length()
-      current := self.buckets.get(j).head
+      bucket := self.buckets.get(i)
+      for j := range bucket.size
-      while current != End
+        pair := bucket.data.get(j)
-        match current
-          Next(Node(Pair(key, val), _, next)) =>
-            pair := cb(key, val)
+        mapped := cb(pair.key, pair.val)
-            result.set(pair.key, pair.val)
+        result.set(mapped.key, mapped.val)
-            current = next
-          End =>
-            break
-      j = j + 1
     return result
 test "get/set/has round-trip and set replaces an existing key in place"
@@ -259,3 +214,20 @@ test "many keys landing in the same bucket still resolve correctly (collision ch
   assert m.get(4).unwrap() == 16
   assert m.get(21).unwrap() == 441
   assert m.length() == 39
+test "map_collisions_erased: Map[Str, Int] with 500 keys round-trips"
+  m := Map[Str, Int]()
+  i := 0
+  while i < 500
+    m.set("key{i}", i * 3)
+    i = i + 1
+  assert m.length() == 500
+  j := 0
+  while j < 500
+    assert m.get("key{j}").unwrap() == j * 3
+    j = j + 1
+  assert m.has("key500") == False
+  m.remove("key250")
+  assert m.length() == 499
+  assert m.has("key250") == False
+  assert m.get("key251").unwrap() == 753

plum-std/Number.plum CHANGED Viewed

@@ -26,7 +26,7 @@ HALF_PI = 1.5707963267948966f # PI / 2
 TAU = 6.283185307179586f # 2 * PI
 # `Int`/`Float` bare-wrap into `Number` with no wrapper syntax at all (see
-# `plum-checker`'s `unify`/`monomorphize::wrapPrimitiveAgainstExpected`) —
+# `plum-checker`'s `unify`, `plum-wasm-codegen`'s expected-type wrapping) —
 # assigning/returning/passing a bare `Int`/`Float` value wherever `Number` is
 # expected just works. A method not found on `Int`/`Float` directly (they no
 # longer have their own method tables at all) falls back to `Number`'s,

plum-std/Str.plum CHANGED Viewed

@@ -146,10 +146,10 @@ enum Str(Comparable, ToStr, Readable, Writable) =
   fun toStr(self) -> Str =
     self
-  fun matchPattern(self, pattern: Regex) -> List =
+  fun matchPattern(self, pattern: Regex) -> List[Str] =
     todo
-  fun matchAll(self, pattern: Regex) -> List =
+  fun matchAll(self, pattern: Regex) -> List[Str] =
     todo
   # Pads the start of `self` with repeated copies of `sub` until its length is
@@ -193,7 +193,7 @@ enum Str(Comparable, ToStr, Readable, Writable) =
   # `strings.SplitN` semantics, not JS's (which instead discards anything
   # past the limit). An empty `separator` splits into individual bytes.
   fun split(self, separator: Str, limit: Int) -> List[Str] =
-    result := List(head: End, tail: End, size: 0)
+    result := List[Str]()
     len := self.length()
     sep_len := separator.length()
     if sep_len == 0

plum-std/Testing.plum CHANGED Viewed

@@ -19,12 +19,7 @@ import std/Str
 #
 # `expectArray`/`expectOk`/`expectErr` below take a container
 # type (`List[T]`/`Try[T, E]`) whose OWN generic param is
-# nested inside the param type — this used to hit a real monomorphizer bug
+# nested inside the param type.
-# (misclassified as a "bare generic class reference" fn, then lost its type
-# argument when the specialized signature was registered, mismatching the
-# caller's concrete arg type; fixed in `plum-checker/src/monomorphize.rs`'s
-# `fnGenericParams`/`resolveFnInstantiation`, see the
-# `plum_generic_method_self_nesting_landmine`-adjacent compiler-bugs memory).
 # The underlying type's own method (`result.isOk()`, `listA.equals(listB)`)
 # still works too and reads just as well — use whichever fits the call site.
 #

plum-std/Try.plum CHANGED Viewed

@@ -80,8 +80,8 @@ enum Try[T, E] =
       Err(e) =>
         return Err(e)
-  # No implicit `toStr`: every method of a generic type is compiled for every
+  # No implicit `toStr`: `T`/`E` carry no `ToStr` bound (a `Try` may hold any
-  # specialization, so assuming `T`/`E: ToStr` would break unrelated uses.
+  # type), so the caller supplies the renderers.
   fun toTryStr(self, okToStr: fn(T) -> Str, errToStr: fn(E) -> Str) -> Str =
     match self
       Ok(v) =>

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

@@ -1475,8 +1475,30 @@ fn inferFallbackType(expr: &ast::Expr, ctx: &LocalCtx) -> PlumType {
     plum_checker::inferExpr(expr, &env, &cctx).unwrap_or(PlumType::TInt)
 }
+/// Type-checks `source` once, returning the per-expression types codegen needs
+/// (`plum_checker::typedSource`) or the joined `type error: ...` lines.
+pub fn typeCheck(source: &ast::Source) -> Result<plum_checker::TypedInfo, String> {
+    plum_checker::typedSource(source).map_err(|errs| {
+        errs.iter()
+            .map(|e| format!("type error: {}", e.message))
+            .collect::<Vec<_>>()
+            .join("\n")
+    })
+}
+/// Compiles a source already checked by `plum_checker::typedSource(source)`
+/// (the `TypedInfo` is keyed by expression address, so it must come from this
+/// very `source` value). Hosts that check once call this; `compileSource`
+/// checks and compiles in one step.
+pub fn compileTyped(
+    source: &ast::Source,
+    typed: plum_checker::TypedInfo,
+) -> Result<Vec<u8>, String> {
+    compileSourceInner(source, &[], typed).map(|(bytes, _)| bytes)
+}
 pub fn compileSource(source: &ast::Source) -> Result<Vec<u8>, String> {
-    compileSourceInner(source, &[]).map(|(bytes, _)| bytes)
+    compileTyped(source, typeCheck(source)?)
 }
 /// Like `compileSource`, also returning the key of every compiled function
@@ -1484,7 +1506,7 @@ pub fn compileSource(source: &ast::Source) -> Result<Vec<u8>, String> {
 /// generic function/method compiles exactly once however many types it is
 /// instantiated at.
 pub fn compileSourceWithFunctions(source: &ast::Source) -> Result<(Vec<u8>, Vec<String>), String> {
-    compileSourceInner(source, &[])
+    compileSourceInner(source, &[], typeCheck(source)?)
 }
 /// Compiles `test "..." { ... }` blocks for `plum test`, stripped from every
@@ -1500,13 +1522,38 @@ pub fn compileSourceWithFunctions(source: &ast::Source) -> Result<(Vec<u8>, Vec<
 /// original display name, in the same order as its exported `"test#<name>"`
 /// function.
 pub fn compileTestSource(source: &ast::Source) -> Result<(Vec<u8>, Vec<String>), String> {
+    let prog = desugarTests(source);
+    let typed = typeCheck(&prog.source)?;
+    compileTestTyped(&prog, typed)
+}
+/// A source with its `test` blocks desugared into ordinary fns. Type-check
+/// `source` (not the original) and pass the result to `compileTestTyped`.
+pub struct TestProgram {
+    pub source: ast::Source,
+    extra_exports: Vec<(String, String)>,
+    pub names: Vec<String>,
+}
+pub fn desugarTests(source: &ast::Source) -> TestProgram {
     let (desugared, extra_exports) = desugarTestsToFns(source);
     let names = extra_exports
         .iter()
         .map(|(_, export_name)| export_name["test#".len()..].to_string())
         .collect();
+    TestProgram {
+        source: desugared,
+        extra_exports,
+        names,
+    }
+}
+pub fn compileTestTyped(
+    prog: &TestProgram,
+    typed: plum_checker::TypedInfo,
+) -> Result<(Vec<u8>, Vec<String>), String> {
-    let (wasm, _) = compileSourceInner(&desugared, &extra_exports)?;
+    let (wasm, _) = compileSourceInner(&prog.source, &prog.extra_exports, typed)?;
-    Ok((wasm, names))
+    Ok((wasm, prog.names.clone()))
 }
 fn strLit(s: String) -> ast::Expr {
@@ -1675,17 +1722,12 @@ fn desugarAssertStmt(stmt: &ast::Stmt) -> ast::Stmt {
 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
     // checker's per-expression instantiated types drive every box/unbox decision.
-    let typed = plum_checker::typedSource(source).map_err(|errs| {
-        errs.iter()
-            .map(|e| format!("type error: {}", e.message))
-            .collect::<Vec<_>>()
-            .join("\n")
-    })?;
     let types = typed.expr_types;
-    let (global_env, methods, enum_variants, enum_params) = plum_checker::buildTables(source, true);
+    let (global_env, methods, enum_variants, enum_params) = plum_checker::buildGlobalTables(source);
     let min_required = plum_checker::buildMinRequiredArgs(source);
     // Intern every tag name the program's types mention, in sorted order.
@@ -2165,7 +2207,9 @@ fn compileSourceInner(
     for f in &fns {
         let body = match compileIntrinsicFnBody(f) {
             Some(body) => body,
-            None => compileFnBody(f, &ctx, &mut state)?,
+            None => compileFnBody(f, &ctx, &mut state).map_err(|e| {
+                format!("{e} (in '{}{}')", f.type_param.as_ref().map(|r| format!("{r}.")).unwrap_or_default(), f.name)
+            })?,
         };
         compiled_bodies.push((fnKey(f), body));
     }
@@ -3049,6 +3093,55 @@ fn compileArrayIntrinsicFnBody(f: &ast::Fn) -> Option<Vec<u8>> {
             Instruction::End.encode(&mut body);
             Some(body)
         }
+        // resize(self, n: Int) -> Array[T] — a new array of length `n` holding
+        // `self`'s first `min(len, n)` elements (the rest null). Lets `List`
+        // grow by doubling instead of copying on every `push`.
+        "resize" => {
+            const SELF: u32 = 0;
+            const N: u32 = 1;
+            const OLD_LEN: u32 = 2;
+            const NEW_LEN: u32 = 3;
+            const NEW_ARR: u32 = 4;
+            let array_ref = gcRef(array_type_idx);
+            let mut body = Vec::new();
+            body.extend(encodeLeb128U32(2));
+            body.extend(encodeLeb128U32(2)); // old_len, new_len: i32
+            ValType::I32.encode(&mut body);
+            body.extend(encodeLeb128U32(1)); // new_arr: ref
+            array_ref.encode(&mut body);
+            Instruction::LocalGet(SELF).encode(&mut body);
+            Instruction::ArrayLen.encode(&mut body);
+            Instruction::LocalSet(OLD_LEN).encode(&mut body);
+            Instruction::LocalGet(N).encode(&mut body);
+            Instruction::I32WrapI64.encode(&mut body);
+            Instruction::LocalSet(NEW_LEN).encode(&mut body);
+            Instruction::LocalGet(NEW_LEN).encode(&mut body);
+            Instruction::ArrayNewDefault(array_type_idx).encode(&mut body);
+            Instruction::LocalSet(NEW_ARR).encode(&mut body);
+            // array.copy(new_arr, 0, self, 0, min(old_len, new_len))
+            Instruction::LocalGet(NEW_ARR).encode(&mut body);
+            Instruction::I32Const(0).encode(&mut body);
+            Instruction::LocalGet(SELF).encode(&mut body);
+            Instruction::I32Const(0).encode(&mut body);
+            Instruction::LocalGet(OLD_LEN).encode(&mut body);
+            Instruction::LocalGet(NEW_LEN).encode(&mut body);
+            Instruction::LocalGet(OLD_LEN).encode(&mut body);
+            Instruction::LocalGet(NEW_LEN).encode(&mut body);
+            Instruction::I32LtU.encode(&mut body);
+            Instruction::Select.encode(&mut body);
+            Instruction::ArrayCopy {
+                array_type_index_dst: array_type_idx,
+                array_type_index_src: array_type_idx,
+            }
+            .encode(&mut body);
+            Instruction::LocalGet(NEW_ARR).encode(&mut body);
+            Instruction::End.encode(&mut body);
+            Some(body)
+        }
         "get" => {
             let mut body = vec![0u8];
             Instruction::LocalGet(0).encode(&mut body); // self
@@ -6090,12 +6183,12 @@ fn compileExpr(
                     .name
                     .chars()
                     .next()
-                    .is_some_and(|c| c.is_uppercase() || c == plum_checker::TAG_MARKER)
+                    .is_some_and(|c| c.is_uppercase())
                 && matches!(inferLocalType(expr, ctx), PlumType::TTags(_))
             {
                 let payload = call.args.first().map(argExprOf);
                 compileTagLiteral(
-                    plum_checker::tagLiteralName(&call.name),
+                    &call.name,
                     payload,
                     body,
                     ctx,
@@ -6159,7 +6252,7 @@ fn compileExpr(
                 // A bare uppercase name the checker typed as a tag union is a tag
                 // literal, even when a declared variant shares its name.
                 Some(_) if matches!(inferLocalType(expr, ctx), PlumType::TTags(_)) => {
-                    compileTagLiteral(plum_checker::tagLiteralName(n), None, body, ctx, state)?
+                    compileTagLiteral(n, None, body, ctx, state)?
                 }
                 Some(info) if info.field_types.is_empty() => {
                     let global_idx = *ctx.singleton_globals.get(n)
@@ -6194,10 +6287,10 @@ fn compileExpr(
                         None if n
                             .chars()
                             .next()
-                            .is_some_and(|c| c.is_uppercase() || c == plum_checker::TAG_MARKER)
+                            .is_some_and(|c| c.is_uppercase())
                             && matches!(inferLocalType(expr, ctx), PlumType::TTags(_)) =>
                         {
-                            compileTagLiteral(plum_checker::tagLiteralName(n), None, body, ctx, state)?
+                            compileTagLiteral(n, None, body, ctx, state)?
                         }
                         None => {
                             return Err(format!(