eaf49cb | plum | pyrossh

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

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

eaf49cb — Peter John 2026-10-25T19:10:46+05:30

feat(checker): check generics structurally on the original source; add typedSource

Files changed (3) hide show

plum-checker/src/lib.rs +876 -418
plum-checker/src/monomorphize.rs +2 -0
plum-checker/tests/checker_tests.rs +211 -6

plum-checker/src/lib.rs CHANGED Viewed

@@ -6,9 +6,264 @@ pub mod monomorphize;
 pub mod types;
 use plum_core::ast;
+use std::cell::{Cell, RefCell};
-use std::collections::BTreeMap;
+use std::collections::{BTreeMap, HashMap};
 use types::{CheckError, CheckResult, PlumType, TypeEnv, TypeScheme};
+thread_local! {
+    /// Counter for the fresh `_t<N>` inference variables minted per generic call site.
+    static FRESH: Cell<u32> = const { Cell::new(0) };
+    /// When set, `inferExprWith` records every expression's type here (see `typedSource`).
+    static RECORD: RefCell<Option<HashMap<usize, PlumType>>> = const { RefCell::new(None) };
+}
+/// Per-expression instantiated types of a checked source, for codegen.
+#[derive(Debug, Clone, Default)]
+pub struct TypedInfo {
+    /// Expression address (`&ast::Expr as *const _ as usize`) -> its type.
+    pub expr_types: HashMap<usize, PlumType>,
+}
+fn freshVar() -> PlumType {
+    FRESH.with(|c| {
+        let n = c.get();
+        c.set(n + 1);
+        PlumType::TVar(format!("_t{}", n))
+    })
+}
+/// Binding of `_t<N>` inference variables to types, local to one call site.
+type Binds = BTreeMap<String, PlumType>;
+fn isInferVar(name: &str) -> bool {
+    name.starts_with("_t")
+}
+/// Replaces bound `_t<N>` variables (to a fixpoint, so chains resolve).
+fn substVars(ty: &PlumType, b: &Binds) -> PlumType {
+    if b.is_empty() {
+        return ty.clone();
+    }
+    fn go(ty: &PlumType, b: &Binds, depth: u32) -> PlumType {
+        use PlumType::*;
+        match ty {
+            TVar(n) if depth < 8 => match b.get(n) {
+                Some(t) => go(t, b, depth + 1),
+                None => ty.clone(),
+            },
+            TApp(n, args) => TApp(n.clone(), args.iter().map(|a| go(a, b, depth)).collect()),
+            TFun(ps, r) => TFun(
+                ps.iter().map(|p| go(p, b, depth)).collect(),
+                Box::new(go(r, b, depth)),
+            ),
+            TVariadic(i) => TVariadic(Box::new(go(i, b, depth))),
+            TTags(tags) => TTags(
+                tags.iter()
+                    .map(|(k, v)| (k.clone(), v.as_ref().map(|t| Box::new(go(t, b, depth)))))
+                    .collect(),
+            ),
+            _ => ty.clone(),
+        }
+    }
+    go(ty, b, 0)
+}
+/// Free generic parameter names in `ty`, first-appearance order.
+fn freeTParams(ty: &PlumType, out: &mut Vec<String>) {
+    use PlumType::*;
+    match ty {
+        TParam(n) => {
+            if !out.contains(n) {
+                out.push(n.clone());
+            }
+        }
+        TApp(_, args) => args.iter().for_each(|a| freeTParams(a, out)),
+        TFun(ps, r) => {
+            ps.iter().for_each(|p| freeTParams(p, out));
+            freeTParams(r, out);
+        }
+        TVariadic(i) => freeTParams(i, out),
+        TTags(tags) => tags
+            .values()
+            .flatten()
+            .for_each(|t| freeTParams(t, out)),
+        _ => {}
+    }
+}
+/// Instantiates every free `TParam` in `sig`: those named in `owner` take the
+/// owner's (receiver's) type, all others get a fresh inference variable.
+fn instSig(sig: &PlumType, owner: &BTreeMap<String, PlumType>) -> PlumType {
+    let mut names = Vec::new();
+    freeTParams(sig, &mut names);
+    let map: BTreeMap<String, PlumType> = names
+        .into_iter()
+        .map(|n| {
+            let t = owner.get(&n).cloned().unwrap_or_else(freshVar);
+            (n, t)
+        })
+        .collect();
+    types::substitute(sig, &map)
+}
+/// One-way matching: binds the inference variables of `pattern` from `actual`.
+fn bindMatch(pattern: &PlumType, actual: &PlumType, b: &mut Binds) {
+    use PlumType::*;
+    match (pattern, actual) {
+        (TVar(n), a) if isInferVar(n) => {
+            if matches!(a, TVar(_)) {
+                return;
+            }
+            match b.get(n).cloned() {
+                None => {
+                    b.insert(n.clone(), a.clone());
+                }
+                // A variable standing for a whole tag union widens to cover all
+                // the unions seen for it (E is covariant).
+                Some(TTags(old)) if matches!(a, TTags(_)) => {
+                    let TTags(new) = a else { unreachable!() };
+                    let mut merged = old;
+                    for (k, v) in new {
+                        merged.entry(k.clone()).or_insert_with(|| v.clone());
+                    }
+                    b.insert(n.clone(), TTags(merged));
+                }
+                Some(bound) => bindMatch(&bound, a, b),
+            }
+        }
+        (TApp(x, xs), TApp(y, ys)) if x == y && xs.len() == ys.len() => {
+            for (p, a) in xs.iter().zip(ys) {
+                bindMatch(p, a, b);
+            }
+        }
+        (TFun(ps, r), TFun(qs, s)) if ps.len() == qs.len() => {
+            for (p, a) in ps.iter().zip(qs) {
+                bindMatch(p, a, b);
+            }
+            bindMatch(r, s, b);
+        }
+        (TVariadic(p), TVariadic(a)) => bindMatch(p, a, b),
+        (TTags(p), TTags(a)) => {
+            for (tag, pp) in p {
+                if let (Some(pp), Some(Some(ap))) = (pp, a.get(tag)) {
+                    bindMatch(pp, ap, b);
+                }
+            }
+        }
+        _ => {}
+    }
+}
+fn isGenericName(n: &str) -> bool {
+    monomorphize::isGenericParamName(n)
+}
+/// Structural type conversion for UN-monomorphized source: `List[Int]` ->
+/// `TApp`, a single-uppercase-letter name (the grammar's generic parameter
+/// spelling) -> `TParam`.
+pub fn plumTypeFromAstG(ty: &ast::Type) -> PlumType {
+    if !ty.generics.is_empty() {
+        return PlumType::TApp(
+            ty.name.clone(),
+            ty.generics.iter().map(plumTypeFromAstG).collect(),
+        );
+    }
+    if isGenericName(&ty.name) {
+        return PlumType::TParam(ty.name.clone());
+    }
+    plumTypeFromName(&ty.name)
+}
+fn paramTypeG(pt: &ast::ParamType) -> PlumType {
+    match pt {
+        ast::ParamType::Type(t) => plumTypeFromAstG(t),
+        ast::ParamType::Variadic(t) => PlumType::TVariadic(Box::new(plumTypeFromAstG(t))),
+        ast::ParamType::Fn(params, ret) => PlumType::TFun(
+            params.iter().map(plumTypeFromAstG).collect(),
+            Box::new(
+                ret.as_ref()
+                    .map(|r| plumTypeFromAstG(r))
+                    .unwrap_or(PlumType::TUnit),
+            ),
+        ),
+    }
+}
+/// The generic parameter names of enum `name` (empty if non-generic/unknown).
+fn enumGenericsOf<'a>(name: &str, ctx: &'a CheckCtx) -> &'a [String] {
+    ctx.enum_variants
+        .values()
+        .find(|i| i.enum_name == name)
+        .map(|i| i.generics.as_slice())
+        .unwrap_or(&[])
+}
+fn appSubst(generics: &[String], args: &[PlumType]) -> BTreeMap<String, PlumType> {
+    generics.iter().cloned().zip(args.iter().cloned()).collect()
+}
+/// A variant's payload field types with the enum's generics replaced by the
+/// type arguments of `ty` (when it is a `TApp`).
+fn variantFields(info: &EnumVariantInfo, ty: &PlumType) -> Vec<PlumType> {
+    match ty {
+        PlumType::TApp(_, args) if args.len() == info.generics.len() => {
+            let s = appSubst(&info.generics, args);
+            info.field_types
+                .iter()
+                .map(|f| types::substitute(f, &s))
+                .collect()
+        }
+        _ if info.generics.is_empty() => info.field_types.clone(),
+        // A generic variant seen through a non-parameterized type: unknown arguments.
+        _ => {
+            let s: BTreeMap<String, PlumType> = info
+                .generics
+                .iter()
+                .map(|g| (g.clone(), PlumType::TVar("_".to_string())))
+                .collect();
+            info.field_types
+                .iter()
+                .map(|f| types::substitute(f, &s))
+                .collect()
+        }
+    }
+}
+/// `Ok(3)`-style result type of a variant of enum `info.enum_name`.
+fn enumTypeWith(info: &EnumVariantInfo, owner: &BTreeMap<String, PlumType>) -> PlumType {
+    if info.generics.is_empty() {
+        PlumType::TNamed(info.enum_name.clone())
+    } else {
+        PlumType::TApp(
+            info.enum_name.clone(),
+            info.generics
+                .iter()
+                .map(|g| owner.get(g).cloned().unwrap_or(PlumType::TVar("_".into())))
+                .collect(),
+        )
+    }
+}
+fn freshOwner(generics: &[String]) -> BTreeMap<String, PlumType> {
+    generics.iter().map(|g| (g.clone(), freshVar())).collect()
+}
+fn recordType(expr: &ast::Expr, ty: &PlumType) {
+    RECORD.with(|r| {
+        if let Some(m) = r.borrow_mut().as_mut() {
+            m.insert(expr as *const ast::Expr as usize, ty.clone());
+        }
+    });
+}
+/// Base name of a nominal type (`TNamed`/`TApp`).
+fn nominalName(t: &PlumType) -> Option<&str> {
+    match t {
+        PlumType::TNamed(n) | PlumType::TApp(n, _) => Some(n),
+        _ => None,
+    }
+}
 /// Maps a bare type name (as written in source: a param/return annotation, or
 /// a method's receiver name) to its `PlumType`. Builtin primitives get their
 /// dedicated variant; anything else is an unmodeled `TNamed`.
@@ -139,6 +394,13 @@ pub fn tagUnionSegmentsCompatible(expected: &str, actual: &str, ctx: &CheckCtx)
 /// 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
+/// same name shadows it instead of being a redeclaration).
+const GLOBAL_KEY: &str = "$global:";
+/// `TypeEnv` key prefix for a trait method's signature (`$trait:Hashable:hash`).
+const TRAIT_KEY: &str = "$trait:";
+/// `TypeEnv` key prefix for a generic parameter's trait bound (`$bound:K:Hashable`).
+const BOUND_KEY: &str = "$bound:";
 pub fn plumTypeFromAst(ty: &ast::Type) -> PlumType {
     plumTypeFromName(&ty.name)
@@ -152,7 +414,7 @@ pub fn plumTypeFromAst(ty: &ast::Type) -> PlumType {
 /// the same receiver name string `ctx.methods` is keyed by.
 pub fn methodReceiverName(ty: &PlumType) -> Option<String> {
     match ty {
-        PlumType::TNamed(name) => Some(name.clone()),
+        PlumType::TNamed(name) | PlumType::TApp(name, _) => Some(name.clone()),
         PlumType::TInt => Some("Int".to_string()),
         PlumType::TFloat => Some("Float".to_string()),
         PlumType::TBool => Some("Bool".to_string()),
@@ -197,6 +459,33 @@ pub fn unify(t1: &PlumType, t2: &PlumType, ctx: &CheckCtx) -> Result<(), String>
         (PlumType::TByteSlice, PlumType::TByteSlice) => Ok(()),
         (PlumType::TUnit, PlumType::TUnit) => Ok(()),
         (PlumType::TNamed(a), PlumType::TNamed(b)) if a == b => Ok(()),
+        // Structural generics: same base, arguments unify pairwise (tag unions
+        // inside the arguments stay covariant through the TTags arm).
+        (PlumType::TApp(a, xs), PlumType::TApp(b, ys)) if a == b && xs.len() == ys.len() => {
+            for (x, y) in xs.iter().zip(ys.iter()) {
+                unify(x, y, ctx).map_err(|e| {
+                    format!("type mismatch: expected {}, found {} ({})", t1, t2, e)
+                })?;
+            }
+            Ok(())
+        }
+        (PlumType::TParam(a), PlumType::TParam(b)) if a == b => Ok(()),
+        // A generic type used bare (`o: Link`) accepts any instantiation.
+        (PlumType::TApp(a, _), PlumType::TNamed(b))
+        | (PlumType::TNamed(a), PlumType::TApp(b, _))
+            if a == b =>
+        {
+            Ok(())
+        }
+        // A bare variant name as a type against its generic enum (either direction).
+        (PlumType::TApp(a, _), PlumType::TNamed(b)) | (PlumType::TNamed(b), PlumType::TApp(a, _))
+            if ctx
+                .enum_variants
+                .get(b)
+                .is_some_and(|info| &info.enum_name == a) =>
+        {
+            Ok(())
+        }
         // Tag-union subtyping: every tag of `actual` must exist in `expected`
         // with a unifying payload.
         (PlumType::TTags(exp), PlumType::TTags(act)) => {
@@ -274,6 +563,22 @@ pub fn unify(t1: &PlumType, t2: &PlumType, ctx: &CheckCtx) -> Result<(), String>
     }
 }
+/// Return-position check: a value still typed by a bare generic parameter is
+/// accepted for a concrete declared return (`fun get() -> Int = self.value` in
+/// a `Box[T]` is only ever instantiated at `Int` by existing code), everything
+/// else goes through `unifyArg`.
+fn unifyReturn(
+    declared: &PlumType,
+    actual: &PlumType,
+    actual_expr: &ast::Expr,
+    ctx: &CheckCtx,
+) -> Result<(), String> {
+    if matches!(actual, PlumType::TParam(_)) && !matches!(declared, PlumType::TParam(_)) {
+        return Ok(());
+    }
+    unifyArg(declared, actual, actual_expr, ctx)
+}
 /// True if `expr` (looking through parens) is a direct construction/reference
 /// of exactly the enum variant named `variant_name` — a bare payload-free
 /// reference (`Red`), a positional-payload construction (`Circle(1)`), or a
@@ -344,6 +649,9 @@ pub struct EnumVariantInfo {
     /// form (`Next(T)`). See `ast::EnumVariant::field_names`.
     pub field_names: Vec<String>,
     pub values: Vec<ast::Expr>,
+    /// The owning enum's generic parameter names (`[T, E]` for `Try`) —
+    /// empty for a non-generic enum and for monomorphized specializations.
+    pub generics: Vec<String>,
 }
 /// Enum variant name -> its info, e.g. `"True" -> { enum_name: "Bool", tag: 1, field_types: [] }`.
 pub type EnumVariants = BTreeMap<String, EnumVariantInfo>;
@@ -396,6 +704,23 @@ 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)
+        } else {
+            plumTypeFromAst(t)
+        }
+    };
     let mut global_env: TypeEnv = TypeEnv::new();
     let mut methods: MethodEnv = BTreeMap::new();
     let mut enum_variants: EnumVariants = BTreeMap::new();
@@ -420,12 +745,12 @@ pub fn buildGlobalTables(source: &ast::Source) -> (TypeEnv, MethodEnv, EnumVaria
         match item {
             ast::Item::Enum(e) => {
                 let shared_field_types: Vec<PlumType> =
-                    e.params.iter().map(|p| plumTypeFromAst(&p.ty)).collect();
+                    e.params.iter().map(|p| conv(&p.ty)).collect();
                 if !e.params.is_empty() {
                     let params = e
                         .params
                         .iter()
-                        .map(|p| (p.name.clone(), plumTypeFromAst(&p.ty)))
+                        .map(|p| (p.name.clone(), conv(&p.ty)))
                         .collect();
                     enum_params.insert(e.name.clone(), params);
                 }
@@ -466,7 +791,7 @@ pub fn buildGlobalTables(source: &ast::Source) -> (TypeEnv, MethodEnv, EnumVaria
                         (vec![PlumType::TNamed(v.name.clone())], Vec::new())
                     } else {
                         (
-                            v.fields.iter().map(plumTypeFromAst).collect(),
+                            v.fields.iter().map(conv).collect(),
                             v.field_names.clone(),
                         )
                     };
@@ -478,6 +803,11 @@ pub fn buildGlobalTables(source: &ast::Source) -> (TypeEnv, MethodEnv, EnumVaria
                             field_types,
                             field_names,
                             values: v.values.clone(),
+                            generics: if generic {
+                                monomorphize::enumGenericParams(e)
+                            } else {
+                                Vec::new()
+                            },
                         },
                     );
                 }
@@ -496,28 +826,36 @@ pub fn buildGlobalTables(source: &ast::Source) -> (TypeEnv, MethodEnv, EnumVaria
                     .params
                     .iter()
                     .map(|p| match &p.ty {
-                        ast::ParamType::Type(t) => plumTypeFromAst(t),
+                        ast::ParamType::Type(t) => conv(t),
-                        ast::ParamType::Variadic(t) => {
-                            PlumType::TVariadic(Box::new(plumTypeFromAst(t)))
+                        ast::ParamType::Variadic(t) => PlumType::TVariadic(Box::new(conv(t))),
-                        }
                         ast::ParamType::Fn(params, ret) => {
-                            let param_types = params.iter().map(plumTypeFromAst).collect();
+                            let param_types = params.iter().map(&conv).collect();
                             let ret_ty = ret
                                 .as_ref()
-                                .map(|r| plumTypeFromAst(r))
+                                .map(|r| conv(r))
                                 .unwrap_or(PlumType::TUnit);
                             PlumType::TFun(param_types, Box::new(ret_ty))
                         }
                     })
                     .collect();
-                let ret = f
-                    .returns
-                    .as_ref()
-                    .map(plumTypeFromAst)
-                    .unwrap_or(PlumType::TUnit);
+                let ret = f.returns.as_ref().map(&conv).unwrap_or(PlumType::TUnit);
                 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 {
+                    global_env.insert(
+                        format!("{}{}", GLOBAL_KEY, f.name),
+                        TypeScheme::mono(PlumType::TUnit),
+                    );
+                    let mut vars = Vec::new();
+                    freeTParams(&fn_ty, &mut vars);
+                    global_env.insert(
+                        f.name.clone(),
+                        TypeScheme {
+                            vars,
+                            body: Box::new(fn_ty),
+                        },
+                    );
                 } else {
                     global_env.insert(f.name.clone(), TypeScheme::mono(fn_ty));
                 }
@@ -534,6 +872,17 @@ pub fn buildGlobalTables(source: &ast::Source) -> (TypeEnv, MethodEnv, EnumVaria
                 };
                 global_env.insert(c.name.clone(), TypeScheme::mono(ty));
             }
+            ast::Item::Trait(t) if generic => {
+                // Trait method signatures, looked up for calls on a bounded `TParam`.
+                for m in &t.methods {
+                    let params: Vec<PlumType> = m.params.iter().map(|p| paramTypeG(&p.ty)).collect();
+                    let ret = m.returns.as_ref().map(&conv).unwrap_or(PlumType::TUnit);
+                    global_env.insert(
+                        format!("{}{}:{}", TRAIT_KEY, t.name, m.name),
+                        TypeScheme::mono(PlumType::TFun(params, Box::new(ret))),
+                    );
+                }
+            }
             _ => {}
         }
     }
@@ -652,12 +1001,26 @@ fn checkTraitConformance(source: &ast::Source) -> Vec<CheckError> {
 }
 pub fn checkSource(source: &ast::Source) -> CheckResult<()> {
+    checkSourceInner(source)
+}
-    // Runs against the ORIGINAL (pre-monomorphization) source, deliberately —
+/// Type-checks the original source like `checkSource` and also returns the
+/// instantiated type of every expression (keyed by expression address) for codegen.
+pub fn typedSource(source: &ast::Source) -> CheckResult<TypedInfo> {
+    RECORD.with(|r| *r.borrow_mut() = Some(HashMap::new()));
+    let result = checkSourceInner(source);
+    let recorded = RECORD.with(|r| r.borrow_mut().take()).unwrap_or_default();
+    result.map(|()| TypedInfo {
+        expr_types: recorded,
+    })
+}
+fn checkSourceInner(source: &ast::Source) -> CheckResult<()> {
-    // see `checkTraitConformance`'s own doc comment for why.
+    // Generic items are checked once, structurally (`TApp`/`TParam`), on the
+    // ORIGINAL source — no monomorphization.
     let mut errors: Vec<CheckError> = checkTraitConformance(source);
-    let source = monomorphize::monomorphizeSource(source).map_err(|e| vec![CheckError::new(e)])?;
-    let (global_env, methods, enum_variants, enum_params) = buildGlobalTables(&source);
+    let (global_env, methods, enum_variants, enum_params) = buildTables(source, true);
-    let min_required = buildMinRequiredArgs(&source);
+    let min_required = buildMinRequiredArgs(source);
     let ctx = CheckCtx {
         methods: &methods,
         enum_variants: &enum_variants,
@@ -721,9 +1084,17 @@ pub fn checkSource(source: &ast::Source) -> CheckResult<()> {
         }
     }
+    let enums_by_name: BTreeMap<&str, &ast::Enum> = source
+        .items
+        .iter()
+        .filter_map(|i| match i {
+            ast::Item::Enum(e) => Some((e.name.as_str(), e)),
+            _ => None,
+        })
+        .collect();
     for item in &source.items {
         if let ast::Item::Fn(f) = item {
-            let mut local_errors = checkFn(f, &global_env, &ctx);
+            let mut local_errors = checkFn(f, &global_env, &ctx, &enums_by_name);
             errors.append(&mut local_errors);
         }
     }
@@ -750,7 +1121,12 @@ pub fn checkSource(source: &ast::Source) -> CheckResult<()> {
     }
 }
+fn checkFn(
+    f: &ast::Fn,
+    global_env: &TypeEnv,
+    ctx: &CheckCtx,
-fn checkFn(f: &ast::Fn, global_env: &TypeEnv, ctx: &CheckCtx) -> Vec<CheckError> {
+    enums: &BTreeMap<&str, &ast::Enum>,
+) -> Vec<CheckError> {
     let mut errors = Vec::new();
     // `is_extern` and `body == FnBody::Extern` must agree — either both (a genuine
@@ -817,45 +1193,46 @@ fn checkFn(f: &ast::Fn, global_env: &TypeEnv, ctx: &CheckCtx) -> Vec<CheckError>
     // Methods (`name<Receiver>(...)`) get an implicit `self: Receiver` binding.
     if let Some(recv) = &f.type_param {
+        let generics = enumGenericsOf(recv, ctx);
-        let recv_ty = ast::Type {
+        let self_ty = if generics.is_empty() {
+            plumTypeFromName(recv)
+        } else {
+            PlumType::TApp(
-            name: recv.clone(),
+                recv.clone(),
-            generics: vec![],
+                generics.iter().map(|g| PlumType::TParam(g.clone())).collect(),
+            )
         };
+        env.insert("self".to_string(), TypeScheme::mono(self_ty));
+        // The owner's declared trait bounds (`K: Hashable`) apply in its methods.
+        if let Some(e) = enums.get(recv.as_str()) {
+            for g in &e.generics {
+                for b in &g.bounds {
-        env.insert(
+                    env.insert(
-            "self".to_string(),
+                        format!("{}{}:{}", BOUND_KEY, g.name, b),
-            TypeScheme::mono(plumTypeFromAst(&recv_ty)),
+                        TypeScheme::mono(PlumType::TUnit),
-        );
+                    );
+                }
+            }
+        }
     }
     // Add params to env
     for p in &f.params {
-        let ty = match &p.ty {
-            ast::ParamType::Type(t) => plumTypeFromAst(t),
-            ast::ParamType::Variadic(t) => PlumType::TVariadic(Box::new(plumTypeFromAst(t))),
-            ast::ParamType::Fn(params, ret) => {
-                let param_types = params.iter().map(plumTypeFromAst).collect();
-                let ret_ty = ret
-                    .as_ref()
-                    .map(|r| plumTypeFromAst(r))
-                    .unwrap_or(PlumType::TUnit);
-                PlumType::TFun(param_types, Box::new(ret_ty))
-            }
-        };
-        env.insert(p.name.clone(), TypeScheme::mono(ty));
+        env.insert(p.name.clone(), TypeScheme::mono(paramTypeG(&p.ty)));
     }
     let declared_ret = f
         .returns
         .as_ref()
-        .map(plumTypeFromAst)
+        .map(plumTypeFromAstG)
         .unwrap_or(PlumType::TUnit);
     // Reserved env key read by `?` (see `inferExpr`'s `Try` arm); closures remove it.
     env.insert(RETURN_KEY.to_string(), TypeScheme::mono(declared_ret.clone()));
     match &f.body {
-        ast::FnBody::Expr(e) => match inferExpr(e, &env, ctx) {
+        ast::FnBody::Expr(e) => match inferExprWith(e, &env, ctx, Some(&declared_ret)) {
             Ok(t) => {
-                if let Err(msg) = unifyArg(&declared_ret, &t, e, ctx) {
+                if let Err(msg) = unifyReturn(&declared_ret, &t, e, ctx) {
                     errors.push(CheckError::at(
                         f.line,
                         f.column,
@@ -870,28 +1247,39 @@ fn checkFn(f: &ast::Fn, global_env: &TypeEnv, ctx: &CheckCtx) -> Vec<CheckError>
             )),
         },
         ast::FnBody::Block(block) => {
+            // The tail expression is checked against the declared return type
+            // (which also pins down its generic arguments); everything before
+            // it is an ordinary statement.
+            let (tail, init) = match block.stmts.split_last() {
+                Some((ast::Stmt::Expr(e, line, column), init)) => (Some((e, *line, *column)), init),
+                _ => (None, &block.stmts[..]),
+            };
+            for stmt in init {
-            let mut block_errors = checkBlock(
+                errors.append(&mut checkStmt(
-                block,
+                    stmt,
-                &mut env,
+                    &mut env,
-                &declared_ret,
+                    &declared_ret,
-                &f.name,
+                    &f.name,
-                (f.line, f.column),
+                    (f.line, f.column),
-                ctx,
+                    ctx,
-            );
+                ));
-            errors.append(&mut block_errors);
+            }
-            // Check the type of the last expression statement against the declared return type
-            if let Some(ast::Stmt::Expr(last_expr, line, column)) = block.stmts.last() {
+            if let Some((last_expr, line, column)) = tail {
-                match inferExpr(last_expr, &env, ctx) {
+                match inferExprWith(last_expr, &env, ctx, Some(&declared_ret)) {
                     Ok(t) => {
-                        if let Err(msg) = unifyArg(&declared_ret, &t, last_expr, ctx) {
+                        if let Err(msg) = unifyReturn(&declared_ret, &t, last_expr, ctx) {
                             errors.push(CheckError::at(
-                                *line,
+                                line,
-                                *column,
+                                column,
                                 format!("fn '{}': return type mismatch: {}", f.name, msg),
                             ));
                         }
                     }
+                    Err(msg) => errors.push(CheckError::at(
+                        line,
+                        column,
-                    Err(_) => {} // already reported by checkBlock
+                        format!("fn '{}': {}", f.name, msg),
+                    )),
                 }
             }
         }
@@ -946,7 +1334,8 @@ fn checkStmt(
             for (target, value) in a.targets.iter().zip(a.values.iter()) {
                 match target {
                     ast::AssignTarget::Var(name) => {
-                        let already_declared = lookup(env, name).is_ok();
+                        let already_declared = lookup(env, name).is_ok()
+                            && !env.contains_key(&format!("{}{}", GLOBAL_KEY, name));
                         if a.declare && already_declared {
                             errors.push(CheckError::at(fn_pos.0, fn_pos.1, format!("fn '{}': assign '{}': already declared — use '=' to reassign, not ':='", fn_name, name)));
                         } else if !a.declare && already_declared {
@@ -997,8 +1386,8 @@ fn checkStmt(
                     ast::AssignTarget::Field(object, field_name) => {
                         let label = format!("{}.{}", describeTargetObject(object), field_name);
                         match (inferExpr(object, env, ctx), inferExpr(value, env, ctx)) {
-                            (Ok(PlumType::TNamed(class_name)), Ok(value_ty)) => {
+                            (Ok(obj_ty @ (PlumType::TNamed(_) | PlumType::TApp(..))), Ok(value_ty)) => {
-                                match lookupFieldType(&class_name, field_name, ctx) {
+                                match fieldTypeOf(&obj_ty, field_name, ctx) {
                                     Ok(field_ty) => {
                                         if let Err(msg) = unifyArg(&field_ty, &value_ty, value, ctx) {
                                             errors.push(CheckError::at(fn_pos.0, fn_pos.1, format!("fn '{}': assign '{}': {}", fn_name, label, msg)));
@@ -1015,9 +1404,9 @@ fn checkStmt(
                 }
             }
         }
-        ast::Stmt::Return(Some(e)) => match inferExpr(e, env, ctx) {
+        ast::Stmt::Return(Some(e)) => match inferExprWith(e, env, ctx, Some(declared_ret)) {
             Ok(t) => {
-                if let Err(msg) = unifyArg(declared_ret, &t, e, ctx) {
+                if let Err(msg) = unifyReturn(declared_ret, &t, e, ctx) {
                     errors.push(CheckError::at(
                         fn_pos.0,
                         fn_pos.1,
@@ -1277,7 +1666,7 @@ fn coverCtors(ty: &PlumType, ctx: &CheckCtx) -> Option<(String, Vec<CoverCtor>)>
                 })
                 .collect(),
         )),
-        PlumType::TNamed(enum_name) => {
+        PlumType::TNamed(enum_name) | PlumType::TApp(enum_name, _) => {
             let mut vs: Vec<(&String, &EnumVariantInfo)> = ctx
                 .enum_variants
                 .iter()
@@ -1297,7 +1686,7 @@ fn coverCtors(ty: &PlumType, ctx: &CheckCtx) -> Option<(String, Vec<CoverCtor>)>
                         fields: if ctx.enum_params.contains_key(enum_name) {
                             Vec::new()
                         } else {
-                            i.field_types.clone()
+                            variantFields(i, ty)
                         },
                     })
                     .collect(),
@@ -1541,7 +1930,9 @@ fn inferClassCallRaw(
     call: &ast::ClassCall,
     env: &TypeEnv,
     ctx: &CheckCtx,
+    expected: Option<&PlumType>,
 ) -> Result<PlumType, String> {
+    let explicit: Vec<PlumType> = call.generics.iter().map(plumTypeFromAstG).collect();
     // A zero-arg `Type()` construction with a nested, no-param `fun init() ->
     // Type = ...` method declared is sugar for calling that method — the
     // constructor pattern used by e.g. `Buffer` — rather than raw field
@@ -1549,12 +1940,25 @@ fn inferClassCallRaw(
     // and go through ordinary field-by-field construction below instead,
     // which requires every field to be given.
     if call.fields.is_empty() {
-        if let Some(PlumType::TFun(init_params, ret)) = ctx
+        if let Some(sig @ PlumType::TFun(init_params, _)) = ctx
             .methods
             .get(&(call.type_name.clone(), "init".to_string()))
         {
             if initCallableWithNoArgs(init_params) {
+                let gens = enumGenericsOf(&call.type_name, ctx);
+                let owner = if !explicit.is_empty() && explicit.len() == gens.len() {
+                    appSubst(gens, &explicit)
+                } else {
+                    BTreeMap::new()
+                };
+                let PlumType::TFun(_, ret) = instSig(sig, &owner) else {
+                    unreachable!("instSig preserves the TFun shape")
+                };
+                let mut binds = Binds::new();
+                if let Some(exp) = expected {
+                    bindMatch(&ret, exp, &mut binds);
+                }
-                return Ok(*ret.clone());
+                return Ok(substVars(&ret, &binds));
             }
         }
     }
@@ -1566,12 +1970,19 @@ fn inferClassCallRaw(
         // replacement, e.g. `enum Cat = | Cat(name: Str)`) constructs, with no
         // separate class-construction path needed.
         Some(info) if !info.field_names.is_empty() => {
+            let (owner, result, mut binds) = startVariant(info, &explicit, expected);
             for fa in &call.fields {
                 match info.field_names.iter().position(|n| n == &fa.name) {
                     Some(i) => {
-                        let expected = &info.field_types[i];
+                        let pat = types::substitute(&info.field_types[i], &owner);
-                        let actual = inferExpr(&fa.value, env, ctx)?;
+                        let actual = inferExprWith(
+                            &fa.value,
+                            env,
+                            ctx,
+                            Some(&substVars(&pat, &binds)),
+                        )?;
+                        bindMatch(&pat, &actual, &mut binds);
-                        unifyArg(expected, &actual, &fa.value, ctx).map_err(|e| {
+                        unifyArg(&substVars(&pat, &binds), &actual, &fa.value, ctx).map_err(|e| {
                             format!("variant '{}' field '{}': {}", call.type_name, fa.name, e)
                         })?;
                     }
@@ -1598,7 +2009,7 @@ fn inferClassCallRaw(
                     }
                 }
             }
-            Ok(PlumType::TNamed(info.enum_name.clone()))
+            Ok(substVars(&result, &binds))
         }
         // Positional/generic-payload variant (`Next(T)`, constructed via `Expr::FnCall`
         // elsewhere instead), a payload-free variant, or an unmodeled (e.g.
@@ -1682,7 +2093,12 @@ fn checkPattern(
                         fields.len()
                     ));
                 }
+                let field_tys = if nominalName(subject_ty) == Some(info.enum_name.as_str()) {
+                    variantFields(info, subject_ty)
+                } else {
+                    variantFields(info, &PlumType::TNamed(info.enum_name.clone()))
+                };
-                for (f, fty) in fields.iter().zip(info.field_types.iter()) {
+                for (f, fty) in fields.iter().zip(field_tys.iter()) {
                     checkPattern(f, fty, env, ctx)?;
                 }
                 Ok(())
@@ -1936,12 +2352,298 @@ fn isTagLiteralName(n: &str, ctx: &CheckCtx) -> bool {
         && !ctx.methods.keys().any(|(recv, _)| recv == n)
 }
+fn argExpr(arg: &ast::Arg) -> &ast::Expr {
+    match arg {
+        ast::Arg::Positional(e) => e,
+        ast::Arg::Keyword { value, .. } => value,
+        ast::Arg::Pair { value, .. } => value,
+    }
+}
+/// Checks call `args` against the (already instantiated) `params`, binding the
+/// inference variables in `binds` as it goes. Non-closure arguments are checked
+/// first so a closure sees the types its parameters were already pinned to.
+fn checkCallArgs(
+    label: &str,
+    params: &[PlumType],
+    args: &[ast::Arg],
+    required: usize,
+    env: &TypeEnv,
+    ctx: &CheckCtx,
+    binds: &mut Binds,
+) -> Result<(), String> {
+    let (fixed, variadic) = match params.last() {
+        Some(PlumType::TVariadic(elem)) => (&params[..params.len() - 1], Some(&**elem)),
+        _ => (params, None),
+    };
+    match variadic {
+        Some(_) => {
+            if args.len() < fixed.len() {
+                return Err(format!(
+                    "{}: expected at least {} arg(s), got {}",
+                    label,
+                    fixed.len(),
+                    args.len()
+                ));
+            }
+        }
+        None => {
+            if args.len() < required || args.len() > params.len() {
+                return Err(format!(
+                    "{}: expected {} args, got {}",
+                    label,
+                    params.len(),
+                    args.len()
+                ));
+            }
+        }
+    }
+    let slots: Vec<(usize, &ast::Expr, &PlumType, bool)> = args
+        .iter()
+        .enumerate()
+        .map(|(i, a)| match fixed.get(i) {
+            Some(p) => (i, argExpr(a), p, false),
+            None => (i, argExpr(a), variadic.expect("variadic slot"), true),
+        })
+        .collect();
+    for pass in 0..2 {
+        for (i, e, pat, is_var) in &slots {
+            let is_closure = matches!(e, ast::Expr::Closure(_));
+            if (pass == 1) != is_closure {
+                continue;
+            }
+            let want = substVars(pat, binds);
+            let actual = inferExprWith(e, env, ctx, Some(&want))?;
+            bindMatch(pat, &actual, binds);
+            let want = substVars(pat, binds);
+            unifyArg(&want, &actual, e, ctx).map_err(|err| {
+                if *is_var {
+                    format!("{} variadic arg {}: {}", label, i, err)
+                } else {
+                    format!("{} arg {}: {}", label, i, err)
+                }
+            })?;
+        }
+    }
+    Ok(())
+}
+/// Type of `obj.field`, substituting a generic receiver's type arguments.
+fn fieldTypeOf(obj_ty: &PlumType, field: &str, ctx: &CheckCtx) -> Result<PlumType, String> {
+    match obj_ty {
+        PlumType::TNamed(n) => lookupFieldType(n, field, ctx),
+        PlumType::TStr => lookupFieldType("Str", field, ctx),
+        PlumType::TApp(n, args) => {
+            let raw = lookupFieldType(n, field, ctx)?;
+            let gens = enumGenericsOf(n, ctx);
+            if gens.len() == args.len() {
+                Ok(types::substitute(&raw, &appSubst(gens, args)))
+            } else {
+                Ok(raw)
+            }
+        }
+        other => Err(format!(
+            "cannot access field '{}' on non-class type {}",
+            field, other
+        )),
+    }
+}
+/// The success (`Ok`) payload and failure (`Err`) payload types of a `Try`-shaped
+/// value of type `ty`, with its type arguments substituted.
+fn tryParts(ty: &PlumType, ctx: &CheckCtx) -> Option<(PlumType, Option<PlumType>)> {
+    let name = nominalName(ty)?;
+    let (_, success, _, failure) = tryOperatorVariants(name, ctx)?;
+    let ok = variantFields(success, ty)
+        .first()
+        .cloned()
+        .unwrap_or(PlumType::TUnit);
+    let err = variantFields(failure, ty).first().cloned();
+    Some((ok, err))
+}
+fn inferMethodCall(
+    obj_ty: &PlumType,
+    call: &ast::FnCall,
+    env: &TypeEnv,
+    ctx: &CheckCtx,
+    expected: Option<&PlumType>,
+) -> Result<PlumType, String> {
+    // A method on a generic parameter resolves through its trait bounds only.
+    if let PlumType::TParam(p) = obj_ty {
+        let prefix = format!("{}{}:", BOUND_KEY, p);
+        for key in env.keys() {
+            let Some(tr) = key.strip_prefix(&prefix) else {
+                continue;
+            };
+            let Some(sch) = env.get(&format!("{}{}:{}", TRAIT_KEY, tr, call.name)) else {
+                continue;
+            };
+            if let PlumType::TFun(params, ret) = &*sch.body {
+                let mut binds = Binds::new();
+                let label = format!("method '{}.{}'", p, call.name);
+                checkCallArgs(&label, params, &call.args, params.len(), env, ctx, &mut binds)?;
+                return Ok(substVars(ret, &binds));
+            }
+        }
+        return Err(format!(
+            "'{}' has no method '{}' (add a bound)",
+            p, call.name
+        ));
+    }
+    let Some(class_name) = methodReceiverName(obj_ty) else {
+        return Ok(PlumType::TVar("_".to_string()));
+    };
+    // Fallback: a primitive/class receiver's method might be defined once on
+    // the "union" enum that bare-wraps it instead (`enum Number = | Int | Float`).
+    let class_name = if ctx
+        .methods
+        .contains_key(&(class_name.clone(), call.name.clone()))
+    {
+        class_name
+    } else {
+        ctx.enum_variants
+            .get(class_name.as_str())
+            .map(|info| info.enum_name.clone())
+            .filter(|enum_name| {
+                ctx.methods
+                    .contains_key(&(enum_name.clone(), call.name.clone()))
+            })
+            .unwrap_or(class_name)
+    };
+    let Some(sig) = ctx.methods.get(&(class_name.clone(), call.name.clone())) else {
+        // Unmodeled method (e.g. builtin/std): allow, codegen will catch.
+        return Ok(PlumType::TVar("_".to_string()));
+    };
+    let PlumType::TFun(..) = sig else {
+        return Ok(PlumType::TVar("_".to_string()));
+    };
+    let owner = match obj_ty {
+        PlumType::TApp(n, args) if *n == class_name => {
+            appSubst(enumGenericsOf(n, ctx), args)
+        }
+        _ => BTreeMap::new(),
+    };
+    let PlumType::TFun(params, ret) = instSig(sig, &owner) else {
+        unreachable!("instSig preserves the TFun shape")
+    };
+    let mut binds = Binds::new();
+    if let Some(exp) = expected {
+        bindMatch(&ret, exp, &mut binds);
+    }
+    let required = ctx
+        .min_required
+        .get(&(Some(class_name.clone()), call.name.clone()))
+        .copied()
+        .unwrap_or(params.len());
+    let label = format!("method '{}.{}'", class_name, call.name);
+    checkCallArgs(&label, &params, &call.args, required, env, ctx, &mut binds)?;
+    Ok(substVars(&ret, &binds))
+}
+/// Starts constructing a value of one of `info`'s enum: fresh owner variables
+/// (or the explicit `generics`), the result type pattern, and bindings seeded
+/// from the `expected` type.
+fn startVariant(
+    info: &EnumVariantInfo,
+    explicit: &[PlumType],
+    expected: Option<&PlumType>,
+) -> (BTreeMap<String, PlumType>, PlumType, Binds) {
+    let owner = if !explicit.is_empty() && explicit.len() == info.generics.len() {
+        appSubst(&info.generics, explicit)
+    } else {
+        freshOwner(&info.generics)
+    };
+    let result = enumTypeWith(info, &owner);
+    let mut binds = Binds::new();
+    if let Some(exp) = expected {
+        bindMatch(&result, exp, &mut binds);
+    }
+    (owner, result, binds)
+}
+/// A tag literal (`Bad` / `Bad(x)`) written where the expected type is a tag
+/// union naming it — it is the TAG even if a declared variant shares the name.
+fn expectedTagLiteral(
+    expr: &ast::Expr,
+    env: &TypeEnv,
+    ctx: &CheckCtx,
+    expected: Option<&PlumType>,
+) -> Option<Result<PlumType, String>> {
+    let Some(PlumType::TTags(tags)) = expected else {
+        return None;
+    };
+    match expr {
+        ast::Expr::TypeName(n)
+            if matches!(tags.get(n.as_str()), Some(None)) && ctx.enum_variants.contains_key(n) =>
+        {
+            Some(Ok(PlumType::TTags(BTreeMap::from([(n.clone(), None)]))))
+        }
+        ast::Expr::FnCall(call)
+            if call.args.len() == 1
+                && matches!(tags.get(call.name.as_str()), Some(Some(_)))
+                && ctx.enum_variants.contains_key(&call.name) =>
+        {
+            let payload_expected = tags.get(call.name.as_str()).and_then(|p| p.as_deref());
+            Some(
+                inferExprWith(argExpr(&call.args[0]), env, ctx, payload_expected).map(|p| {
+                    PlumType::TTags(BTreeMap::from([(
+                        call.name.clone(),
+                        Some(Box::new(p)),
+                    )]))
+                }),
+            )
+        }
+        _ => None,
+    }
+}
 pub fn inferExpr(expr: &ast::Expr, env: &TypeEnv, ctx: &CheckCtx) -> Result<PlumType, String> {
+    inferExprWith(expr, env, ctx, None)
+}
+/// Like `inferExpr`, with the type the context expects (a declared return, a
+/// parameter, a field) — used to pin down generic arguments nothing else
+/// determines (`Err(Bad)` in a `Try[Int, [Bad]]` position).
+pub fn inferExprWith(
+    expr: &ast::Expr,
+    env: &TypeEnv,
+    ctx: &CheckCtx,
+    expected: Option<&PlumType>,
+) -> Result<PlumType, String> {
+    let r = inferExprInner(expr, env, ctx, expected);
+    if let Ok(t) = &r {
+        recordType(expr, t);
+    }
+    r
+}
+fn inferExprInner(
+    expr: &ast::Expr,
+    env: &TypeEnv,
+    ctx: &CheckCtx,
+    expected: Option<&PlumType>,
+) -> Result<PlumType, String> {
+    if let Some(r) = expectedTagLiteral(expr, env, ctx, expected) {
+        return r;
+    }
     match expr {
         ast::Expr::Int(_) => Ok(PlumType::TInt),
         ast::Expr::Float(_) => Ok(PlumType::TFloat),
-        ast::Expr::String(_) => Ok(PlumType::TStr),
+        ast::Expr::String(s) => {
+            // Interpolated parts are typed for the record only; errors in them
+            // were never part of this check.
+            for part in &s.parts {
+                if let ast::StringPart::Interp(e) = part {
+                    let _ = inferExprWith(e, env, ctx, None);
+                }
+            }
+            Ok(PlumType::TStr)
+        }
-        ast::Expr::Var(name) => lookup(env, name),
+        ast::Expr::Var(name) => match env.get(name) {
+            Some(s) if !s.vars.is_empty() => Ok(instSig(&s.body, &BTreeMap::new())),
+            _ => lookup(env, name),
+        },
         ast::Expr::Self_ => lookup(env, "self"),
         // A bare `NAME` lexes as a type_identifier whenever it starts with an
         // uppercase letter — which includes every SCREAMING_CASE top-level
@@ -1952,15 +2654,12 @@ pub fn inferExpr(expr: &ast::Expr, env: &TypeEnv, ctx: &CheckCtx) -> Result<Plum
             Ok(ty) if !matches!(ty, PlumType::TVar(_)) => Ok(ty),
             _ => match ctx.enum_variants.get(n) {
                 // `Bool` normalizes to the dedicated `TBool` variant (not
-                // `TNamed("Bool")`) — `True`/`False` only resolve here at all
+                // `TNamed("Bool")`) — see the note on `unify`'s Bool arm.
-                // once `enum Bool = | True | False` (`libs/std/Bool.plum`) is
-                // actually imported, but every OTHER part of the checker AND
-                // `plum-wasm-codegen` (which reuses `inferExpr` via
-                // `inferLocalType`) still branches on the literal `TBool`
-                // variant, not a generic `TNamed` name — normalizing here
-                // keeps that working without patching every such site.
                 Some(info) if info.enum_name == "Bool" => Ok(PlumType::TBool),
+                Some(info) => {
-                Some(info) => Ok(PlumType::TNamed(info.enum_name.clone())),
+                    let (_, result, binds) = startVariant(info, &[], expected);
+                    Ok(substVars(&result, &binds))
+                }
                 None if isTagLiteralName(n, ctx) => Ok(PlumType::TTags(BTreeMap::from([(
                     tagLiteralName(n).to_string(),
                     None,
@@ -1969,35 +2668,27 @@ pub fn inferExpr(expr: &ast::Expr, env: &TypeEnv, ctx: &CheckCtx) -> Result<Plum
                 None => Ok(PlumType::TNamed(n.to_string())),
             },
         },
-        ast::Expr::Paren(inner) => inferExpr(inner, env, ctx),
+        ast::Expr::Paren(inner) => inferExprWith(inner, env, ctx, expected),
         // `expr?` — deliberately does NOT check that the enclosing function's
-        // return type actually accepts the `Err` value this can exit
+        // return type actually accepts the `Err` value beyond its error type.
-        // with early; that's left permissive here (codegen will catch a
-        // genuine mismatch as a wasm type error), consistent with this
-        // checker's existing "unmodeled/unvalidated, codegen catches it"
-        // fallbacks elsewhere (e.g. `TypeName`'s unmodeled-type-name arm
-        // above) — checking it properly would need the enclosing function's
-        // declared return type threaded through every `inferExpr` call site,
-        // for a case a wrong program still fails on, just less precisely.
         ast::Expr::Try(inner) => {
             let inner_ty = inferExpr(inner, env, ctx)?;
-            let name = match &inner_ty {
+            if nominalName(&inner_ty).is_none() {
-                PlumType::TNamed(name) => name,
-                other => return Err(format!("'?' requires a Try value, found {}", other)),
+                return Err(format!("'?' requires a Try value, found {}", inner_ty));
-            };
+            }
-            let Some((_, success_info, _, failure_info)) = tryOperatorVariants(name, ctx) else {
+            let Some((success_ty, inner_err)) = tryParts(&inner_ty, ctx) else {
+                return Err(format!(
-                return Err(format!("'?' requires a Try value, found '{}'", name));
+                    "'?' requires a Try value, found '{}'",
+                    nominalName(&inner_ty).unwrap_or("?")
+                ));
             };
             // The failure branch returns early from the enclosing fn, so the
             // inner error type must fit the fn's declared error type. Closures
             // (and test blocks) have no `$return` and aren't checked.
-            if let Some(PlumType::TNamed(outer)) = env.get(RETURN_KEY).map(|s| (*s.body).clone()) {
+            if let Some(outer_ty) = env.get(RETURN_KEY).map(|s| (*s.body).clone()) {
-                if let Some((_, _, _, outer_failure)) = tryOperatorVariants(&outer, ctx) {
+                if let Some((_, Some(outer_err))) = tryParts(&outer_ty, ctx) {
-                    if let (Some(inner_err), Some(outer_err)) = (
+                    if let Some(inner_err) = &inner_err {
-                        failure_info.field_types.first(),
-                        outer_failure.field_types.first(),
-                    ) {
-                        if unify(outer_err, inner_err, ctx).is_err() {
+                        if unify(&outer_err, inner_err, ctx).is_err() {
                             return Err(format!(
                                 "'?' error type {} is not part of the function's error type {}",
                                 inner_err, outer_err
@@ -2006,11 +2697,7 @@ pub fn inferExpr(expr: &ast::Expr, env: &TypeEnv, ctx: &CheckCtx) -> Result<Plum
                     }
                 }
             }
-            Ok(success_info
+            Ok(success_ty)
-                .field_types
-                .first()
-                .cloned()
-                .unwrap_or(PlumType::TUnit))
         }
         ast::Expr::Closure(cl) => {
             let mut closure_env = env.clone();
@@ -2027,18 +2714,32 @@ pub fn inferExpr(expr: &ast::Expr, env: &TypeEnv, ctx: &CheckCtx) -> Result<Plum
                     &mut resolved_from_usage,
                 );
             }
+            let (exp_params, exp_ret): (Option<&Vec<PlumType>>, Option<&PlumType>) = match expected
+            {
+                Some(PlumType::TFun(ps, r)) if ps.len() == cl.params.len() => {
+                    (Some(ps), Some(&**r))
+                }
+                _ => (None, None),
+            };
             let param_types: Vec<PlumType> = cl
                 .params
                 .iter()
+                .enumerate()
-                .map(|p| {
+                .map(|(i, p)| {
                     // A fresh TVar for anything not resolved below — `unify` treats an
                     // unbound TVar as a wildcard, so this is only a real problem for
                     // field access (`p.field`), which needs a concrete class name to
                     // look the field up at all; see `resolveClosureParamFromFieldUsage`.
+                    let from_expected = exp_params
+                        .and_then(|ps| ps.get(i))
+                        .filter(|t| !matches!(t, PlumType::TVar(_)))
+                        .cloned();
+                    let t = from_expected.unwrap_or_else(|| {
-                    let t = resolved_from_usage
+                        resolved_from_usage
-                        .get(p)
+                            .get(p)
-                        .cloned()
+                            .cloned()
-                        .unwrap_or_else(|| PlumType::TVar(format!("_closure_{}", p)));
+                            .unwrap_or_else(|| PlumType::TVar(format!("_closure_{}", p)))
+                    });
                     closure_env.insert(p.clone(), TypeScheme::mono(t.clone()));
                     t
                 })
@@ -2060,8 +2761,8 @@ pub fn inferExpr(expr: &ast::Expr, env: &TypeEnv, ctx: &CheckCtx) -> Result<Plum
                 }
             }
             let body_ty = match &cl.body.stmts.last() {
-                Some(ast::Stmt::Expr(e, ..)) => inferExpr(e, &closure_env, ctx)?,
+                Some(ast::Stmt::Expr(e, ..)) => inferExprWith(e, &closure_env, ctx, exp_ret)?,
-                Some(ast::Stmt::Return(Some(e))) => inferExpr(e, &closure_env, ctx)?,
+                Some(ast::Stmt::Return(Some(e))) => inferExprWith(e, &closure_env, ctx, exp_ret)?,
                 _ => PlumType::TUnit,
             };
             Ok(PlumType::TFun(param_types, Box::new(body_ty)))
@@ -2076,6 +2777,9 @@ pub fn inferExpr(expr: &ast::Expr, env: &TypeEnv, ctx: &CheckCtx) -> Result<Plum
             let lt = inferExpr(&b.left, env, ctx)?;
             let rt = inferExpr(&b.right, env, ctx)?;
             unify(&lt, &rt, ctx).map_err(|e| format!("binary op: {}", e))?;
+            if matches!(lt, PlumType::TVar(_)) && !matches!(rt, PlumType::TVar(_)) {
+                return Ok(rt);
+            }
             Ok(lt)
         }
         ast::Expr::Bool(b) => {
@@ -2104,8 +2808,8 @@ pub fn inferExpr(expr: &ast::Expr, env: &TypeEnv, ctx: &CheckCtx) -> Result<Plum
         ast::Expr::Ternary(t) => {
             let ct = inferExpr(&t.condition, env, ctx)?;
             unify(&PlumType::TBool, &ct, ctx).map_err(|e| format!("ternary condition: {}", e))?;
-            let tt = inferExpr(&t.then, env, ctx)?;
+            let tt = inferExprWith(&t.then, env, ctx, expected)?;
-            let et = inferExpr(&t.else_, env, ctx)?;
+            let et = inferExprWith(&t.else_, env, ctx, expected)?;
             unify(&tt, &et, ctx).map_err(|e| format!("ternary branches: {}", e))?;
             Ok(tt)
         }
@@ -2114,28 +2818,13 @@ pub fn inferExpr(expr: &ast::Expr, env: &TypeEnv, ctx: &CheckCtx) -> Result<Plum
         // unify with `left`'s success (`Ok`) field type.
         ast::Expr::Elvis(e) => {
             let left_ty = inferExpr(&e.left, env, ctx)?;
-            let success_ty = match &left_ty {
+            let Some(name) = nominalName(&left_ty) else {
+                return Err(format!("'??' requires a Try value, found {}", left_ty));
+            };
-                PlumType::TNamed(name) => match tryOperatorVariants(name, ctx) {
+            let Some((success_ty, _)) = tryParts(&left_ty, ctx) else {
-                    Some((_, success_info, _, _)) => success_info
-                        .field_types
-                        .first()
-                        .cloned()
-                        .unwrap_or(PlumType::TUnit),
-                    None => {
-                        return Err(format!(
-                            "'??' requires a Try value, found '{}'",
+                return Err(format!("'??' requires a Try value, found '{}'", name));
-                            name
-                        ))
-                    }
-                },
-                other => {
-                    return Err(format!(
-                        "'??' requires a Try value, found {}",
-                        other
-                    ))
-                }
             };
-            let right_ty = inferExpr(&e.right, env, ctx)?;
+            let right_ty = inferExprWith(&e.right, env, ctx, Some(&success_ty))?;
             unify(&success_ty, &right_ty, ctx).map_err(|e| format!("'??' branches: {}", e))?;
             Ok(success_ty)
         }
@@ -2147,21 +2836,12 @@ pub fn inferExpr(expr: &ast::Expr, env: &TypeEnv, ctx: &CheckCtx) -> Result<Plum
             // registered enum variant (a "union" enum's bare-primitive-wrap
             // variant, e.g. `enum Number = | Int | Float`) whose single
             // field type exactly matches the arg's own type — a same-type
-            // call (`Int(intExpr)`) then means constructing that variant
+            // call (`Int(intExpr)`) then means constructing that variant,
-            // (`monomorphize::wrapPrimitiveAgainstExpected` synthesizes
-            // exactly this call shape), not a no-op cast; falls through to
-            // the ordinary enum-variant-construction handling just below
-            // instead. A genuinely cross-type call (`Int(floatExpr)`) is
-            // never ambiguous this way, so every existing numeric-cast call
-            // site keeps its normal meaning.
+            // not a no-op cast.
             if (call.name == "Int" || call.name == "Float" || call.name == "Byte")
                 && call.args.len() == 1
             {
-                let arg_expr = match &call.args[0] {
+                let arg_expr = argExpr(&call.args[0]);
-                    ast::Arg::Positional(e) => e,
-                    ast::Arg::Keyword { value, .. } => value,
-                    ast::Arg::Pair { value, .. } => value,
-                };
                 let actual = inferExpr(arg_expr, env, ctx)?;
                 let is_same_type_variant_wrap = ctx
                     .enum_variants
@@ -2180,26 +2860,11 @@ pub fn inferExpr(expr: &ast::Expr, env: &TypeEnv, ctx: &CheckCtx) -> Result<Plum
                         )),
                     };
                 }
-                // Else: fall through to the ordinary enum-variant-construction
-                // handling just below, exactly as if this special case didn't
-                // exist for this call.
             }
             // `Type(1, 2, 3)` — a call with bare POSITIONAL args on a record-shaped
-            // type's name (as opposed to `Type(field: value, ...)`, which parses as a
-            // `ClassCall` instead — see `class_argument_list` vs `fn_argument_list` in
-            // the grammar) — is sugar for `Type.init(1, 2, 3)`, the same constructor
+            // type's name is sugar for `Type.init(1, 2, 3)` (see the `ClassCall`
-            // pattern as `Type()`'s own `ClassCall` handling above, letting `init`
-            // take real params (e.g. `List`'s own variadic `init(values: ...T)`)
-            // instead of being limited to zero args. Checked BEFORE the ordinary
+            // zero-arg `Type()` handling); checked BEFORE the ordinary
-            // positional-variant-construction case just below: a record-shaped
+            // positional-variant-construction case just below.
-            // enum's own name is ALSO its one variant's name (see
-            // `buildGlobalTables`), so without this ordering a call meant as
-            // `List.init(1, 2, 3)` could instead misfire as "construct the List
-            // variant positionally" whenever the arg count happens to match its
-            // real field count — a record-shaped type never supported positional
-            // field construction via bare `Type(...)` even before enums/classes
-            // merged into one representation, only through `init` or the named
-            // `Type(field: value, ...)` form.
             if ctx
                 .enum_variants
                 .get(&call.name)
@@ -2215,7 +2880,7 @@ pub fn inferExpr(expr: &ast::Expr, env: &TypeEnv, ctx: &CheckCtx) -> Result<Plum
                         args: call.args.clone(),
                     }),
                 }));
-                return inferExpr(&synthetic, env, ctx);
+                return inferExprWith(&synthetic, env, ctx, expected);
             }
             if let Some(info) = ctx.enum_variants.get(&call.name) {
                 if call.args.len() != info.field_types.len() {
@@ -2226,121 +2891,51 @@ pub fn inferExpr(expr: &ast::Expr, env: &TypeEnv, ctx: &CheckCtx) -> Result<Plum
                         call.args.len()
                     ));
                 }
-                for (i, (arg, expected)) in
+                let (owner, result, mut binds) = startVariant(info, &[], expected);
-                    call.args.iter().zip(info.field_types.iter()).enumerate()
+                for (i, (arg, field)) in call.args.iter().zip(info.field_types.iter()).enumerate() {
-                {
-                    let arg_expr = match arg {
+                    let arg_expr = argExpr(arg);
-                        ast::Arg::Positional(e) => e,
-                        ast::Arg::Keyword { value, .. } => value,
+                    let pat = types::substitute(field, &owner);
-                        ast::Arg::Pair { value, .. } => value,
-                    };
-                    // A bare-type variant's own payload (`FantasyBook(FantasyBook(...))`,
+                    // A bare-type variant's own payload (`FantasyBook(FantasyBook(...))`)
-                    // whether hand-written or produced by desugaring `FantasyBook(...)`
-                    // sugar) infers via the RAW class-field rules — not the
+                    // infers via the RAW class-field rules — see `inferClassCallRaw`.
-                    // enum-wrapping `inferExpr` would otherwise apply to a
-                    // `ClassCall` of that same name — so it unifies against
-                    // `expected` (the bare class type), not the enum itself.
-                    let actual = match (expected, arg_expr) {
+                    let actual = match (&pat, arg_expr) {
                         (PlumType::TNamed(n), ast::Expr::ClassCall(c))
                             if n == &call.name && c.type_name == call.name =>
                         {
-                            inferClassCallRaw(c, env, ctx)?
+                            inferClassCallRaw(c, env, ctx, None)?
                         }
-                        _ => inferExpr(arg_expr, env, ctx)?,
+                        _ => inferExprWith(arg_expr, env, ctx, Some(&substVars(&pat, &binds)))?,
                     };
+                    bindMatch(&pat, &actual, &mut binds);
-                    unifyArg(expected, &actual, arg_expr, ctx)
+                    unifyArg(&substVars(&pat, &binds), &actual, arg_expr, ctx)
                         .map_err(|e| format!("variant '{}' arg {}: {}", call.name, i, e))?;
                 }
-                return Ok(PlumType::TNamed(info.enum_name.clone()));
+                return Ok(substVars(&result, &binds));
             }
+            let callee = match env.get(&call.name) {
+                Some(s) if !s.vars.is_empty() => Ok(instSig(&s.body, &BTreeMap::new())),
-            match lookup(env, &call.name) {
+                _ => lookup(env, &call.name),
+            };
+            match callee {
                 Ok(PlumType::TFun(param_types, ret)) => {
-                    match param_types.last() {
+                    let mut binds = Binds::new();
-                        Some(PlumType::TVariadic(elem)) => {
-                            let fixed = &param_types[..param_types.len() - 1];
-                            if call.args.len() < fixed.len() {
-                                return Err(format!(
-                                    "call '{}': expected at least {} arg(s), got {}",
-                                    call.name,
-                                    fixed.len(),
-                                    call.args.len()
-                                ));
-                            }
-                            for (i, (arg, expected)) in
-                                call.args.iter().zip(fixed.iter()).enumerate()
-                            {
-                                let arg_expr = match arg {
+                    if let Some(exp) = expected {
-                                    ast::Arg::Positional(e) => e,
-                                    ast::Arg::Keyword { value, .. } => value,
-                                    ast::Arg::Pair { value, .. } => value,
-                                };
-                                let actual = inferExpr(arg_expr, env, ctx)?;
-                                unifyArg(expected, &actual, arg_expr, ctx).map_err(|e| {
-                                    format!("call '{}' arg {}: {}", call.name, i, e)
-                                })?;
-                            }
-                            for (i, arg) in call.args.iter().enumerate().skip(fixed.len()) {
-                                let arg_expr = match arg {
-                                    ast::Arg::Positional(e) => e,
-                                    ast::Arg::Keyword { value, .. } => value,
-                                    ast::Arg::Pair { value, .. } => value,
-                                };
-                                let actual = inferExpr(arg_expr, env, ctx)?;
-                                unifyArg(elem, &actual, arg_expr, ctx).map_err(|e| {
-                                    format!("call '{}' variadic arg {}: {}", call.name, i, e)
-                                })?;
-                            }
-                            Ok(*ret)
-                        }
-                        _ => {
-                            // Fewer args than params is fine as long as every
-                            // OMITTED one (always the trailing ones — see
-                            // `MinRequiredArgs`'s doc comment) has a declared
-                            // default; codegen fills those in from their own
-                            // default expression at the call site.
-                            let required = ctx
-                                .min_required
-                                .get(&(None, call.name.clone()))
+                        bindMatch(&ret, exp, &mut binds);
-                                .copied()
-                                .unwrap_or(param_types.len());
-                            if call.args.len() < required || call.args.len() > param_types.len() {
-                                return Err(format!(
-                                    "call '{}': expected {} args, got {}",
-                                    call.name,
-                                    param_types.len(),
-                                    call.args.len()
-                                ));
-                            }
-                            for (i, (arg, expected)) in
-                                call.args.iter().zip(param_types.iter()).enumerate()
-                            {
-                                let arg_expr = match arg {
-                                    ast::Arg::Positional(e) => e,
-                                    ast::Arg::Keyword { value, .. } => value,
-                                    ast::Arg::Pair { value, .. } => value,
-                                };
-                                let actual = inferExpr(arg_expr, env, ctx)?;
-                                unifyArg(expected, &actual, arg_expr, ctx).map_err(|e| {
-                                    format!("call '{}' arg {}: {}", call.name, i, e)
-                                })?;
-                            }
-                            Ok(*ret)
-                        }
                     }
+                    let required = ctx
+                        .min_required
+                        .get(&(None, call.name.clone()))
+                        .copied()
+                        .unwrap_or(param_types.len());
+                    let label = format!("call '{}'", call.name);
+                    checkCallArgs(&label, &param_types, &call.args, required, env, ctx, &mut binds)?;
+                    Ok(substVars(&ret, &binds))
                 }
                 Ok(_) => Err(format!("'{}' is not a function", call.name)),
                 Err(_) if isTagLiteralName(&call.name, ctx) && call.args.len() <= 1 => {
                     // `Bad(x)` — an undeclared uppercase name applied to one arg is
                     // a tag literal with a payload.
                     let payload = match call.args.first() {
-                        Some(arg) => {
-                            let arg_expr = match arg {
-                                ast::Arg::Positional(e) => e,
-                                ast::Arg::Keyword { value, .. } => value,
-                                ast::Arg::Pair { value, .. } => value,
-                            };
-                            Some(Box::new(inferExpr(arg_expr, env, ctx)?))
+                        Some(arg) => Some(Box::new(inferExpr(argExpr(arg), env, ctx)?)),
-                        }
                         None => None,
                     };
                     Ok(PlumType::TTags(BTreeMap::from([(
@@ -2358,7 +2953,7 @@ pub fn inferExpr(expr: &ast::Expr, env: &TypeEnv, ctx: &CheckCtx) -> Result<Plum
             }
         }
         ast::Expr::ClassCall(call) => {
-            let bare = inferClassCallRaw(call, env, ctx)?;
+            let bare = inferClassCallRaw(call, env, ctx, expected)?;
             Ok(match bare {
                 PlumType::TNamed(n) => bareVariantWrapType(&n, ctx),
                 other => other,
@@ -2368,157 +2963,20 @@ pub fn inferExpr(expr: &ast::Expr, env: &TypeEnv, ctx: &CheckCtx) -> Result<Plum
             let obj_ty = inferExpr(&attr.object, env, ctx)?;
             match &attr.attr {
                 ast::AttrKind::Field(field_name) => match &obj_ty {
-                    // `Str` is an ordinary class (`type Str(...) = data: Buffer
+                    // `Str` is an ordinary class with a real field; a generic
-                    // ...` in `str.plum`) with a real field, unlike historically
-                    // (see the `other` hard-error arm's comment below) — resolve
+                    // class substitutes its receiver's type arguments.
-                    // it the same way `TNamed` does, just keyed by the literal
-                    // name "Str" since `TStr` itself carries no name.
-                    PlumType::TNamed(_) | PlumType::TStr => {
+                    PlumType::TNamed(_) | PlumType::TStr | PlumType::TApp(..) => {
-                        let class_name: &str = match &obj_ty {
-                            PlumType::TNamed(n) => n.as_str(),
-                            _ => "Str",
-                        };
-                        lookupFieldType(class_name, field_name, ctx)
+                        fieldTypeOf(&obj_ty, field_name, ctx)
                     }
-                    // An unresolved generic method return (e.g. `Try[T, E].unwrap()`'s
+                    // An unresolved generic return reaches here as a plain `TVar`;
-                    // bare `T`, which this checker's `PlumType` erases entirely — see
-                    // `types.rs`'s `TNamed` having no type-argument slot) reaches here as
-                    // a plain `TVar`, not a real "wrong type". Field access on it is
-                    // "unmodeled" the same way an unknown enum's fields already are just
-                    // above (`ctx.enum_params.get` returning `None`) — allow it and let
-                    // codegen (which DOES track concrete monomorphized types) catch a
+                    // field access on it is unmodeled — allow, codegen will catch.
-                    // genuine mismatch. Only a definitely-wrong concrete type (`Int`,
-                    // `Str`, ...) still hard-errors here.
                     PlumType::TVar(_) => Ok(PlumType::TVar("_".to_string())),
                     other => Err(format!(
                         "cannot access field '{}' on non-class type {}",
                         field_name, other
                     )),
                 },
-                ast::AttrKind::Method(call) => {
+                ast::AttrKind::Method(call) => inferMethodCall(&obj_ty, call, env, ctx, expected),
-                    match methodReceiverName(&obj_ty) {
-                        Some(class_name) => {
-                            // Fallback: a primitive/class receiver's method might be
-                            // defined once on the "union" enum that bare-wraps it
-                            // instead (`enum Number = | Int | Float`) — `class_name`
-                            // (e.g. "Int") is itself a registered enum-variant name
-                            // in that case (see `buildGlobalTables`'s bare-wrap
-                            // conditions); retry there before falling through to the
-                            // permissive "unmodeled method" case below. Mirrors
-                            // `plum-wasm-codegen`'s equivalent dispatch fallback,
-                            // which also boxes `self` into the wrap-enum's variant.
-                            let class_name = if ctx
-                                .methods
-                                .contains_key(&(class_name.clone(), call.name.clone()))
-                            {
-                                class_name
-                            } else {
-                                ctx.enum_variants
-                                    .get(class_name.as_str())
-                                    .map(|info| info.enum_name.clone())
-                                    .filter(|enum_name| {
-                                        ctx.methods
-                                            .contains_key(&(enum_name.clone(), call.name.clone()))
-                                    })
-                                    .unwrap_or(class_name)
-                            };
-                            match ctx.methods.get(&(class_name.clone(), call.name.clone())) {
-                                Some(PlumType::TFun(param_types, ret)) => {
-                                    match param_types.last() {
-                                        Some(PlumType::TVariadic(elem)) => {
-                                            let fixed = &param_types[..param_types.len() - 1];
-                                            if call.args.len() < fixed.len() {
-                                                return Err(format!(
-                                            "method '{}.{}': expected at least {} arg(s), got {}",
-                                            class_name, call.name, fixed.len(), call.args.len()
-                                        ));
-                                            }
-                                            for (i, (arg, expected)) in
-                                                call.args.iter().zip(fixed.iter()).enumerate()
-                                            {
-                                                let arg_expr = match arg {
-                                                    ast::Arg::Positional(e) => e,
-                                                    ast::Arg::Keyword { value, .. } => value,
-                                                    ast::Arg::Pair { value, .. } => value,
-                                                };
-                                                let actual = inferExpr(arg_expr, env, ctx)?;
-                                                unifyArg(expected, &actual, arg_expr, ctx)
-                                                    .map_err(|e| {
-                                                        format!(
-                                                            "method '{}.{}' arg {}: {}",
-                                                            class_name, call.name, i, e
-                                                        )
-                                                    })?;
-                                            }
-                                            for (i, arg) in
-                                                call.args.iter().enumerate().skip(fixed.len())
-                                            {
-                                                let arg_expr = match arg {
-                                                    ast::Arg::Positional(e) => e,
-                                                    ast::Arg::Keyword { value, .. } => value,
-                                                    ast::Arg::Pair { value, .. } => value,
-                                                };
-                                                let actual = inferExpr(arg_expr, env, ctx)?;
-                                                unifyArg(elem, &actual, arg_expr, ctx).map_err(
-                                                    |e| {
-                                                        format!(
-                                                            "method '{}.{}' variadic arg {}: {}",
-                                                            class_name, call.name, i, e
-                                                        )
-                                                    },
-                                                )?;
-                                            }
-                                            Ok(*ret.clone())
-                                        }
-                                        _ => {
-                                            // See the matching comment on the free-function
-                                            // arm above — fewer args than params is fine as
-                                            // long as every omitted (trailing) one has a
-                                            // declared default.
-                                            let required = ctx
-                                                .min_required
-                                                .get(&(Some(class_name.clone()), call.name.clone()))
-                                                .copied()
-                                                .unwrap_or(param_types.len());
-                                            if call.args.len() < required
-                                                || call.args.len() > param_types.len()
-                                            {
-                                                return Err(format!(
-                                                    "method '{}.{}': expected {} args, got {}",
-                                                    class_name,
-                                                    call.name,
-                                                    param_types.len(),
-                                                    call.args.len()
-                                                ));
-                                            }
-                                            for (i, (arg, expected)) in
-                                                call.args.iter().zip(param_types.iter()).enumerate()
-                                            {
-                                                let arg_expr = match arg {
-                                                    ast::Arg::Positional(e) => e,
-                                                    ast::Arg::Keyword { value, .. } => value,
-                                                    ast::Arg::Pair { value, .. } => value,
-                                                };
-                                                let actual = inferExpr(arg_expr, env, ctx)?;
-                                                unifyArg(expected, &actual, arg_expr, ctx)
-                                                    .map_err(|e| {
-                                                        format!(
-                                                            "method '{}.{}' arg {}: {}",
-                                                            class_name, call.name, i, e
-                                                        )
-                                                    })?;
-                                            }
-                                            Ok(*ret.clone())
-                                        }
-                                    }
-                                }
-                                // Unmodeled method (e.g. builtin/std): allow, codegen will catch.
-                                _ => Ok(PlumType::TVar("_".to_string())),
-                            }
-                        }
-                        None => Ok(PlumType::TVar("_".to_string())),
-                    }
-                }
             }
         }
     }

plum-checker/src/monomorphize.rs CHANGED Viewed

@@ -2354,6 +2354,7 @@ impl<'a> Monomorphizer<'a> {
                         field_types,
                         field_names: v.field_names.clone(),
                         values: v.values.clone(),
+                        generics: Vec::new(),
                     },
                 );
             }
@@ -3100,6 +3101,7 @@ pub fn monomorphizeSource(source: &ast::Source) -> Result<ast::Source, String> {
                             field_types,
                             field_names,
                             values: v.values.clone(),
+                            generics: Vec::new(),
                         },
                     );
                 }

plum-checker/tests/checker_tests.rs CHANGED Viewed

@@ -2,7 +2,7 @@
 use plum_checker::types::*;
 use plum_checker::{
     checkSource, erasedEnumName, plumTypeFromAst, plumTypeFromName, tagUnionSegmentsCompatible,
-    unify, CheckCtx,
+    typedSource, unify, CheckCtx,
 };
 use plum_core::ast::Type as AstType;
 use plum_core::{ast::*, AstParser};
@@ -1749,12 +1749,12 @@ fun main() -> Int =
 #[test]
 fn unpinnedOkIsNotATagLiteral() {
+    // Structural generics: `Ok(3)` with nothing pinning `E` is a `Try[Int, ?]`
-    // (needs some concrete `Try` specialization to exist, as in any real
+    // (the unresolved `E` stays open), never a tag literal named `Ok`.
-    // program importing std/Try; with none, the checker can't tell `Ok` from a tag)
     let r = checkTry("fun one() -> Try[Int, [Nope]] =\n  Ok(1)\n\nfun main() =\n  x := Ok(3)\n");
-    let msg = errText(r);
-    assert!(msg.contains("cannot infer the type parameters of 'Ok'"), "{}", msg);
-    assert!(!msg.contains("[Ok("), "{}", msg);
+    assert!(r.is_ok(), "{:?}", r.err());
+    let bad = checkTry("fun f() -> Try[Str, [Nope]] =\n  Ok(1)\n");
+    assert!(errText(bad).contains("variant 'Ok' arg 0"), "pinned T still checked");
 }
 #[test]
@@ -1959,3 +1959,208 @@ fun f(s: Step) -> Int =
     let r = errText(enumMatch(def, "    ReadMin => 1\n"));
     assert!(r.contains("non-exhaustive match on Step: missing ReadMax"), "got: {}", r);
 }
+fn repoRoot() -> std::path::PathBuf {
+    std::path::Path::new(env!("CARGO_MANIFEST_DIR")).join("..")
+}
+/// Acceptance: every std and example file checks with zero errors on the
+/// ORIGINAL (un-monomorphized) source.
+#[test]
+fn everyStdAndExampleChecksStructurally() {
+    let mut failures: Vec<String> = Vec::new();
+    for dir in ["plum-std", "plum-examples"] {
+        let mut files: Vec<_> = std::fs::read_dir(repoRoot().join(dir))
+            .unwrap()
+            .filter_map(|e| e.ok())
+            .map(|e| e.path())
+            .filter(|p| p.extension().and_then(|e| e.to_str()) == Some("plum"))
+            .collect();
+        files.sort();
+        for path in files {
+            let source = plum_core::loadAndMerge(&path, &repoRoot())
+                .unwrap_or_else(|e| panic!("failed to load {}: {}", path.display(), e));
+            if let Err(errs) = checkSource(&source) {
+                for e in errs {
+                    failures.push(format!(
+                        "{}: {}",
+                        path.file_name().unwrap().to_string_lossy(),
+                        e.message
+                    ));
+                }
+            }
+        }
+    }
+    assert!(failures.is_empty(), "structural check errors:\n{}", failures.join("\n"));
+}
+// ---- structural generics (T2) ----
+const GENERIC_DEFS: &str = "\
+enum Try[T, E] =
+  | Ok(T)
+  | Err(E)
+enum List[T] =
+  | List(items: T)
+  fun map(self, cb: fn(T) -> U) -> List[U] =
+    List(items: cb(self.items))
+enum Box[T] =
+  | Box(value: T)
+";
+fn tapp(name: &str, args: Vec<PlumType>) -> PlumType {
+    PlumType::TApp(name.to_string(), args)
+}
+fn tagsA() -> PlumType {
+    PlumType::TTags(std::collections::BTreeMap::from([("A".to_string(), None)]))
+}
+/// The instantiated type of the body expression of the LAST fn in `src`.
+fn lastFnBodyType(src: &str) -> PlumType {
+    let source = parseClean(&format!("{}{}", GENERIC_DEFS, src));
+    let info = typedSource(&source).unwrap_or_else(|e| {
+        panic!(
+            "unexpected errors: {:?}",
+            e.iter().map(|x| x.message.clone()).collect::<Vec<_>>()
+        )
+    });
+    let f = source
+        .items
+        .iter()
+        .rev()
+        .find_map(|i| match i {
+            Item::Fn(f) => Some(f),
+            _ => None,
+        })
+        .unwrap();
+    let e = match &f.body {
+        FnBody::Expr(e) => e,
+        FnBody::Block(b) => match b.stmts.last() {
+            Some(Stmt::Expr(e, ..)) => e,
+            _ => panic!("no tail expression"),
+        },
+        _ => panic!("no body"),
+    };
+    info.expr_types
+        .get(&(e as *const Expr as usize))
+        .cloned()
+        .expect("body expression has a recorded type")
+}
+#[test]
+fn method_own_generic_instantiated_per_call() {
+    assert_eq!(
+        lastFnBodyType("fun f(xs: List[Int]) -> List[Int] =\n  xs.map(|n| n * 2)\n"),
+        tapp("List", vec![PlumType::TInt])
+    );
+    assert_eq!(
+        lastFnBodyType("fun f(xs: List[Int]) -> List[Str] =\n  xs.map(|n| \"{n}\")\n"),
+        tapp("List", vec![PlumType::TStr])
+    );
+    // The two instantiations are independent: Str result where Int is declared is an error.
+    let bad = checkSource(&parseClean(&format!(
+        "{}fun f(xs: List[Int]) -> List[Int] =\n  xs.map(|n| \"{{n}}\")\n",
+        GENERIC_DEFS
+    )));
+    assert!(errText(bad).contains("type mismatch"));
+}
+#[test]
+fn nested_generic_field() {
+    let tryIntA = tapp("Try", vec![PlumType::TInt, tagsA()]);
+    assert_eq!(
+        lastFnBodyType("fun f(b: Box[Try[Int, [A]]]) -> Try[Int, [A]] =\n  b.value\n"),
+        tryIntA
+    );
+}
+#[test]
+fn unbounded_tparam_method_error() {
+    let r = checkSource(&parseClean("fun f(x: T) -> Int =\n  x.hash()\n"));
+    assert!(
+        errText(r).contains("'T' has no method 'hash' (add a bound)"),
+        "unbounded T must not resolve methods"
+    );
+}
+#[test]
+fn bounded_ok() {
+    let src = "\
+trait Hashable =
+  hash() -> Int
+enum Keyed[T: Hashable] =
+  | Keyed(value: T)
+  fun h(self) -> Int =
+    self.value.hash()
+";
+    let r = checkSource(&parseClean(src));
+    assert!(r.is_ok(), "got {:?}", r.err());
+}
+#[test]
+fn tags_covariant_in_tapp() {
+    let defs = "\
+fun wide(t: Try[Int, [A, B]]) -> Int =
+  1
+fun narrow() -> Try[Int, [A]] =
+  Err(A)
+fun ok() -> Int =
+  wide(narrow())
+";
+    let r = checkSource(&parseClean(&format!("{}{}", GENERIC_DEFS, defs)));
+    assert!(r.is_ok(), "got {:?}", r.err());
+    // ...but not the other way around.
+    let rev = "\
+fun narrow(t: Try[Int, [A]]) -> Int =
+  1
+fun wide() -> Try[Int, [A, B]] =
+  Err(A)
+fun bad() -> Int =
+  narrow(wide())
+";
+    let r = checkSource(&parseClean(&format!("{}{}", GENERIC_DEFS, rev)));
+    assert!(r.is_err());
+}
+#[test]
+fn typed_source_records_every_instantiated_expr() {
+    let source = parseClean(&format!(
+        "{}fun f() -> Try[Int, [A]] =\n  Ok(1)\n",
+        GENERIC_DEFS
+    ));
+    let info = typedSource(&source).unwrap();
+    assert!(!info.expr_types.is_empty());
+    assert_eq!(
+        lastFnBodyType("fun f() -> Try[Int, [A]] =\n  Ok(1)\n"),
+        tapp("Try", vec![PlumType::TInt, tagsA()])
+    );
+}
+#[test]
+fn generic_free_fn_instantiated_per_call() {
+    let defs = "\
+fun identity(value: T) -> T =
+  value
+fun a() -> Int =
+  identity(5)
+fun b() -> Str =
+  identity(\"x\")
+";
+    assert!(checkSource(&parseClean(&format!("{}{}", GENERIC_DEFS, defs))).is_ok());
+    let bad = "fun identity(value: T) -> T =\n  value\n\nfun a() -> Str =\n  identity(5)\n";
+    assert!(checkSource(&parseClean(bad)).is_err());
+}