22140cf | plum

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

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

22140cf — Peter John 2026-07-20T15:43:06+05:30

feat(plum-checker): monomorphize generic classes/functions/methods/enums before checking and codegen

Files changed (5) hide show

plum-checker/src/lib.rs +2 -1
plum-checker/src/monomorphize.rs +410 -0
plum-checker/tests/checker_tests.rs +66 -0
plum-core/src/parser.rs +28 -22
plum-wasm-codegen/src/lib.rs +1 -0

plum-checker/src/lib.rs CHANGED Viewed

@@ -138,8 +138,9 @@ pub fn build_global_tables(source: &ast::Source) -> (TypeEnv, ClassEnv, MethodEn
 }
 pub fn check_source(source: &ast::Source) -> CheckResult<()> {
+    let source = monomorphize::monomorphize_source(source).map_err(|e| vec![CheckError { message: e }])?;
     let mut errors: Vec<CheckError> = Vec::new();
-    let (global_env, classes, methods, enum_variants) = build_global_tables(source);
+    let (global_env, classes, methods, enum_variants) = build_global_tables(&source);
     let ctx = CheckCtx { classes: &classes, methods: &methods, enum_variants: &enum_variants };
     // A name that is both a class and an enum variant is ambiguous: `Name(...)`

plum-checker/src/monomorphize.rs CHANGED Viewed

@@ -165,3 +165,413 @@ pub fn specialize_enum(e: &ast::Enum, subst: &Substitution, mangled_name: &str)
         }).collect(),
     }
 }
+use std::collections::BTreeSet;
+use crate::types::{TypeEnv, TypeScheme};
+use crate::{ClassEnv, MethodEnv, EnumVariants, CheckCtx};
+enum PendingSpecialization<'a> {
+    Class { base: &'a ast::Class, subst: Substitution, mangled: String },
+    Fn { base: &'a ast::Fn, subst: Substitution, mangled: String, new_receiver: Option<String> },
+    #[allow(dead_code)]
+    Enum { base: &'a ast::Enum, subst: Substitution, mangled: String },
+}
+struct Monomorphizer<'a> {
+    classes_generic: BTreeMap<String, &'a ast::Class>,
+    fns_generic: BTreeMap<String, &'a ast::Fn>,
+    methods_generic_on: BTreeMap<String, Vec<&'a ast::Fn>>,
+    global_env: TypeEnv,
+    classes: ClassEnv,
+    methods: MethodEnv,
+    enum_variants: EnumVariants,
+    specialized: BTreeSet<String>,
+    enqueued: BTreeSet<String>,
+    worklist: Vec<PendingSpecialization<'a>>,
+    produced: Vec<ast::Item>,
+}
+impl<'a> Monomorphizer<'a> {
+    fn infer(&self, e: &ast::Expr, env: &TypeEnv) -> PlumType {
+        let ctx = CheckCtx { classes: &self.classes, methods: &self.methods, enum_variants: &self.enum_variants };
+        crate::infer_expr(e, env, &ctx).unwrap_or(PlumType::TVar("_".to_string()))
+    }
+    /// Rewrites a function/method body's generic call sites. When `resolve_return`
+    /// is set (for freshly-generated specializations, whose declared return may be
+    /// a generic parameter like `a` — which the current grammar can't even parse,
+    /// leaving `returns: None` — or a generic class), the declared return type is
+    /// re-derived from the concrete inferred type of the body's tail expression.
+    /// For an ordinary (non-generic) top-level function we only rewrite the return
+    /// annotation when it names a generic class used bare (e.g. `-> Box`), which
+    /// the body's construction site has just been specialized to a mangled name.
+    fn rewrite_fn_body(&mut self, f: &mut ast::Fn, resolve_return: bool) -> Result<(), String> {
+        let mut env = self.global_env.clone();
+        if let Some(recv) = &f.type_param {
+            env.insert("self".to_string(), TypeScheme::mono(PlumType::TNamed(recv.clone())));
+        }
+        for p in &f.params {
+            let ty = match &p.ty {
+                ast::ParamType::Type(t) => crate::plum_type_from_ast(t),
+                ast::ParamType::Variadic(t) => crate::plum_type_from_ast(t),
+            };
+            env.insert(p.name.clone(), TypeScheme::mono(ty));
+        }
+        let tail: Option<PlumType> = match &mut f.body {
+            ast::FnBody::Expr(e) => {
+                self.rewrite_expr(e, &env)?;
+                Some(self.infer(e, &env))
+            }
+            ast::FnBody::Block(block) => {
+                self.rewrite_block(block, &mut env)?;
+                match block.stmts.last() {
+                    Some(ast::Stmt::Expr(e)) => Some(self.infer(e, &env)),
+                    Some(ast::Stmt::Return(Some(e))) => Some(self.infer(e, &env)),
+                    _ => None,
+                }
+            }
+        };
+        if let Some(t) = tail {
+            self.maybe_rewrite_return(f, &t, resolve_return);
+        }
+        Ok(())
+    }
+    /// Overwrites `f.returns` with a concrete type derived from the body's tail
+    /// type `t` when the currently-declared return type is generic/unresolved.
+    /// Never clobbers a genuine concrete annotation on an ordinary function, and
+    /// never fabricates a return type from an un-inferrable (`TVar`) tail.
+    fn maybe_rewrite_return(&self, f: &mut ast::Fn, t: &PlumType, resolve_return: bool) {
+        if matches!(t, PlumType::TVar(_) | PlumType::TFun(_, _)) {
+            return;
+        }
+        let needs = match &f.returns {
+            None => resolve_return,
+            Some(rt) => {
+                resolve_return
+                    || is_generic_param_name(&rt.name)
+                    || self.classes_generic.contains_key(&rt.name)
+            }
+        };
+        if needs {
+            f.returns = Some(ast::ReturnType { name: t.to_string(), generics: vec![] });
+        }
+    }
+    fn rewrite_block(&mut self, block: &mut ast::Block, env: &mut TypeEnv) -> Result<(), String> {
+        for stmt in &mut block.stmts {
+            self.rewrite_stmt(stmt, env)?;
+        }
+        Ok(())
+    }
+    fn rewrite_stmt(&mut self, stmt: &mut ast::Stmt, env: &mut TypeEnv) -> Result<(), String> {
+        match stmt {
+            ast::Stmt::Assign(a) => {
+                for (target, value) in a.targets.iter().zip(a.values.iter_mut()) {
+                    self.rewrite_expr(value, env)?;
+                    let ty = self.infer(value, env);
+                    env.insert(target.clone(), TypeScheme::mono(ty));
+                }
+            }
+            ast::Stmt::Return(Some(e)) => self.rewrite_expr(e, env)?,
+            ast::Stmt::Return(None) => {}
+            ast::Stmt::If(if_) => {
+                self.rewrite_expr(&mut if_.condition, env)?;
+                self.rewrite_block(&mut if_.body, &mut env.clone())?;
+                for ei in &mut if_.else_ifs {
+                    self.rewrite_expr(&mut ei.condition, env)?;
+                    self.rewrite_block(&mut ei.body, &mut env.clone())?;
+                }
+                if let Some(else_block) = &mut if_.else_ {
+                    self.rewrite_block(else_block, &mut env.clone())?;
+                }
+            }
+            ast::Stmt::While(w) => {
+                self.rewrite_expr(&mut w.condition, env)?;
+                self.rewrite_block(&mut w.body, &mut env.clone())?;
+            }
+            ast::Stmt::For(f) => {
+                self.rewrite_expr(&mut f.iter, env)?;
+                let mut inner = env.clone();
+                for v in &f.vars {
+                    inner.insert(v.clone(), TypeScheme::mono(PlumType::TInt));
+                }
+                self.rewrite_block(&mut f.body, &mut inner)?;
+            }
+            ast::Stmt::Expr(e) => self.rewrite_expr(e, env)?,
+            ast::Stmt::Assert(e) => self.rewrite_expr(e, env)?,
+            ast::Stmt::Match(m) => {
+                for s in &mut m.subjects {
+                    self.rewrite_expr(s, env)?;
+                }
+                let subject_ty = m.subjects.first().map(|s| self.infer(s, env)).unwrap_or(PlumType::TInt);
+                for case in &mut m.cases {
+                    let mut case_env = env.clone();
+                    if let Some(ast::CasePattern::Name(n)) = case.patterns.first() {
+                        let is_variant = n.chars().next().map(|c| c.is_uppercase()).unwrap_or(false)
+                            && self.enum_variants.contains_key(n);
+                        if !is_variant {
+                            case_env.insert(n.clone(), TypeScheme::mono(subject_ty.clone()));
+                        }
+                    }
+                    self.rewrite_block(&mut case.body, &mut case_env)?;
+                }
+            }
+            ast::Stmt::Break | ast::Stmt::Continue | ast::Stmt::Todo => {}
+        }
+        Ok(())
+    }
+    fn resolve_class_instantiation(&mut self, call: &mut ast::ClassCall, env: &TypeEnv) -> Result<(), String> {
+        let Some(class) = self.classes_generic.get(call.type_name.as_str()).copied() else { return Ok(()) };
+        let params = class_generic_params(class);
+        let mut bindings: BTreeMap<String, PlumType> = BTreeMap::new();
+        for gp in &params {
+            if let Some(field) = class.fields.iter().find(|f| f.ty.name == *gp) {
+                if let Some(fa) = call.fields.iter().find(|fa| fa.name == field.name) {
+                    bindings.insert(gp.clone(), self.infer(&fa.value, env));
+                }
+            }
+        }
+        if bindings.len() != params.len() {
+            return Err(format!(
+                "monomorphize: could not resolve all generic parameters for '{}' at this call site",
+                call.type_name
+            ));
+        }
+        let type_args: Vec<PlumType> = params.iter().map(|p| bindings[p].clone()).collect();
+        let mangled = mangle(&call.type_name, &type_args);
+        if !self.specialized.contains(&mangled) && !self.enqueued.contains(&mangled) {
+            self.enqueued.insert(mangled.clone());
+            self.worklist.push(PendingSpecialization::Class { base: class, subst: Substitution(bindings), mangled: mangled.clone() });
+        }
+        call.type_name = mangled;
+        Ok(())
+    }
+    fn resolve_fn_instantiation(&mut self, call: &mut ast::FnCall, env: &TypeEnv) -> Result<(), String> {
+        let Some(f) = self.fns_generic.get(call.name.as_str()).copied() else { return Ok(()) };
+        let params = fn_generic_params(f);
+        let mut bindings: BTreeMap<String, PlumType> = BTreeMap::new();
+        for (param, arg) in f.params.iter().zip(call.args.iter()) {
+            let gp = match &param.ty {
+                ast::ParamType::Type(t) => t.name.clone(),
+                ast::ParamType::Variadic(t) => t.name.clone(),
+            };
+            if params.contains(&gp) {
+                let arg_expr = match arg {
+                    ast::Arg::Positional(e) => e,
+                    ast::Arg::Keyword { value, .. } => value,
+                    ast::Arg::Pair { value, .. } => value,
+                };
+                bindings.entry(gp).or_insert_with(|| self.infer(arg_expr, env));
+            }
+        }
+        if bindings.len() != params.len() {
+            return Err(format!(
+                "monomorphize: could not resolve all generic parameters for '{}' at this call site",
+                call.name
+            ));
+        }
+        let type_args: Vec<PlumType> = params.iter().map(|p| bindings[p].clone()).collect();
+        let mangled = mangle(&call.name, &type_args);
+        if !self.specialized.contains(&mangled) && !self.enqueued.contains(&mangled) {
+            self.enqueued.insert(mangled.clone());
+            self.worklist.push(PendingSpecialization::Fn { base: f, subst: Substitution(bindings), mangled: mangled.clone(), new_receiver: None });
+        }
+        call.name = mangled;
+        Ok(())
+    }
+    fn rewrite_expr(&mut self, expr: &mut ast::Expr, env: &TypeEnv) -> Result<(), String> {
+        match expr {
+            ast::Expr::ClassCall(call) => {
+                for fa in &mut call.fields {
+                    self.rewrite_expr(&mut fa.value, env)?;
+                }
+                self.resolve_class_instantiation(call, env)?;
+            }
+            ast::Expr::FnCall(call) => {
+                for arg in &mut call.args {
+                    let e = match arg {
+                        ast::Arg::Positional(e) => e,
+                        ast::Arg::Keyword { value, .. } => value,
+                        ast::Arg::Pair { value, .. } => value,
+                    };
+                    self.rewrite_expr(e, env)?;
+                }
+                self.resolve_fn_instantiation(call, env)?;
+            }
+            ast::Expr::Attribute(attr) => {
+                self.rewrite_expr(&mut attr.object, env)?;
+                if let ast::AttrKind::Method(call) = &mut attr.attr {
+                    for arg in &mut call.args {
+                        let e = match arg {
+                            ast::Arg::Positional(e) => e,
+                            ast::Arg::Keyword { value, .. } => value,
+                            ast::Arg::Pair { value, .. } => value,
+                        };
+                        self.rewrite_expr(e, env)?;
+                    }
+                    // Method dispatch on a specialized receiver needs no rewrite here:
+                    // once the receiver's construction site is rewritten to its mangled
+                    // class name, the receiver's inferred static type IS that mangled
+                    // name, and the specialized methods were registered under exactly
+                    // that (mangled receiver, method name) key when their class was
+                    // specialized (see the `PendingSpecialization::Class` arm below).
+                }
+            }
+            ast::Expr::Binary(b) => { self.rewrite_expr(&mut b.left, env)?; self.rewrite_expr(&mut b.right, env)?; }
+            ast::Expr::Bool(b) => { self.rewrite_expr(&mut b.left, env)?; self.rewrite_expr(&mut b.right, env)?; }
+            ast::Expr::Compare(c) => { self.rewrite_expr(&mut c.left, env)?; self.rewrite_expr(&mut c.right, env)?; }
+            ast::Expr::Not(inner) => self.rewrite_expr(inner, env)?,
+            ast::Expr::Unary(u) => self.rewrite_expr(&mut u.operand, env)?,
+            ast::Expr::Paren(inner) => self.rewrite_expr(inner, env)?,
+            ast::Expr::Ternary(t) => {
+                self.rewrite_expr(&mut t.condition, env)?;
+                self.rewrite_expr(&mut t.then, env)?;
+                self.rewrite_expr(&mut t.else_, env)?;
+            }
+            // String interpolation can embed arbitrary expressions (including generic
+            // call sites), so recurse into its interpolated parts.
+            ast::Expr::String(s) => {
+                for part in &mut s.parts {
+                    if let ast::StringPart::Interp(e) = part {
+                        self.rewrite_expr(e, env)?;
+                    }
+                }
+            }
+            ast::Expr::Int(_) | ast::Expr::Float(_)
+            | ast::Expr::Self_ | ast::Expr::Var(_) | ast::Expr::TypeName(_) => {}
+        }
+        Ok(())
+    }
+}
+/// Runs the whole generics-monomorphization pass over `source`, producing a plain,
+/// fully-concrete `ast::Source` with every generic `Class`/`Fn`/`Enum` template
+/// replaced by zero or more mangled concrete specializations, and every remaining
+/// item's body rewritten so its call sites reference those mangled names. The
+/// result has no generic syntax left in it — `check_source`/`compile_source` run
+/// on it completely unmodified.
+pub fn monomorphize_source(source: &ast::Source) -> Result<ast::Source, String> {
+    let (global_env, classes, methods, enum_variants) = crate::build_global_tables(source);
+    let mut m = Monomorphizer {
+        classes_generic: BTreeMap::new(),
+        fns_generic: BTreeMap::new(),
+        methods_generic_on: BTreeMap::new(),
+        global_env,
+        classes,
+        methods,
+        enum_variants,
+        specialized: BTreeSet::new(),
+        enqueued: BTreeSet::new(),
+        worklist: Vec::new(),
+        produced: Vec::new(),
+    };
+    for item in &source.items {
+        match item {
+            ast::Item::Class(c) if !c.generics.is_empty() => { m.classes_generic.insert(c.name.clone(), c); }
+            _ => {}
+        }
+    }
+    for item in &source.items {
+        if let ast::Item::Fn(f) = item {
+            let receiver_is_generic = f.type_param.as_deref().map(|r| m.classes_generic.contains_key(r)).unwrap_or(false);
+            if receiver_is_generic {
+                m.methods_generic_on.entry(f.type_param.clone().unwrap()).or_default().push(f);
+            } else if f.type_param.is_none() && !fn_generic_params(f).is_empty() {
+                m.fns_generic.insert(f.name.clone(), f);
+            }
+            // A method whose receiver is NOT generic is left as a regular method below,
+            // even if its own params/return happen to use a bare lowercase-letter type
+            // name — that shape (a method introducing its own extra generic parameter)
+            // is out of scope for this pass; see the plan's Global Constraints.
+        }
+    }
+    for item in &source.items {
+        match item {
+            ast::Item::Class(c) if c.generics.is_empty() => m.produced.push(ast::Item::Class(c.clone())),
+            ast::Item::Enum(e) if enum_generic_params(e).is_empty() => m.produced.push(ast::Item::Enum(e.clone())),
+            ast::Item::Const(c) => m.produced.push(ast::Item::Const(c.clone())),
+            ast::Item::Trait(t) => m.produced.push(ast::Item::Trait(t.clone())),
+            ast::Item::Fn(f) => {
+                let receiver_is_generic = f.type_param.as_deref().map(|r| m.classes_generic.contains_key(r)).unwrap_or(false);
+                let is_generic_fn = f.type_param.is_none() && !fn_generic_params(f).is_empty();
+                if !receiver_is_generic && !is_generic_fn {
+                    let mut f2 = f.clone();
+                    m.rewrite_fn_body(&mut f2, false)?;
+                    m.produced.push(ast::Item::Fn(f2));
+                }
+            }
+            _ => {} // generic Class/Enum declarations dropped here — templates only
+        }
+    }
+    let mut guard = 0usize;
+    while let Some(pending) = m.worklist.pop() {
+        guard += 1;
+        if guard > 10_000 {
+            return Err("monomorphize: exceeded specialization limit (possible unbounded generic recursion)".to_string());
+        }
+        match pending {
+            PendingSpecialization::Class { base, subst, mangled } => {
+                if !m.specialized.insert(mangled.clone()) { continue; }
+                let spec_class = specialize_class(base, &subst, &mangled);
+                // Register the specialized class's fields so inference inside its
+                // own (and other items') bodies can resolve `receiver.field` on the
+                // mangled type — `self.classes` was built from the ORIGINAL source
+                // and would otherwise not know this freshly-minted class.
+                m.classes.insert(
+                    mangled.clone(),
+                    spec_class.fields.iter().map(|f| (f.name.clone(), crate::plum_type_from_ast(&f.ty))).collect(),
+                );
+                m.produced.push(ast::Item::Class(spec_class));
+                if let Some(methods) = m.methods_generic_on.get(base.name.as_str()).cloned() {
+                    for method in methods {
+                        let mut specialized_method = specialize_fn(method, &subst, &method.name, Some(mangled.clone()));
+                        m.rewrite_fn_body(&mut specialized_method, true)?;
+                        // Register the specialized method's signature under its
+                        // (mangled receiver, method name) key so any later body that
+                        // dispatches to it can resolve its concrete return type.
+                        let param_types: Vec<PlumType> = specialized_method.params.iter().map(|p| match &p.ty {
+                            ast::ParamType::Type(t) => crate::plum_type_from_ast(t),
+                            ast::ParamType::Variadic(t) => crate::plum_type_from_ast(t),
+                        }).collect();
+                        let ret = specialized_method.returns.as_ref()
+                            .map(|r| crate::plum_type_from_ast(&ast::Type { name: r.name.clone(), generics: vec![] }))
+                            .unwrap_or(PlumType::TUnit);
+                        m.methods.insert((mangled.clone(), specialized_method.name.clone()), PlumType::TFun(param_types, Box::new(ret)));
+                        m.produced.push(ast::Item::Fn(specialized_method));
+                    }
+                }
+            }
+            PendingSpecialization::Fn { base, subst, mangled, new_receiver } => {
+                if !m.specialized.insert(mangled.clone()) { continue; }
+                let mut specialized_fn = specialize_fn(base, &subst, &mangled, new_receiver);
+                m.rewrite_fn_body(&mut specialized_fn, true)?;
+                // Register the specialized free function's signature so later bodies
+                // can resolve calls to it during inference.
+                let param_types: Vec<PlumType> = specialized_fn.params.iter().map(|p| match &p.ty {
+                    ast::ParamType::Type(t) => crate::plum_type_from_ast(t),
+                    ast::ParamType::Variadic(t) => crate::plum_type_from_ast(t),
+                }).collect();
+                let ret = specialized_fn.returns.as_ref()
+                    .map(|r| crate::plum_type_from_ast(&ast::Type { name: r.name.clone(), generics: vec![] }))
+                    .unwrap_or(PlumType::TUnit);
+                m.global_env.insert(specialized_fn.name.clone(), TypeScheme::mono(PlumType::TFun(param_types, Box::new(ret))));
+                m.produced.push(ast::Item::Fn(specialized_fn));
+            }
+            PendingSpecialization::Enum { base, subst, mangled } => {
+                if !m.specialized.insert(mangled.clone()) { continue; }
+                m.produced.push(ast::Item::Enum(specialize_enum(base, &subst, &mangled)));
+            }
+        }
+    }
+    Ok(ast::Source { module: source.module.clone(), imports: source.imports.clone(), items: m.produced })
+}

plum-checker/tests/checker_tests.rs CHANGED Viewed

@@ -315,3 +315,69 @@ enum Animal =
         errs
     );
 }
+#[test]
+fn generic_class_instantiated_at_two_concrete_types_type_checks() {
+    let src = "\
+type Box(a) =
+  value: a
+makeIntBox() -> Box =
+  Box(value: 5)
+makeStrBox() -> Box =
+  Box(value: \"x\")
+";
+    let source = parse(src);
+    let result = check_source(&source);
+    assert!(result.is_ok(), "expected Ok, got {:?}", result.err());
+}
+#[test]
+fn generic_function_called_with_different_concrete_types_per_site_type_checks() {
+    let src = "\
+wrap(value: a) -> Bool =
+  True
+useInt() -> Bool =
+  wrap(5)
+useStr() -> Bool =
+  wrap(\"x\")
+";
+    let source = parse(src);
+    let result = check_source(&source);
+    assert!(result.is_ok(), "expected Ok, got {:?}", result.err());
+}
+#[test]
+fn generic_function_with_two_independent_type_params_type_checks() {
+    let src = "\
+pair(first: a, second: b) -> Bool =
+  True
+use() -> Bool =
+  pair(1, \"x\")
+";
+    let source = parse(src);
+    let result = check_source(&source);
+    assert!(result.is_ok(), "expected Ok, got {:?}", result.err());
+}
+#[test]
+fn generic_method_on_generic_class_type_checks() {
+    let src = "\
+type Box(a) =
+  value: a
+getValue<Box>() -> a =
+  self.value
+use() -> Int =
+  b = Box(value: 5)
+  b.getValue()
+";
+    let source = parse(src);
+    let result = check_source(&source);
+    assert!(result.is_ok(), "expected Ok, got {:?}", result.err());
+}

plum-core/src/parser.rs CHANGED Viewed

@@ -97,28 +97,34 @@ impl<'a> AstParser<'a> {
     }
     fn parse_generics_field(&self, node: Node) -> Vec<GenericParam> {
+        // generics: "(" generic_type,* ")"  where  generic_type: generic (":" sep1(type_identifier, "+"))?
+        //
-        // generics: "(" generic_type,* ")"
+        // Both `generic_type` and `generic` are `inline`d in the grammar, so the
-        // The generics node is not field-named in a straightforward way; look
+        // `generics` node has NO `generic_type` children — its named children are
+        // the single-letter generic nodes (`a`/`b`/`c`/`d`) each optionally
+        // followed by their bound `type_identifier` nodes, all flattened together.
+        // Reconstruct each `GenericParam` by starting a new one at every generic
+        // letter and attaching any following `type_identifier`s as its bounds
-        // for a child whose kind is "generics".
+        // until the next generic letter.
-        let generics_node = self.children_of_kind(node, "generics").into_iter().next();
+        let Some(generics_node) = self.children_of_kind(node, "generics").into_iter().next() else {
-        generics_node.map(|g| {
+            return Vec::new();
-            self.children_of_kind(g, "generic_type")
-                .into_iter()
+        };
-                .map(|n| self.parse_generic_type(n))
+        let mut cursor = generics_node.walk();
-                .collect()
+        let mut params: Vec<GenericParam> = Vec::new();
+        for child in generics_node.named_children(&mut cursor) {
-        }).unwrap_or_default()
+            match child.kind() {
+                "a" | "b" | "c" | "d" => {
+                    params.push(GenericParam { name: self.text(child), bounds: Vec::new() });
-    }
+                }
-    fn parse_generic_type(&self, node: Node) -> GenericParam {
-        // generic_type: generic (":" sep1(type_identifier, "+"))?
+                "type_identifier" => {
-        // named_child(0) = generic (single letter)
+                    if let Some(last) = params.last_mut() {
-        // remaining named children = bound type_identifiers
-        let name = node.named_child(0).map(|n| self.text(n)).unwrap_or_default();
-        let bounds = (1..node.named_child_count())
+                        last.bounds.push(self.text(child));
-            .filter_map(|i| node.named_child(i as u32))
-            .map(|n| self.text(n))
+                    }
+                }
-            .collect();
+                _ => {}
+            }
+        }
-        GenericParam { name, bounds }
+        params
     }
     fn parse_field(&self, node: Node) -> Field {

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

@@ -294,6 +294,7 @@ fn infer_local_type(expr: &ast::Expr, ctx: &LocalCtx) -> PlumType {
 }
 pub fn compile_source(source: &ast::Source) -> Result<Vec<u8>, String> {
+    let source = &plum_checker::monomorphize::monomorphize_source(source)?;
     let (global_env, classes, methods, enum_variants) = plum_checker::build_global_tables(source);
     let mut module = WasmModule::new();