c273ea5 | plum

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

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

c273ea5 — Peter John 2026-07-20T16:01:25+05:30

fix(plum-checker): stop masking type errors in specializations; resolve generic enum instantiation

Files changed (8) hide show

plum-checker/src/monomorphize.rs +112 -7
plum-checker/tests/checker_tests.rs +101 -0
plum-core/src/parser.rs +5 -3
tooling/tree-sitter-plum/grammar.js +1 -1
tooling/tree-sitter-plum/src/grammar.json +0 -0
tooling/tree-sitter-plum/src/node-types.json +0 -0
tooling/tree-sitter-plum/src/parser.c +0 -0
tooling/tree-sitter-plum/test/corpus/enum.txt +19 -0

plum-checker/src/monomorphize.rs CHANGED Viewed

@@ -173,7 +173,6 @@ 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 },
 }
@@ -181,6 +180,17 @@ 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>>,
+    /// Bare variant name (e.g. `"Some"`) -> the generic `Enum` it belongs to. Keyed
+    /// 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.
+    /// Because the runtime `EnumVariants` table is keyed by BARE variant name
+    /// globally, two specializations of the same generic enum would both try to
+    /// register `"Some"`, silently colliding. We detect that here and error rather
+    /// than corrupt one specialization (single-instantiation-per-generic-enum is a
+    /// documented limitation of this pass).
+    enum_variant_owner: BTreeMap<String, String>,
     global_env: TypeEnv,
     classes: ClassEnv,
     methods: MethodEnv,
@@ -238,9 +248,28 @@ impl<'a> Monomorphizer<'a> {
     }
     /// Overwrites `f.returns` with a concrete type derived from the body's tail
-    /// type `t` when the currently-declared return type is generic/unresolved.
+    /// type `t` when the currently-declared return type is genuinely generic or
-    /// Never clobbers a genuine concrete annotation on an ordinary function, and
+    /// unresolved. Never clobbers a real, concrete declared return type — even for
+    /// a specialization (`resolve_return: true`) — so a generic function whose body
+    /// is internally inconsistent with its concrete declared return (e.g.
+    /// `wrong(x: a) -> Int = "hello"`) is left for the checker's normal
+    /// return-type-mismatch logic to REJECT rather than silently rewritten (and
+    /// thereby masked). The overwrite fires only when:
+    ///   - `f.returns` is `None` — the unparseable `-> a` generic-parameter-return
+    ///     case, where the grammar dropped the annotation entirely (this only ever
+    ///     happens for a specialization, which is the only path that can supply a
+    ///     concrete tail type to fill it in); or
+    ///   - the declared return names something still-generic: a generic-parameter
+    ///     letter (e.g. `-> a`) or a generic class used bare (e.g. `-> Box`).
+    /// For the `Some(rt)` arm this condition is identical whether `resolve_return`
+    /// is `true` or `false`; the specialization path differs only in that its tail
+    /// is inferred against a resolved substitution, so a generic-parameter-letter
+    /// return resolves to the specialization's concrete bound type (which the
+    /// ordinary path cannot do). The unparseable-`None` fill-in is gated on
+    /// `resolve_return` so an ordinary void function (`returns: None` meaning "no
+    /// declared return", not "a generic return the grammar dropped") is never given
-    /// never fabricates a return type from an un-inferrable (`TVar`) tail.
+    /// a fabricated return type. Never fabricates a return 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;
@@ -248,8 +277,7 @@ impl<'a> Monomorphizer<'a> {
         let needs = match &f.returns {
             None => resolve_return,
             Some(rt) => {
-                resolve_return
-                    || is_generic_param_name(&rt.name)
+                is_generic_param_name(&rt.name)
                     || self.classes_generic.contains_key(&rt.name)
             }
         };
@@ -384,6 +412,50 @@ impl<'a> Monomorphizer<'a> {
         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
+    /// does NOT rewrite `call.name`: the variant name (`Some`) must stay exactly as
+    /// 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.
+    ///
+    /// 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.
+    fn resolve_enum_instantiation(&mut self, call: &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(()) };
+        let mut bindings: BTreeMap<String, PlumType> = BTreeMap::new();
+        for (field_ty_name, arg) in variant.fields.iter().zip(call.args.iter()) {
+            if params.contains(field_ty_name) {
+                let arg_expr = match arg {
+                    ast::Arg::Positional(e) => e,
+                    ast::Arg::Keyword { value, .. } => value,
+                    ast::Arg::Pair { value, .. } => value,
+                };
+                bindings.entry(field_ty_name.clone()).or_insert_with(|| self.infer(arg_expr, env));
+            }
+        }
+        // This single construction site couldn't pin down every generic parameter
+        // (e.g. a payload-free `None`, or a variant that mentions only some of a
+        // multi-parameter enum's params). Leave it for another site to drive.
+        if bindings.len() != params.len() {
+            return Ok(());
+        }
+        let type_args: Vec<PlumType> = params.iter().map(|p| bindings[p].clone()).collect();
+        let mangled = mangle(&e.name, &type_args);
+        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 });
+        }
+        // Intentionally NOT rewriting `call.name` — see doc comment.
+        Ok(())
+    }
     fn rewrite_expr(&mut self, expr: &mut ast::Expr, env: &TypeEnv) -> Result<(), String> {
         match expr {
             ast::Expr::ClassCall(call) => {
@@ -401,6 +473,11 @@ impl<'a> Monomorphizer<'a> {
                     };
                     self.rewrite_expr(e, env)?;
                 }
+                // 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
+                // rewrites `call.name`, so order doesn't matter.
+                self.resolve_enum_instantiation(call, env)?;
                 self.resolve_fn_instantiation(call, env)?;
             }
             ast::Expr::Attribute(attr) => {
@@ -462,6 +539,8 @@ pub fn monomorphize_source(source: &ast::Source) -> Result<ast::Source, String>
         classes_generic: BTreeMap::new(),
         fns_generic: BTreeMap::new(),
         methods_generic_on: BTreeMap::new(),
+        enums_generic_by_variant: BTreeMap::new(),
+        enum_variant_owner: BTreeMap::new(),
         global_env,
         classes,
         methods,
@@ -475,6 +554,11 @@ pub fn monomorphize_source(source: &ast::Source) -> Result<ast::Source, String>
     for item in &source.items {
         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() => {
+                for v in &e.variants {
+                    m.enums_generic_by_variant.insert(v.name.clone(), e);
+                }
+            }
             _ => {}
         }
     }
@@ -568,7 +652,28 @@ pub fn monomorphize_source(source: &ast::Source) -> Result<ast::Source, String>
             }
             PendingSpecialization::Enum { base, subst, mangled } => {
                 if !m.specialized.insert(mangled.clone()) { continue; }
-                m.produced.push(ast::Item::Enum(specialize_enum(base, &subst, &mangled)));
+                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

@@ -364,6 +364,107 @@ use() -> Bool =
     assert!(result.is_ok(), "expected Ok, got {:?}", result.err());
 }
+#[test]
+fn generic_function_with_internally_inconsistent_body_is_rejected_after_specialization() {
+    // A generic function whose body is genuinely inconsistent with its concrete,
+    // correct declared return type must still be REJECTED after specialization.
+    // The `-> Str` on `useIt` means the buggy (unconditional return-overwrite)
+    // behavior — rewriting `wrong$Str`'s `-> Int` to `-> Str` — would make the
+    // whole program type-check, masking the real `expected Int, found Str` error.
+    let src = "\
+wrong(x: a) -> Int =
+  \"hello\"
+useIt() -> Str =
+  wrong(\"s\")
+";
+    let source = parse(src);
+    let result = check_source(&source);
+    assert!(
+        result.is_err(),
+        "expected the internally-inconsistent generic function to be rejected, got Ok"
+    );
+}
+#[test]
+fn generic_enum_single_instantiation_type_checks() {
+    // A generic Option-shaped enum, constructed at one concrete type (`Some(5)`),
+    // matched, must resolve end-to-end via check_source.
+    let src = "\
+enum Option =
+  | Some(a)
+  | None
+get() -> Int =
+  o = Some(5)
+  match o
+    Some(v) =>
+      v
+    None =>
+      0
+";
+    let source = parse(src);
+    let result = check_source(&source);
+    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
+    // the generic `a`), and must NOT retain the generic `Option` template. The
+    // variant name itself stays `Some` (only the enum's own name is mangled).
+    let mono = plum_checker::monomorphize::monomorphize_source(&source)
+        .expect("monomorphize should succeed");
+    let opt = mono.items.iter().find_map(|it| match it {
+        Item::Enum(e) if e.name == "Option$Int" => Some(e),
+        _ => None,
+    });
+    let opt = opt.expect("expected a specialized `Option$Int` enum in the output");
+    let some = opt.variants.iter().find(|v| v.name == "Some")
+        .expect("expected `Some` 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")),
+        "the generic `Option` template must be dropped from the output"
+    );
+}
+#[test]
+fn generic_enum_multi_instantiation_is_a_clear_error() {
+    // The SAME generic enum instantiated at two different concrete types in one
+    // program is a known, documented limitation — it must fail with a clear
+    // monomorphize error rather than silently corrupting one specialization.
+    let src = "\
+enum Option =
+  | Some(a)
+  | None
+useInt() -> Int =
+  o = Some(5)
+  match o
+    Some(v) =>
+      v
+    None =>
+      0
+useStr() -> Str =
+  o = Some(\"x\")
+  match o
+    Some(v) =>
+      v
+    None =>
+      \"z\"
+";
+    let source = parse(src);
+    let result = check_source(&source);
+    let errs = result.err().expect("expected a monomorphize collision error, got Ok");
+    assert!(
+        errs.iter().any(|e| e.message.contains("monomorphize")
+            && e.message.contains("Option")
+            && e.message.contains("more than one concrete type")),
+        "expected a clear monomorphize multi-instantiation error, got {:?}",
+        errs
+    );
+}
 #[test]
 fn generic_method_on_generic_class_type_checks() {
     let src = "\

plum-core/src/parser.rs CHANGED Viewed

@@ -169,12 +169,14 @@ impl<'a> AstParser<'a> {
     }
     fn parse_enum_variant(&self, node: Node) -> EnumVariant {
-        // enum_field (aliased to field): "|" type_identifier ("(" type_identifier,* ")")?
+        // enum_field (aliased to field): "|" type_identifier ("(" (type_identifier | generic),* ")")?
-        // named children: type_identifier (name), type_identifier* (fields inside "()")
+        // named children: type_identifier (name), then each field type inside "()" — a
+        // `type_identifier` (concrete, e.g. `Int`) or an inlined generic letter node
+        // (`a`/`b`/`c`/`d`, since `generic` is inlined in the grammar).
         let name = node.named_child(0).map(|n| self.text(n)).unwrap_or_default();
         let fields: Vec<String> = (1..node.named_child_count())
             .filter_map(|i| node.named_child(i as u32))
-            .filter(|n| n.kind() == "type_identifier")
+            .filter(|n| matches!(n.kind(), "type_identifier" | "a" | "b" | "c" | "d"))
             .map(|n| self.text(n))
             .collect();
         EnumVariant { name, fields }

tooling/tree-sitter-plum/grammar.js CHANGED Viewed

@@ -146,7 +146,7 @@ module.exports = grammar({
       seq(
         "|",
         field("name", $.type_identifier),
-        field("parameters", optional(seq("(", commaSep1($.type_identifier), ")"))),
+        field("parameters", optional(seq("(", commaSep1(choice($.type_identifier, $.generic)), ")"))),
       ),
     fn: ($) =>

tooling/tree-sitter-plum/src/grammar.json CHANGED Viewed

Binary file

tooling/tree-sitter-plum/src/node-types.json CHANGED Viewed

Binary file

tooling/tree-sitter-plum/src/parser.c CHANGED Viewed

Binary file

tooling/tree-sitter-plum/test/corpus/enum.txt CHANGED Viewed

@@ -31,3 +31,22 @@ toStr<Bool>() -> Str =
             (string_start)
             (string_content)
             (string_end)))))))
+================================================================================
+enum - generic variant fields
+================================================================================
+enum Option =
+  | Some(a)
+  | None
+--------------------------------------------------------------------------------
+(source
+  (enum
+    (type_identifier)
+    (field
+      (type_identifier)
+      (a))
+    (field
+      (type_identifier))))