2216237 | plum

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

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

2216237 — Peter John 2026-07-20T20:11:29+05:30

feat(plum-checker): support multiple concrete instantiations of the same generic enum

Files changed (4) hide show

README.md +1 -1
plum-checker/src/monomorphize.rs +181 -51
plum-checker/tests/checker_tests.rs +78 -16
plum-wasm-codegen/tests/codegen_tests.rs +56 -0

README.md CHANGED Viewed

@@ -240,7 +240,7 @@ wrap(value: a) -> Bool =      # generic param type
   True
 ```
-Generic **arguments** (instantiating a generic type) accept either bracket or paren syntax: `List[Int]` and `List(Int)` both parse. User-defined generics (classes, their methods, free functions, and enums) are monomorphized: each concrete-type-argument combination actually used in the program gets its own specialized, fully-concrete copy, which then type-checks and compiles to wasm through the normal, unmodified pipeline. See `useWrap`/`usePair` in [`examples/functions.plum`](examples/functions.plum) and `makeIntBox`/`makeStrBox` in [`examples/types.plum`](examples/types.plum) for real instantiation sites. One documented limitation: a generic *enum* may only be instantiated at one concrete type per program (instantiating the same generic enum at two different concrete types produces a clear `monomorphize:`-prefixed error, since the runtime's enum-variant table is keyed by bare variant name).
+Generic **arguments** (instantiating a generic type) accept either bracket or paren syntax: `List[Int]` and `List(Int)` both parse. User-defined generics (classes, their methods, free functions, and enums) are monomorphized: each concrete-type-argument combination actually used in the program gets its own specialized, fully-concrete copy, which then type-checks and compiles to wasm through the normal, unmodified pipeline. See `useWrap`/`usePair` in [`examples/functions.plum`](examples/functions.plum) and `makeIntBox`/`makeStrBox` in [`examples/types.plum`](examples/types.plum) for real instantiation sites. Generic enums support any number of concrete instantiations coexisting in one program (variant names are mangled per instantiation, e.g. `Some` -> `Some$Int`/`Some$Str`, internally — invisible to user code). One narrower residual limitation: a payload-free variant (e.g. `None`) used as a bare value *outside* of a `match` pattern can't be disambiguated between multiple concrete instantiations of its enum from that expression alone; constructing via a payload-carrying sibling (`Some(5)`) and matching (`Some(v) => ...`, `None => ...`) is fully supported and is the overwhelmingly common usage pattern.
 Full example: [`examples/types.plum`](examples/types.plum), [`examples/functions.plum`](examples/functions.plum).

plum-checker/src/monomorphize.rs CHANGED Viewed

@@ -154,11 +154,20 @@ pub fn specialize_fn(f: &ast::Fn, subst: &Substitution, mangled_name: &str, new_
 /// Produces a concrete, specialized copy of a generic enum under `mangled_name`,
 /// substituting every variant field type name that matches one of the enum's
 /// generic parameters with its resolved concrete type's name.
+///
+/// Variant names are ALSO mangled here, with the same suffix as the enum's own
+/// name (e.g. `Some` -> `Some$Int`) — even a payload-free variant like `None`.
+/// This is necessary because the runtime `EnumVariants` table (built by
+/// `build_global_tables`) is keyed by bare variant name globally: without this,
+/// two specializations of the same generic enum would both register a variant
+/// literally named `Some`, colliding in that flat table.
 pub fn specialize_enum(e: &ast::Enum, subst: &Substitution, mangled_name: &str) -> ast::Enum {
+    let params = enum_generic_params(e);
+    let type_args: Vec<PlumType> = params.iter().filter_map(|p| subst.get(p).cloned()).collect();
     ast::Enum {
         name: mangled_name.to_string(),
         variants: e.variants.iter().map(|v| ast::EnumVariant {
-            name: v.name.clone(),
+            name: mangle(&v.name, &type_args),
             fields: v.fields.iter().map(|f| {
                 subst.get(f).map(|t| t.to_string()).unwrap_or_else(|| f.clone())
             }).collect(),
@@ -168,7 +177,7 @@ pub fn specialize_enum(e: &ast::Enum, subst: &Substitution, mangled_name: &str)
 use std::collections::BTreeSet;
 use crate::types::{TypeEnv, TypeScheme};
-use crate::{ClassEnv, MethodEnv, EnumVariants, CheckCtx};
+use crate::{ClassEnv, MethodEnv, EnumVariants, EnumVariantInfo, CheckCtx};
 enum PendingSpecialization<'a> {
     Class { base: &'a ast::Class, subst: Substitution, mangled: String },
@@ -184,13 +193,26 @@ struct Monomorphizer<'a> {
     /// by variant name because a construction site (`Some(5)`) parses as a `FnCall`
     /// whose `name` is the VARIANT, not the enum's own name.
     enums_generic_by_variant: BTreeMap<String, &'a ast::Enum>,
-    /// Bare variant name -> the mangled enum name that has currently "claimed" it.
+    /// Mangled enum name -> {original variant name -> mangled variant name}, e.g.
+    /// `"Option$Int" -> {"Some": "Some$Int", "None": "None$Int"}`. Populated eagerly
+    /// (in `resolve_enum_instantiation`, at the moment an instantiation's concrete
-    /// Because the runtime `EnumVariants` table is keyed by BARE variant name
+    /// type arguments become known) rather than waiting for the worklist to actually
-    /// globally, two specializations of the same generic enum would both try to
+    /// produce that specialization — so both a construction call site and a later
-    /// register `"Some"`, silently colliding. We detect that here and error rather
-    /// than corrupt one specialization (single-instantiation-per-generic-enum is a
+    /// `match` on the same specialization can rewrite variant names consistently,
-    /// documented limitation of this pass).
+    /// regardless of processing order.
-    enum_variant_owner: BTreeMap<String, String>,
+    enum_variant_mangling: BTreeMap<String, BTreeMap<String, String>>,
+    /// The enum's own bare name -> the generic `Enum` — used to detect a bare
+    /// generic-enum-typed function param (e.g. `o: Option`), distinct from
+    /// `enums_generic_by_variant` (keyed by VARIANT name, used for construction
+    /// sites like `Some(5)`).
+    enums_generic_by_name: BTreeMap<String, &'a ast::Enum>,
+    /// Free functions that are NOT generic by `fn_generic_params`'s lowercase-letter
+    /// convention, but whose param type(s) bare-name a generic class or enum (e.g.
+    /// `unwrapOr(o: Option, ...)`) — such a function still needs its own
+    /// per-call-site specialization, since its receiver generic class/enum is
+    /// dropped from the monomorphized output and the bare name would otherwise
+    /// resolve to nothing.
+    fns_bare_generic: BTreeMap<String, &'a ast::Fn>,
     global_env: TypeEnv,
     classes: ClassEnv,
     methods: MethodEnv,
@@ -279,6 +301,7 @@ impl<'a> Monomorphizer<'a> {
             Some(rt) => {
                 is_generic_param_name(&rt.name)
                     || self.classes_generic.contains_key(&rt.name)
+                    || self.enums_generic_by_name.contains_key(&rt.name)
             }
         };
         if needs {
@@ -334,13 +357,40 @@ impl<'a> Monomorphizer<'a> {
                     self.rewrite_expr(s, env)?;
                 }
                 let subject_ty = m.subjects.first().map(|s| self.infer(s, env)).unwrap_or(PlumType::TInt);
+                // If the subject's concrete type is a specialized generic enum, its
+                // variant-name mangling table lets us rewrite this match's patterns
+                // (`Some`/`None` -> `Some$Int`/`None$Int`) to reference the correct
+                // specialization, so the checker/codegen's unmodified, bare-name-keyed
+                // `EnumVariants` lookup still resolves each pattern correctly.
+                let variant_mangling: Option<BTreeMap<String, String>> = match &subject_ty {
+                    PlumType::TNamed(n) => self.enum_variant_mangling.get(n).cloned(),
+                    _ => None,
+                };
                 for case in &mut m.cases {
                     let mut case_env = env.clone();
-                    if let Some(ast::CasePattern::Name(n)) = case.patterns.first() {
+                    if let Some(pat) = case.patterns.first_mut() {
+                        match pat {
+                            ast::CasePattern::Name(n) => {
-                        let is_variant = n.chars().next().map(|c| c.is_uppercase()).unwrap_or(false)
+                                let is_variant = n.chars().next().map(|c| c.is_uppercase()).unwrap_or(false)
-                            && self.enum_variants.contains_key(n);
+                                    && self.enum_variants.contains_key(n.as_str());
-                        if !is_variant {
+                                if is_variant {
+                                    if let Some(table) = &variant_mangling {
+                                        if let Some(mangled_variant) = table.get(n) {
+                                            *n = mangled_variant.clone();
+                                        }
+                                    }
+                                } else {
-                            case_env.insert(n.clone(), TypeScheme::mono(subject_ty.clone()));
+                                    case_env.insert(n.clone(), TypeScheme::mono(subject_ty.clone()));
+                                }
+                            }
+                            ast::CasePattern::Class { name, .. } => {
+                                if let Some(table) = &variant_mangling {
+                                    if let Some(mangled_variant) = table.get(name) {
+                                        *name = mangled_variant.clone();
+                                    }
+                                }
+                            }
+                            _ => {}
                         }
                     }
                     self.rewrite_block(&mut case.body, &mut case_env)?;
@@ -412,20 +462,81 @@ impl<'a> Monomorphizer<'a> {
         Ok(())
     }
+    /// The bare names of any generic class or enum referenced directly (not via a
+    /// lowercase-letter generic parameter) in `f`'s param types — e.g. `"Option"` for
+    /// `unwrapOr(o: Option, default: Int) -> Int`. See `fns_bare_generic`'s doc
+    /// comment for why such a function needs its own specialization.
+    fn fn_bare_generic_refs(&self, f: &ast::Fn) -> Vec<String> {
+        let mut names: Vec<String> = Vec::new();
+        for p in &f.params {
+            let n = match &p.ty {
+                ast::ParamType::Type(t) => &t.name,
+                ast::ParamType::Variadic(t) => &t.name,
+            };
+            if (self.classes_generic.contains_key(n.as_str()) || self.enums_generic_by_name.contains_key(n.as_str()))
+                && !names.iter().any(|x| x == n)
+            {
+                names.push(n.clone());
+            }
+        }
+        names
+    }
+    /// Resolves a call to an otherwise-ordinary function whose param type(s)
+    /// bare-name a generic class/enum, specializing it per call site exactly like a
+    /// truly-generic function — reusing the same `PendingSpecialization::Fn`
+    /// worklist entry and the unmodified `specialize_fn`, whose substitution
+    /// mechanism already replaces any type whose bare name matches a substitution
+    /// key (it doesn't care whether that key came from a lowercase-letter generic
+    /// parameter or a bare generic class/enum reference).
+    fn resolve_bare_generic_fn_instantiation(&mut self, call: &mut ast::FnCall, env: &TypeEnv) -> Result<(), String> {
+        let Some(f) = self.fns_bare_generic.get(call.name.as_str()).copied() else { return Ok(()) };
+        let refs = self.fn_bare_generic_refs(f);
+        let mut bindings: BTreeMap<String, PlumType> = BTreeMap::new();
+        for (param, arg) in f.params.iter().zip(call.args.iter()) {
+            let n = match &param.ty {
+                ast::ParamType::Type(t) => t.name.clone(),
+                ast::ParamType::Variadic(t) => t.name.clone(),
+            };
+            if refs.contains(&n) {
+                let arg_expr = match arg {
+                    ast::Arg::Positional(e) => e,
+                    ast::Arg::Keyword { value, .. } => value,
+                    ast::Arg::Pair { value, .. } => value,
+                };
+                bindings.entry(n).or_insert_with(|| self.infer(arg_expr, env));
+            }
+        }
+        if bindings.len() != refs.len() {
+            return Err(format!(
+                "monomorphize: could not resolve all generic parameters for '{}' at this call site",
+                call.name
+            ));
+        }
+        let type_args: Vec<PlumType> = refs.iter().map(|p| bindings[p].clone()).collect();
+        let mangled = mangle(&call.name, &type_args);
+        if !self.specialized.contains(&mangled) && !self.enqueued.contains(&mangled) {
+            self.enqueued.insert(mangled.clone());
+            self.worklist.push(PendingSpecialization::Fn { base: f, subst: Substitution(bindings), mangled: mangled.clone(), new_receiver: None });
+        }
+        call.name = mangled;
+        Ok(())
+    }
     /// Resolves a construction of a generic enum's variant (e.g. `Some(5)` for
-    /// `enum Option = | Some(a) | None`). Unlike class/function resolution, this
+    /// `enum Option = | Some(a) | None`), rewriting `call.name` from the bare
-    /// does NOT rewrite `call.name`: the variant name (`Some`) must stay exactly as
+    /// variant name (`Some`) to its mangled form (`Some$Int`) once the enum's own
-    /// declared — only the ENUM's own name is mangled (`Option$Int`), and the
-    /// specialized `ast::Enum` keeps its variants named `Some`/`None`. We only need
-    /// to enqueue the enum's specialization; the checker/codegen's `EnumVariants`
-    /// lookup (keyed by bare variant name) resolves `Some` correctly once the
-    /// concrete `Option$Int` is the only thing left in the output.
+    /// concrete instantiation is known. Mangling is eager and deterministic — it
+    /// doesn't wait for the worklist to actually produce the specialized `ast::Enum`
+    /// (see `enum_variant_mangling`'s doc comment).
     ///
     /// A variant that carries no generic fields (e.g. `None`) can't pin down the
     /// enum's type parameters on its own, so such a construction site is left alone
     /// here — some other construction site (e.g. `Some(5)`) is what drives the
-    /// specialization, and the bare `None` needs no rewriting either way.
+    /// specialization. (A bare `None` used as a *value*, not a call, is
+    /// `ast::Expr::TypeName` and doesn't go through this function at all — see the
+    /// plan's Global Constraints for that narrower, documented residual limitation.)
-    fn resolve_enum_instantiation(&mut self, call: &ast::FnCall, env: &TypeEnv) -> Result<(), String> {
+    fn resolve_enum_instantiation(&mut self, call: &mut ast::FnCall, env: &TypeEnv) -> Result<(), String> {
         let Some(e) = self.enums_generic_by_variant.get(call.name.as_str()).copied() else { return Ok(()) };
         let params = enum_generic_params(e);
         let Some(variant) = e.variants.iter().find(|v| v.name == call.name) else { return Ok(()) };
@@ -448,11 +559,41 @@ impl<'a> Monomorphizer<'a> {
         }
         let type_args: Vec<PlumType> = params.iter().map(|p| bindings[p].clone()).collect();
         let mangled = mangle(&e.name, &type_args);
+        // Populate the mangling table (and, crucially, teach `self.enum_variants`
+        // about the new mangled variant names too) the first time this exact
+        // specialization is seen. `self.enum_variants` was built once, up front,
+        // from the ORIGINAL source and only knows bare variant names — without
+        // this, `self.infer` on a rewritten construction site (which now names
+        // the MANGLED variant) would fail to resolve it via `enum_variants` and
+        // fall back to an uninformative `TVar`, which would in turn make a later
+        // `match` on that same value unable to tell which specialization it's
+        // matching and leave its patterns un-rewritten (a real bug: the produced
+        // enum's variants are mangled but its match patterns wouldn't be).
+        if !self.enum_variant_mangling.contains_key(&mangled) {
+            let mut table = BTreeMap::new();
+            for (tag, v) in e.variants.iter().enumerate() {
+                let mangled_variant = mangle(&v.name, &type_args);
+                table.insert(v.name.clone(), mangled_variant.clone());
+                let field_types: Vec<PlumType> = v.fields.iter().map(|f| {
+                    bindings.get(f).cloned().unwrap_or_else(|| {
+                        crate::plum_type_from_ast(&ast::Type { name: f.clone(), generics: vec![] })
+                    })
+                }).collect();
+                self.enum_variants.insert(mangled_variant, EnumVariantInfo {
+                    enum_name: mangled.clone(),
+                    tag: tag as i32,
+                    field_types,
+                });
+            }
+            self.enum_variant_mangling.insert(mangled.clone(), table);
+        }
         if !self.specialized.contains(&mangled) && !self.enqueued.contains(&mangled) {
             self.enqueued.insert(mangled.clone());
-            self.worklist.push(PendingSpecialization::Enum { base: e, subst: Substitution(bindings), mangled });
+            self.worklist.push(PendingSpecialization::Enum { base: e, subst: Substitution(bindings), mangled: mangled.clone() });
         }
-        // Intentionally NOT rewriting `call.name` — see doc comment.
+        call.name = self.enum_variant_mangling[&mangled][&variant.name].clone();
         Ok(())
     }
@@ -475,10 +616,13 @@ impl<'a> Monomorphizer<'a> {
                 }
                 // A `FnCall` may name either a generic free function or a generic
                 // enum's variant; the two name spaces don't overlap (variants are
-                // capitalized), so checking both is safe. Enum resolution never
+                // capitalized). Enum resolution runs first and rewrites `call.name`
+                // to its mangled form when it resolves — `fns_generic` is keyed by
+                // the ORIGINAL unmangled free-function names, so a rewritten variant
-                // rewrites `call.name`, so order doesn't matter.
+                // name can never accidentally match it afterward.
                 self.resolve_enum_instantiation(call, env)?;
                 self.resolve_fn_instantiation(call, env)?;
+                self.resolve_bare_generic_fn_instantiation(call, env)?;
             }
             ast::Expr::Attribute(attr) => {
                 self.rewrite_expr(&mut attr.object, env)?;
@@ -540,7 +684,9 @@ pub fn monomorphize_source(source: &ast::Source) -> Result<ast::Source, String>
         fns_generic: BTreeMap::new(),
         methods_generic_on: BTreeMap::new(),
         enums_generic_by_variant: BTreeMap::new(),
+        enums_generic_by_name: BTreeMap::new(),
-        enum_variant_owner: BTreeMap::new(),
+        enum_variant_mangling: BTreeMap::new(),
+        fns_bare_generic: BTreeMap::new(),
         global_env,
         classes,
         methods,
@@ -555,6 +701,7 @@ pub fn monomorphize_source(source: &ast::Source) -> Result<ast::Source, String>
         match item {
             ast::Item::Class(c) if !c.generics.is_empty() => { m.classes_generic.insert(c.name.clone(), c); }
             ast::Item::Enum(e) if !enum_generic_params(e).is_empty() => {
+                m.enums_generic_by_name.insert(e.name.clone(), e);
                 for v in &e.variants {
                     m.enums_generic_by_variant.insert(v.name.clone(), e);
                 }
@@ -569,11 +716,13 @@ pub fn monomorphize_source(source: &ast::Source) -> Result<ast::Source, String>
                 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);
+            } else if f.type_param.is_none() && !m.fn_bare_generic_refs(f).is_empty() {
+                m.fns_bare_generic.insert(f.name.clone(), f);
             }
             // A method whose receiver is NOT generic is left as a regular method below,
             // even if its own params/return happen to use a bare lowercase-letter type
-            // name — that shape (a method introducing its own extra generic parameter)
+            // name, or bare-name a generic class/enum — those shapes are out of scope
-            // is out of scope for this pass; see the plan's Global Constraints.
+            // for this pass; see the plan's Global Constraints.
         }
     }
@@ -586,7 +735,8 @@ pub fn monomorphize_source(source: &ast::Source) -> Result<ast::Source, String>
             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();
+                let is_bare_generic_fn = f.type_param.is_none() && m.fns_bare_generic.contains_key(f.name.as_str());
-                if !receiver_is_generic && !is_generic_fn {
+                if !receiver_is_generic && !is_generic_fn && !is_bare_generic_fn {
                     let mut f2 = f.clone();
                     m.rewrite_fn_body(&mut f2, false)?;
                     m.produced.push(ast::Item::Fn(f2));
@@ -653,26 +803,6 @@ pub fn monomorphize_source(source: &ast::Source) -> Result<ast::Source, String>
             PendingSpecialization::Enum { base, subst, mangled } => {
                 if !m.specialized.insert(mangled.clone()) { continue; }
                 let spec_enum = specialize_enum(base, &subst, &mangled);
-                // Claim each bare variant name for this mangled enum. If a DIFFERENT
-                // mangled enum already owns it, this generic enum is being
-                // instantiated at more than one concrete type in the same program —
-                // which the flat, bare-variant-name-keyed `EnumVariants` runtime
-                // table can't represent (both would register under `"Some"`). Rather
-                // than silently let the second specialization corrupt the first, we
-                // fail with a clear, specific error. (Re-claiming by the SAME mangled
-                // enum can't reach here — worklist dedup + the `specialized` guard
-                // above ensure each mangled enum is produced exactly once.)
-                for v in &spec_enum.variants {
-                    if let Some(owner) = m.enum_variant_owner.get(&v.name) {
-                        if owner != &mangled {
-                            return Err(format!(
-                                "monomorphize: generic enum '{}' is instantiated at more than one concrete type in the same program ('{}' and '{}'), which is not yet supported. Only a single concrete instantiation per generic enum is allowed (variant '{}' would collide in the global variant table). This is a known, documented limitation, not a bug.",
-                                base.name, owner, mangled, v.name
-                            ));
-                        }
-                    }
-                    m.enum_variant_owner.insert(v.name.clone(), mangled.clone());
-                }
                 m.produced.push(ast::Item::Enum(spec_enum));
             }
         }

plum-checker/tests/checker_tests.rs CHANGED Viewed

@@ -408,9 +408,10 @@ get() -> Int =
     assert!(result.is_ok(), "expected Ok, got {:?}", result.err());
     // Directly prove resolution happened: the monomorphized output must contain a
-    // concrete `Option$Int` enum whose `Some` variant carries an `Int` field (not
+    // concrete `Option$Int` enum whose `Some$Int` variant carries an `Int` field
-    // the generic `a`), and must NOT retain the generic `Option` template. The
+    // (not the generic `a`), and must NOT retain the generic `Option` template.
-    // variant name itself stays `Some` (only the enum's own name is mangled).
+    // The variant name is ALSO mangled (`Some` -> `Some$Int`), the same suffix as
+    // the enum's own name.
     let mono = plum_checker::monomorphize::monomorphize_source(&source)
         .expect("monomorphize should succeed");
     let opt = mono.items.iter().find_map(|it| match it {
@@ -418,8 +419,8 @@ get() -> Int =
         _ => None,
     });
     let opt = opt.expect("expected a specialized `Option$Int` enum in the output");
-    let some = opt.variants.iter().find(|v| v.name == "Some")
+    let some = opt.variants.iter().find(|v| v.name == "Some$Int")
-        .expect("expected `Some` variant on `Option$Int`");
+        .expect("expected `Some$Int` (mangled) variant on `Option$Int`");
     assert_eq!(some.fields, vec!["Int".to_string()], "Some's field should be concrete Int");
     assert!(
         !mono.items.iter().any(|it| matches!(it, Item::Enum(e) if e.name == "Option")),
@@ -428,10 +429,10 @@ get() -> Int =
 }
 #[test]
-fn generic_enum_multi_instantiation_is_a_clear_error() {
+fn generic_enum_multiple_instantiations_coexist_and_type_check() {
     // The SAME generic enum instantiated at two different concrete types in one
-    // program is a known, documented limitation — it must fail with a clear
+    // program must now type-check correctly for BOTH instantiations — this is the
-    // monomorphize error rather than silently corrupting one specialization.
+    // behavior this task adds (previously this was a documented, rejected limitation).
     let src = "\
 enum Option =
   | Some(a)
@@ -455,14 +456,18 @@ useStr() -> Str =
 ";
     let source = parse(src);
     let result = check_source(&source);
-    let errs = result.err().expect("expected a monomorphize collision error, got Ok");
+    assert!(result.is_ok(), "expected Ok, got {:?}", result.err());
+    // Directly prove both specializations exist independently, with distinct
+    // mangled variant names, so neither collides with the other.
+    let mono = plum_checker::monomorphize::monomorphize_source(&source)
-    assert!(
+        .expect("monomorphize should succeed");
+    let has_enum_with_variant = |enum_name: &str, variant_name: &str| {
-        errs.iter().any(|e| e.message.contains("monomorphize")
+        mono.items.iter().any(|it| matches!(it, Item::Enum(e) if e.name == enum_name
-            && e.message.contains("Option")
-            && e.message.contains("more than one concrete type")),
+            && e.variants.iter().any(|v| v.name == variant_name)))
-        "expected a clear monomorphize multi-instantiation error, got {:?}",
-        errs
-    );
+    };
+    assert!(has_enum_with_variant("Option$Int", "Some$Int"), "expected Option$Int with Some$Int");
+    assert!(has_enum_with_variant("Option$Str", "Some$Str"), "expected Option$Str with Some$Str");
 }
 #[test]
@@ -510,3 +515,60 @@ use() -> Int =
     let errs = result.unwrap_err();
     assert!(errs[0].message.contains("monomorphize"), "got: {:?}", errs);
 }
+#[test]
+fn ordinary_function_with_bare_generic_enum_param_type_checks() {
+    // The shape that broke the pre-existing codegen test: an otherwise-ordinary
+    // function taking a bare generic-enum-typed parameter.
+    let src = "\
+enum Option =
+  | Some(a)
+  | None
+unwrapOr(o: Option, default: Int) -> Int =
+  match o
+    Some(v) =>
+      v
+    None =>
+      default
+use() -> Int =
+  unwrapOr(Some(5), 0)
+";
+    let source = parse(src);
+    let result = check_source(&source);
+    assert!(result.is_ok(), "expected Ok, got {:?}", result.err());
+    // Directly prove `unwrapOr` itself got specialized (not left bare/unresolved).
+    let mono = plum_checker::monomorphize::monomorphize_source(&source)
+        .expect("monomorphize should succeed");
+    let has_specialized_unwrap_or = mono.items.iter().any(|it| matches!(it, Item::Fn(f)
+        if f.name.starts_with("unwrapOr$") && f.type_param.is_none()));
+    assert!(has_specialized_unwrap_or, "expected a specialized `unwrapOr$...` function in the output");
+}
+#[test]
+fn ordinary_function_with_bare_generic_class_param_type_checks() {
+    // The same shape, for a generic CLASS param instead of an enum — untested until
+    // now, but the identical root cause: `Box` is dropped from the monomorphized
+    // output, so a bare `Box`-typed param would otherwise reference nothing.
+    let src = "\
+type Box(a) =
+  value: a
+getBoxValue<Box>() -> a =
+  self.value
+sumBox(b: Box) -> Int =
+  b.getBoxValue()
+use() -> Int =
+  sumBox(Box(value: 5))
+";
+    let source = parse(src);
+    let result = check_source(&source);
+    assert!(result.is_ok(), "expected Ok, got {:?}", result.err());
+}

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

@@ -776,3 +776,59 @@ main() -> Int =
     let bytes = compile_source(&source).expect("compile failed");
     assert_eq!(run_main(&bytes), 13);
 }
+#[test]
+fn generic_enum_multiple_instantiations_coexist_and_run_correctly() {
+    // `Str.length()` is not a real, working method in this codebase (no built-in
+    // Str methods exist in codegen, and string-literal match patterns are an
+    // explicit, documented "not yet supported" error — see
+    // `match_string_pattern_is_a_clear_error` above). So the `Some(v) => ...` arm
+    // for the Str instantiation returns a fixed literal instead of deriving
+    // anything from `v`'s content; the point of this test is that `Option$Str`
+    // coexists with `Option$Int` and both run correctly, not string processing.
+    let src = "\
+enum Option =
+  | Some(a)
+  | None
+unwrapIntOr(o: Option, default: Int) -> Int =
+  match o
+    Some(v) =>
+      v
+    None =>
+      default
+unwrapStrOr(o: Option, default: Int) -> Int =
+  match o
+    Some(v) =>
+      4
+    None =>
+      default
+main() -> Int =
+  unwrapIntOr(Some(13), 0) + unwrapStrOr(Some(\"abcd\"), 0)
+";
+    let source = parse(src);
+    let bytes = compile_source(&source).expect("compile failed");
+    assert_eq!(run_main(&bytes), 17);
+}
+#[test]
+fn ordinary_function_with_bare_generic_class_param_runs_correctly() {
+    let src = "\
+type Box(a) =
+  value: a
+getBoxValue<Box>() -> Int =
+  self.value
+sumBox(b: Box) -> Int =
+  b.getBoxValue()
+main() -> Int =
+  sumBox(Box(value: 11))
+";
+    let source = parse(src);
+    let bytes = compile_source(&source).expect("compile failed");
+    assert_eq!(run_main(&bytes), 11);
+}