a261b90 | plum | pyrossh

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

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

a261b90 — Peter John 2026-10-26T11:15:58+05:30

feat(checker): duck-typed generics checked per instantiation

Files changed (5) hide show

plum-checker/src/lib.rs +388 -18
plum-checker/src/types.rs +1 -1
plum-checker/tests/checker_tests.rs +86 -7
plum-core/src/loader.rs +0 -28
plum-wasm-codegen/src/lib.rs +13 -2

plum-checker/src/lib.rs CHANGED Viewed

@@ -15,13 +15,78 @@ thread_local! {
     /// When set, `inferExprWith` records every expression's type here (see `typedSource`).
     static RECORD_BINDS: RefCell<Option<Binds>> = const { RefCell::new(None) };
     static RECORD: RefCell<Option<HashMap<usize, PlumType>>> = const { RefCell::new(None) };
+    /// Generic-call sites seen while checking one body (see `CallSite`); `None` outside `checkSourceInner`.
+    static CALLS: RefCell<Option<Vec<CallSite>>> = const { RefCell::new(None) };
+    /// While checking a generic body for one instantiation: its generic parameter -> concrete type.
+    static TSUBST: RefCell<Option<BTreeMap<String, PlumType>>> = const { RefCell::new(None) };
+    /// True while checking an instantiated generic body (method lookups on declared types are strict).
+    static INST_MODE: Cell<bool> = const { Cell::new(false) };
+    /// Line of the declaration currently being checked (the "called at" line of recorded calls).
+    static CUR_LINE: Cell<usize> = const { Cell::new(0) };
+}
+/// A call to a generic fn/method seen in some body: callee identity plus the
+/// (possibly still unresolved) type bound to each of its generic parameters.
+#[derive(Debug, Clone)]
+struct CallSite {
+    recv: Option<String>,
+    name: String,
+    args: BTreeMap<String, PlumType>,
+    line: usize,
+}
+fn recordCall(recv: Option<&str>, name: &str, args: BTreeMap<String, PlumType>) {
+    if args.is_empty() {
+        return;
+    }
+    CALLS.with(|c| {
+        if let Some(v) = c.borrow_mut().as_mut() {
+            v.push(CallSite {
+                recv: recv.map(|r| r.to_string()),
+                name: name.to_string(),
+                args,
+                line: CUR_LINE.with(|l| l.get()),
+            });
+        }
+    });
 }
 /// Per-expression instantiated types of a checked source, for codegen.
+///
+/// Generic bodies are checked per concrete instantiation (Zig-style duck
+/// typing). The data for codegen is:
+/// * `expr_types`: types from the generic-erased (TParam) pass, as before;
+/// * `instantiations`: every `(item, type args)` pair reached from a root
+///   (non-generic fns, tests), in discovery order; `Instantiation::id` is the
+///   index into this vector (so one wasm fn per entry can be emitted);
+/// * `inst_expr_types`: `(instantiation id, expr address)` -> that expression's
+///   type inside the instantiated body, generics substituted;
+/// * `inst_index`: `(item path, type args)` -> instantiation id.
 #[derive(Debug, Clone, Default)]
 pub struct TypedInfo {
     /// Expression address (`&ast::Expr as *const _ as usize`) -> its type.
     pub expr_types: HashMap<usize, PlumType>,
+    pub instantiations: Vec<Instantiation>,
+    pub inst_expr_types: HashMap<(usize, usize), PlumType>,
+    pub inst_index: HashMap<(String, Vec<PlumType>), usize>,
+}
+/// One reached instantiation of a generic fn or method of a generic type.
+#[derive(Debug, Clone, PartialEq)]
+pub struct Instantiation {
+    pub id: usize,
+    /// Item path: `"max"` for a free fn, `"List.map"` for a method.
+    pub item: String,
+    pub receiver: Option<String>,
+    pub name: String,
+    /// Generic parameter names: the owner type's generics first, then the fn's own.
+    pub generics: Vec<String>,
+    /// Concrete type per entry of `generics`.
+    pub type_args: Vec<PlumType>,
+    /// Instantiation whose body first called this one (`None` = a root).
+    pub parent: Option<usize>,
+    /// Declaration line of the calling root/instantiation.
+    pub called_at_line: usize,
 }
 /// Both operands of a binary/compare operator have the same type, so an
@@ -120,6 +185,14 @@ fn freeTParams(ty: &PlumType, out: &mut Vec<String>) {
 /// 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 {
+    instSigMap(sig, owner).0
+}
+/// `instSig`, also returning the generic-parameter -> type map it used.
+fn instSigMap(
+    sig: &PlumType,
+    owner: &BTreeMap<String, PlumType>,
+) -> (PlumType, BTreeMap<String, PlumType>) {
     let mut names = Vec::new();
     freeTParams(sig, &mut names);
     let map: BTreeMap<String, PlumType> = names
@@ -129,7 +202,7 @@ fn instSig(sig: &PlumType, owner: &BTreeMap<String, PlumType>) -> PlumType {
             (n, t)
         })
         .collect();
-    types::substitute(sig, &map)
+    (types::substitute(sig, &map), map)
 }
 /// One-way matching: binds the inference variables of `pattern` from `actual`.
@@ -221,6 +294,9 @@ pub fn plumTypeFromAstG(ty: &ast::Type) -> PlumType {
         );
     }
     if isGenericName(&ty.name) {
+        if let Some(t) = TSUBST.with(|s| s.borrow().as_ref().and_then(|m| m.get(&ty.name).cloned())) {
+            return t;
+        }
         return PlumType::TParam(ty.name.clone());
     }
     plumTypeFromName(&ty.name)
@@ -907,9 +983,59 @@ pub fn buildGlobalTables(source: &ast::Source) -> (TypeEnv, MethodEnv, EnumVaria
         }
     }
+    // `Bool.toStr` is a compiler builtin (see `builtinBoolToStr`); it is visible as a
+    // method (trait conformance, dyn dispatch) once `Str` is in the program.
+    if hasStr(source) {
+        methods
+            .entry(("Bool".to_string(), "toStr".to_string()))
+            .or_insert_with(|| PlumType::TFun(Vec::new(), Box::new(PlumType::TStr)));
+    }
     (global_env, methods, enum_variants, enum_params)
 }
+fn hasStr(source: &ast::Source) -> bool {
+    source
+        .items
+        .iter()
+        .any(|i| matches!(i, ast::Item::Enum(e) if e.name == "Str"))
+}
+/// True if `source` should get the builtin `Bool.toStr` (it returns `Str`, and
+/// the user has not defined their own).
+pub fn needsBuiltinBoolToStr(source: &ast::Source) -> bool {
+    hasStr(source)
+        && !source.items.iter().any(|i| {
+            matches!(i, ast::Item::Fn(f) if f.name == "toStr" && f.type_param.as_deref() == Some("Bool"))
+        })
+}
+/// The builtin `Bool.toStr` as an ordinary method AST (`self ? "True" : "False"`),
+/// for codegen to compile as one wasm function. Nothing is added to the source.
+pub fn builtinBoolToStr() -> ast::Fn {
+    let lit = |t: &str| {
+        ast::Expr::String(ast::StringExpr {
+            parts: vec![ast::StringPart::Text(t.to_string())],
+        })
+    };
+    ast::Fn {
+        name: "toStr".to_string(),
+        line: 0,
+        column: 0,
+        type_param: Some("Bool".to_string()),
+        is_extern: false,
+        params: Vec::new(),
+        returns: Some(ast::Type {
+            name: "Str".to_string(),
+            generics: Vec::new(),
+        }),
+        body: ast::FnBody::Expr(ast::Expr::Ternary(Box::new(ast::TernaryExpr {
+            condition: ast::Expr::Self_,
+            then: lit("True"),
+            else_: lit("False"),
+        }))),
+    }
+}
 /// A `Type`'s name for comparison purposes only — deliberately ignores `.generics`
 /// entirely (on both sides), so a trait's bare return/param type (`cause() ->
 /// Link`, unable to name a concrete payload since a trait has no instance to
@@ -1019,26 +1145,35 @@ fn checkTraitConformance(source: &ast::Source) -> Vec<CheckError> {
 }
 pub fn checkSource(source: &ast::Source) -> CheckResult<()> {
-    checkSourceInner(source)
+    checkSourceFull(source).0
 }
 /// Type-checks the original source like `checkSource` and also returns the
-/// instantiated type of every expression (keyed by expression address) for codegen.
+/// instantiated type of every expression (keyed by expression address) and the
+/// set of generic instantiations (see `TypedInfo`) for codegen.
 pub fn typedSource(source: &ast::Source) -> CheckResult<TypedInfo> {
+    let (result, info) = checkSourceFull(source);
+    result.map(|()| info)
+}
+fn checkSourceFull(source: &ast::Source) -> (CheckResult<()>, TypedInfo) {
     RECORD.with(|r| *r.borrow_mut() = Some(HashMap::new()));
     RECORD_BINDS.with(|r| *r.borrow_mut() = Some(Binds::new()));
+    CALLS.with(|r| *r.borrow_mut() = Some(Vec::new()));
-    let result = checkSourceInner(source);
+    let (result, mut info) = checkSourceInner(source);
     let mut recorded = RECORD.with(|r| r.borrow_mut().take()).unwrap_or_default();
     let binds = RECORD_BINDS.with(|r| r.borrow_mut().take()).unwrap_or_default();
+    CALLS.with(|r| r.borrow_mut().take());
+    TSUBST.with(|s| *s.borrow_mut() = None);
+    INST_MODE.with(|m| m.set(false));
     // Zonk: apply the final substitution; a variable nothing ever constrained
     // (an unused `None`, an empty literal, ...) is defaulted to `Unit`, since
     // no value of it can ever be observed.
-    for t in recorded.values_mut() {
+    for t in recorded.values_mut().chain(info.inst_expr_types.values_mut()) {
         *t = defaultVars(&substVars(t, &binds));
     }
-    result.map(|()| TypedInfo {
-        expr_types: recorded,
+    info.expr_types = recorded;
-    })
+    (result, info)
 }
 /// A generic type named without type arguments (`p: Parcel` for `enum
@@ -1118,7 +1253,7 @@ fn checkBareGenericTypes(source: &ast::Source) -> Vec<CheckError> {
     errors
 }
-fn checkSourceInner(source: &ast::Source) -> CheckResult<()> {
+fn checkSourceInner(source: &ast::Source) -> (CheckResult<()>, TypedInfo) {
     // Generic items are checked once, structurally (`TApp`/`TParam`), on the
     // ORIGINAL source.
     let mut errors: Vec<CheckError> = checkTraitConformance(source);
@@ -1196,15 +1331,46 @@ fn checkSourceInner(source: &ast::Source) -> CheckResult<()> {
             _ => None,
         })
         .collect();
+    let file = source
+        .module
+        .as_ref()
+        .map(|m| m.name.clone())
+        .unwrap_or_else(|| "<source>".to_string());
+    let fn_by_key: HashMap<(Option<String>, String), &ast::Fn> = source
+        .items
+        .iter()
+        .filter_map(|i| match i {
+            ast::Item::Fn(f) => Some(((f.type_param.clone(), f.name.clone()), f)),
+            _ => None,
+        })
+        .collect();
+    let mut inst = InstState {
+        info: TypedInfo::default(),
+        chains: Vec::new(),
+        queue: std::collections::VecDeque::new(),
+        file,
+    };
+    drainCalls();
+    // Roots: every non-generic fn and every test. A generic fn is only
+    // name-resolved here (its body is type-checked per instantiation below).
     for item in &source.items {
         if let ast::Item::Fn(f) = item {
+            CUR_LINE.with(|l| l.set(f.line));
             let mut local_errors = checkFn(f, &global_env, &ctx, &enums_by_name);
+            if !fnGenericNames(f, &ctx).is_empty() {
+                local_errors.retain(|e| isResolutionError(&e.message));
+                drainCalls();
+            } else {
+                registerCalls(&mut inst, &fn_by_key, &ctx, None);
+            }
             errors.append(&mut local_errors);
         }
     }
     for item in &source.items {
         if let ast::Item::Test(t) = item {
+            CUR_LINE.with(|l| l.set(t.line));
             let mut env = global_env.clone();
             let mut block_errors = checkBlock(
                 &t.body,
@@ -1215,13 +1381,171 @@ fn checkSourceInner(source: &ast::Source) -> CheckResult<()> {
                 &ctx,
             );
             errors.append(&mut block_errors);
+            registerCalls(&mut inst, &fn_by_key, &ctx, None);
         }
     }
+    // Check each reached instantiation (BFS); its own calls enqueue more.
+    let mut seen_msgs: std::collections::HashSet<String> = std::collections::HashSet::new();
+    while let Some(id) = inst.queue.pop_front() {
+        let i = inst.info.instantiations[id].clone();
+        let Some(f) = fn_by_key.get(&(i.receiver.clone(), i.name.clone())).copied() else {
+            continue;
+        };
+        let chain = inst.chains[id].clone();
+        let subst: BTreeMap<String, PlumType> = i
+            .generics
+            .iter()
+            .cloned()
+            .zip(i.type_args.iter().cloned())
+            .collect();
+        TSUBST.with(|s| *s.borrow_mut() = Some(subst));
+        INST_MODE.with(|m| m.set(true));
+        CUR_LINE.with(|l| l.set(f.line));
+        let saved = RECORD.with(|r| r.borrow_mut().replace(HashMap::new()));
+        let errs = checkFn(f, &global_env, &ctx, &enums_by_name);
+        let own = RECORD.with(|r| std::mem::replace(&mut *r.borrow_mut(), saved));
+        TSUBST.with(|s| *s.borrow_mut() = None);
+        INST_MODE.with(|m| m.set(false));
+        for (ptr, t) in own.unwrap_or_default() {
+            inst.info.inst_expr_types.insert((id, ptr), t);
+        }
+        for e in errs {
+            let msg = match (e.message.strip_prefix("fn '"), e.message.find("': ")) {
+                (Some(_), Some(k)) => e.message[k + 3..].to_string(),
+                _ => e.message.clone(),
+            };
+            let full = format!("{}{}", chain, msg);
+            if seen_msgs.insert(full.clone()) {
+                errors.push(CheckError::at(e.line, e.column, full));
+            }
+        }
+        registerCalls(&mut inst, &fn_by_key, &ctx, Some(id));
+    }
+    let result = if errors.is_empty() { Ok(()) } else { Err(errors) };
+    (result, inst.info)
+}
+struct InstState {
+    info: TypedInfo,
+    /// Per instantiation id: the "in X[T] (called at f:l): " chain prefix.
+    chains: Vec<String>,
+    queue: std::collections::VecDeque<usize>,
+    file: String,
+}
+/// Errors a generic body keeps even when uninstantiated (name resolution and
+/// declaration structure); everything else is a type error found per instantiation.
+fn isResolutionError(msg: &str) -> bool {
+    msg.contains("undefined name")
+        || msg.contains("extern")
+        || msg.contains("variadic")
+        || msg.contains("missing a body")
+}
+fn drainCalls() -> Vec<CallSite> {
+    CALLS.with(|c| {
+        c.borrow_mut()
+            .as_mut()
+            .map(std::mem::take)
+            .unwrap_or_default()
+    })
+}
+/// Generic parameter names of `f`: its owner type's generics, then the free
+/// type parameters of its own signature. Empty = not generic.
+fn fnGenericNames(f: &ast::Fn, ctx: &CheckCtx) -> Vec<String> {
+    let mut names: Vec<String> = match &f.type_param {
+        Some(r) => enumGenericsOf(r, ctx).to_vec(),
+        None => Vec::new(),
+    };
+    let mut sig = Vec::new();
+    for p in &f.params {
+        freeTParams(&paramTypeG(&p.ty), &mut sig);
+    }
+    if let Some(r) = &f.returns {
+        freeTParams(&plumTypeFromAstG(r), &mut sig);
+    }
+    for n in sig {
-    if errors.is_empty() {
+        if !names.contains(&n) {
+            names.push(n);
+        }
+    }
-        Ok(())
+    names
+}
+fn hasFreeVars(t: &PlumType) -> bool {
+    use PlumType::*;
-    } else {
+    match t {
+        TVar(_) | TParam(_) => true,
+        TApp(_, a) => a.iter().any(hasFreeVars),
+        TFun(ps, r) => ps.iter().any(hasFreeVars) || hasFreeVars(r),
+        TVariadic(i) => hasFreeVars(i),
+        TTags(m) => m.values().flatten().any(|t| hasFreeVars(t)),
+        _ => false,
+    }
+}
+/// Turns the generic calls recorded while checking one body into new
+/// instantiations (memoized by item + concrete type args).
-        Err(errors)
+fn registerCalls(
+    st: &mut InstState,
+    fns: &HashMap<(Option<String>, String), &ast::Fn>,
+    ctx: &CheckCtx,
+    parent: Option<usize>,
+) {
+    let binds = RECORD_BINDS.with(|r| r.borrow().clone()).unwrap_or_default();
+    let parent_chain = parent.map(|p| st.chains[p].clone()).unwrap_or_default();
+    let depth = parent_chain.matches("(called at").count();
+    for cs in drainCalls() {
+        let Some(f) = fns.get(&(cs.recv.clone(), cs.name.clone())) else {
+            continue;
+        };
+        let gens = fnGenericNames(f, ctx);
+        if gens.is_empty() || depth >= 24 || st.info.instantiations.len() >= 20000 {
+            continue;
+        }
+        let mut args = Vec::new();
+        for g in &gens {
+            match cs.args.get(g).map(|t| substVars(t, &binds)) {
+                Some(t) if !hasFreeVars(&t) => args.push(t),
+                _ => break,
+            }
+        }
+        if args.len() != gens.len() {
+            continue;
+        }
+        let item = match &cs.recv {
+            Some(r) => format!("{}.{}", r, cs.name),
+            None => cs.name.clone(),
+        };
+        let key = (item.clone(), args.clone());
+        if st.info.inst_index.contains_key(&key) {
+            continue;
+        }
+        let id = st.info.instantiations.len();
+        let arg_str: Vec<String> = args.iter().map(|a| a.to_string()).collect();
+        st.chains.push(format!(
+            "{}in {}[{}] (called at {}:{}): ",
+            parent_chain,
+            item,
+            arg_str.join(", "),
+            st.file,
+            cs.line
+        ));
+        st.info.instantiations.push(Instantiation {
+            id,
+            item,
+            receiver: cs.recv.clone(),
+            name: cs.name.clone(),
+            generics: gens,
+            type_args: args,
+            parent,
+            called_at_line: cs.line,
+        });
+        st.info.inst_index.insert(key, id);
+        st.queue.push_back(id);
     }
 }
@@ -1306,6 +1630,10 @@ fn checkFn(
                 generics.iter().map(|g| PlumType::TParam(g.clone())).collect(),
             )
         };
+        let self_ty = match TSUBST.with(|s| s.borrow().clone()) {
+            Some(m) => types::substitute(&self_ty, &m),
+            None => self_ty,
+        };
         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()) {
@@ -2055,13 +2383,29 @@ fn inferClassCallRaw(
                 } else {
                     BTreeMap::new()
                 };
+                let (inst, mut init_map) = instSigMap(sig, &owner);
-                let PlumType::TFun(_, ret) = instSig(sig, &owner) else {
+                let PlumType::TFun(_, ret) = inst else {
                     unreachable!("instSig preserves the TFun shape")
                 };
                 let mut binds = Binds::new();
                 if let Some(exp) = expected {
                     bindMatch(&ret, exp, &mut binds);
                 }
+                for g in gens {
+                    if let Some(t) = owner.get(g) {
+                        init_map.insert(g.clone(), t.clone());
+                    } else if !init_map.contains_key(g) {
+                        // Owner generic not in init's signature: pinned by the result type.
+                        if let PlumType::TApp(_, rargs) = &*ret {
+                            if let Some(i) = gens.iter().position(|x| x == g) {
+                                if let Some(a) = rargs.get(i) {
+                                    init_map.insert(g.clone(), a.clone());
+                                }
+                            }
+                        }
+                    }
+                }
+                recordCall(Some(&call.type_name), "init", init_map);
                 return Ok(substVars(&ret, &binds));
             }
         }
@@ -2545,7 +2889,13 @@ fn inferMethodCall(
     ctx: &CheckCtx,
     expected: Option<&PlumType>,
 ) -> Result<PlumType, String> {
+    // `Bool.toStr` is a compiler intrinsic ("True"/"False"), not a source method.
+    if matches!(obj_ty, PlumType::TBool) && name == "toStr" && args.is_empty() {
+        return Ok(PlumType::TStr);
+    }
-    // A method on a generic parameter resolves through its trait bounds only.
+    // A method on a generic parameter: a declared bound's signature if there is
+    // one; otherwise duck-typed — checked when the enclosing generic body is
+    // checked per concrete instantiation.
     if let PlumType::TParam(p) = obj_ty {
         let prefix = format!("{}{}:", BOUND_KEY, p);
         for key in env.keys() {
@@ -2562,8 +2912,10 @@ fn inferMethodCall(
                 return Ok(substVars(ret, &binds));
             }
         }
+        // Not a type error: the erased pass of a generic body just cannot type
+        // this call (its errors are discarded; see `isResolutionError`).
         return Err(format!(
-            "'{}' has no method '{}' (add a bound)",
+            "'{}.{}' is resolved per instantiation",
             p, name
         ));
     }
@@ -2592,6 +2944,13 @@ fn inferMethodCall(
         if isTraitName(&class_name, ctx) {
             return Err(format!("trait '{}' has no method '{}'", class_name, name));
         }
+        // Inside an instantiated generic body the receiver is a concrete type:
+        // a declared type lacking the method is a real (duck-typing) error.
+        if INST_MODE.with(|m| m.get())
+            && ctx.enum_variants.values().any(|i| i.enum_name == class_name)
+        {
+            return Err(format!("{} has no method '{}'", obj_ty, name));
+        }
         // Unmodeled method (e.g. builtin/std): allow, codegen will catch.
         return Ok(PlumType::TVar("_".to_string()));
     };
@@ -2604,7 +2963,11 @@ fn inferMethodCall(
         }
         _ => BTreeMap::new(),
     };
+    let (inst, mut call_map) = instSigMap(sig, &owner);
+    for (k, v) in &owner {
+        call_map.insert(k.clone(), v.clone());
+    }
-    let PlumType::TFun(params, ret) = instSig(sig, &owner) else {
+    let PlumType::TFun(params, ret) = inst else {
         unreachable!("instSig preserves the TFun shape")
     };
     let mut binds = Binds::new();
@@ -2618,6 +2981,7 @@ fn inferMethodCall(
         .unwrap_or(params.len());
     let label = format!("method '{}.{}'", class_name, name);
     checkCallArgs(&label, &params, args, required, env, ctx, &mut binds)?;
+    recordCall(Some(&class_name), name, call_map);
     Ok(substVars(&ret, &binds))
 }
@@ -3013,8 +3377,13 @@ fn inferExprInner(
                 }
                 return Ok(substVars(&result, &binds));
             }
+            let mut call_map = BTreeMap::new();
             let callee = match env.get(&call.name) {
+                Some(s) if !s.vars.is_empty() => {
-                Some(s) if !s.vars.is_empty() => Ok(instSig(&s.body, &BTreeMap::new())),
+                    let (t, m) = instSigMap(&s.body, &BTreeMap::new());
+                    call_map = m;
+                    Ok(t)
+                }
                 _ => lookup(env, &call.name),
             };
             match callee {
@@ -3030,6 +3399,7 @@ fn inferExprInner(
                         .unwrap_or(param_types.len());
                     let label = format!("call '{}'", call.name);
                     checkCallArgs(&label, &param_types, &call.args, required, env, ctx, &mut binds)?;
+                    recordCall(None, &call.name, call_map);
                     Ok(substVars(&ret, &binds))
                 }
                 Ok(_) => Err(format!("'{}' is not a function", call.name)),

plum-checker/src/types.rs CHANGED Viewed

@@ -1,6 +1,6 @@
 use std::collections::BTreeMap;
-#[derive(Debug, Clone, PartialEq)]
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub enum PlumType {
     TInt,
     TFloat,

plum-checker/tests/checker_tests.rs CHANGED Viewed

@@ -1983,12 +1983,87 @@ fn nested_generic_field() {
 }
 #[test]
-fn unbounded_tparam_method_error() {
+fn unbounded_tparam_method_now_ok() {
+    // Bounds are ignored: a method on a bare `T` is checked per instantiation.
     let r = checkSource(&parseClean("fun f(x: T) -> Int =\n  x.hash()\n"));
+    assert!(r.is_ok(), "uninstantiated unbounded T must not error: {:?}", r.err());
+}
+const DUCK_DEFS: &str = "\
+enum Num =
+  | Num(v: Int)
+  fun lt(self, o: Num) -> Bool =
+    self.v < o.v
+enum Plain =
+  | Plain(v: Int)
+fun maxOf(a: T, b: T) -> T =
+  a.lt(b) ? b : a
+";
-    assert!(
+#[test]
+fn duck_ok() {
-        errText(r).contains("'T' has no method 'hash' (add a bound)"),
+    let src = format!(
-        "unbounded T must not resolve methods"
+        "{}fun main() -> Num =\n  maxOf(Num(v: 1), Num(v: 2))\n",
+        DUCK_DEFS
+    );
+    let r = checkSource(&parseClean(&src));
+    assert!(r.is_ok(), "{:?}", r.err());
+}
+#[test]
+fn duck_missing_method_chain() {
+    let src = format!(
+        "{}fun main() -> Plain =\n  maxOf(Plain(v: 1), Plain(v: 2))\n",
+        DUCK_DEFS
     );
+    let msg = errText(checkSource(&parseClean(&src)));
+    assert!(msg.contains("called at"), "{}", msg);
+    assert!(msg.contains("in maxOf[Plain]"), "{}", msg);
+    assert!(msg.contains("Plain has no method 'lt'"), "{}", msg);
+}
+#[test]
+fn uninstantiated_generic_not_type_errored() {
+    let src = format!("{}fun unused(a: T) -> Int =\n  a.nothing() + \"s\"\n", DUCK_DEFS);
+    let r = checkSource(&parseClean(&src));
+    assert!(r.is_ok(), "{:?}", r.err());
+}
+#[test]
+fn nested_instantiation_chain() {
+    let src = format!(
+        "{}fun outer(a: T) -> T =\n  maxOf(a, a)\n\nfun main() -> Plain =\n  outer(Plain(v: 1))\n",
+        DUCK_DEFS
+    );
+    let msg = errText(checkSource(&parseClean(&src)));
+    let first = msg.find("in outer[Plain]").expect(&msg);
+    let second = msg.find("in maxOf[Plain]").expect(&msg);
+    assert!(first < second, "{}", msg);
+    assert!(msg.matches("called at").count() >= 2, "{}", msg);
+    assert!(msg.contains("Plain has no method 'lt'"), "{}", msg);
+}
+#[test]
+fn instantiation_set_listed() {
+    let src = format!(
+        "{}fun main() -> Int =\n  a := List(items: 1).map(|n| n * 2)\n  b := List(items: \"x\").map(|s| s)\n  0\n",
+        GENERIC_DEFS
+    );
+    let info = plum_checker::typedSource(&parseClean(&src)).unwrap_or_else(|e| panic!("{:?}", e));
+    let has = |t: PlumType| {
+        info.instantiations
+            .iter()
+            .any(|i| i.item == "List.map" && i.type_args.first() == Some(&t))
+    };
+    assert!(has(PlumType::TInt) && has(PlumType::TStr), "{:?}", info.instantiations);
+    for i in &info.instantiations {
+        assert_eq!(info.inst_index[&(i.item.clone(), i.type_args.clone())], i.id);
+    }
+    assert!(!info.inst_expr_types.is_empty());
 }
 #[test]
@@ -2077,9 +2152,13 @@ fun b() -> Str =
 #[test]
 fn generic_return_of_param_rejected_for_concrete_declared_return() {
-    // Under erasure a `T` value must never be accepted where `Int` is declared.
+    // Duck typing: only an instantiation where `T` is not `Int` is rejected.
-    assert!(checkSource(&parseClean("fun f(x: T) -> Int =\n  x\n")).is_err());
+    assert!(checkSource(&parseClean("fun f(x: T) -> Int =\n  x\n")).is_ok());
+    assert!(checkSource(&parseClean(
+        "fun f(x: T) -> Int =\n  x\n\nfun main() -> Int =\n  f(\"s\")\n"
+    ))
+    .is_err());
-    let method = "enum Box[T] =\n  | Box(value: T)\n\n  fun get() -> Int =\n    self.value\n";
+    let method = "enum Box[T] =\n  | Box(value: T)\n\n  fun get() -> Int =\n    self.value\n\nfun main() -> Int =\n  Box(value: \"s\").get()\n";
     assert!(checkSource(&parseClean(method)).is_err());
     assert!(checkSource(&parseClean("fun f(x: T) -> T =\n  x\n")).is_ok());
 }

plum-core/src/loader.rs CHANGED Viewed

@@ -57,8 +57,6 @@ pub fn loadAndMergeWithOverrides(
         )?;
     }
-    injectBoolIntrinsics(&mut items);
     Ok(Source {
         module: entry_source.module,
         imports: entry_source.imports,
@@ -67,32 +65,6 @@ pub fn loadAndMergeWithOverrides(
     })
 }
-/// `Bool` is a built-in i32 with no source file; its one method, `toStr`
-/// ("True"/"False" — the same text string interpolation emits), is a compiler
-/// intrinsic. It is supplied as a synthetic method item so the checker, `ToStr`
-/// trait conformance, dyn dispatch and codegen all see an ordinary method. Only
-/// injected once `Str` is in the program (the method returns `Str`).
-fn injectBoolIntrinsics(items: &mut Vec<Item>) {
-    let has_str = items
-        .iter()
-        .any(|i| matches!(i, Item::Enum(e) if e.name == "Str"));
-    if !has_str {
-        return;
-    }
-    const SNIPPET: &str = "enum Bool =\n  | Bool\n\n  fun toStr(self) -> Str =\n    self ? \"True\" : \"False\"\n";
-    let mut parser = tree_sitter::Parser::new();
-    parser
-        .set_language(&tree_sitter_plum::LANGUAGE.into())
-        .expect("plum grammar loads");
-    let tree = parser.parse(SNIPPET, None).expect("intrinsic snippet parses");
-    let source = AstParser::new(SNIPPET).parseSource(tree.root_node());
-    for item in source.items {
-        if let Item::Fn(f) = item {
-            items.push(Item::Fn(f));
-        }
-    }
-}
 fn canonicalizeMaybeMissing(path: &Path) -> Result<PathBuf, String> {
     if let Ok(canon) = std::fs::canonicalize(path) {
         return Ok(canon);

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

@@ -1760,6 +1760,8 @@ fn compileSourceInner(
     // The source is compiled as written (generics erased, not specialized): the
     // checker's per-expression instantiated types drive every box/unbox decision.
     let types = typed.expr_types;
+    // `Bool.toStr` is a checker/codegen builtin: compiled as one extra method, never added to the source.
+    let bool_to_str_fn = plum_checker::needsBuiltinBoolToStr(source).then(plum_checker::builtinBoolToStr);
     let (global_env, methods, enum_variants, enum_params) = plum_checker::buildGlobalTables(source);
     let min_required = plum_checker::buildMinRequiredArgs(source);
@@ -2018,8 +2020,16 @@ fn compileSourceInner(
     // Register every function AND method signature up front (methods get an implicit
     // leading `self: pointer` param and are keyed as "Receiver::method").
-    for item in &source.items {
+    for f in source
+        .items
+        .iter()
+        .filter_map(|item| match item {
-        if let ast::Item::Fn(f) = item {
+            ast::Item::Fn(f) => Some(f),
+            _ => None,
+        })
+        .chain(bool_to_str_fn.iter())
+    {
+        {
             if f.is_extern {
                 continue;
             }
@@ -2073,6 +2083,7 @@ fn compileSourceInner(
             ast::Item::Fn(f) if !f.is_extern => Some(f),
             _ => None,
         })
+        .chain(bool_to_str_fn.iter())
         .collect();
     // ---- Discovery pre-pass: find every closure literal in every function body. ----