fbfbd7b | plum

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

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

fbfbd7b — Peter John 2026-08-09T18:47:56+05:30

feat(plum-core): parse enum discriminant-value declarations

Files changed (4) hide show

plum-checker/src/monomorphize.rs +2 -0
plum-core/src/ast.rs +8 -0
plum-core/src/parser.rs +29 -7
plum-core/tests/parser_test.rs +20 -0

plum-checker/src/monomorphize.rs CHANGED Viewed

@@ -168,11 +168,13 @@ pub fn specialize_enum(e: &ast::Enum, subst: &Substitution, mangled_name: &str)
     let type_args: Vec<PlumType> = params.iter().filter_map(|p| subst.get(p).cloned()).collect();
     ast::Enum {
         name: mangled_name.to_string(),
+        params: e.params.clone(),
         variants: e.variants.iter().map(|v| ast::EnumVariant {
             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(),
+            values: v.values.clone(),
         }).collect(),
     }
 }

plum-core/src/ast.rs CHANGED Viewed

@@ -63,13 +63,21 @@ pub struct TraitMethod {
 #[derive(Debug, Clone, PartialEq)]
 pub struct Enum {
     pub name: String,
+    pub params: Vec<EnumParam>,
     pub variants: Vec<EnumVariant>,
 }
+#[derive(Debug, Clone, PartialEq)]
+pub struct EnumParam {
+    pub name: String,
+    pub ty: Type,
+}
 #[derive(Debug, Clone, PartialEq)]
 pub struct EnumVariant {
     pub name: String,
     pub fields: Vec<String>,
+    pub values: Vec<Expr>,
 }
 // ---------- Functions ----------

plum-core/src/parser.rs CHANGED Viewed

@@ -198,24 +198,46 @@ impl<'a> AstParser<'a> {
     fn parse_enum(&self, node: Node) -> Enum {
         let name = node.named_child(0).map(|n| self.text(n)).unwrap_or_default();
+        let params = self.children_of_kind(node, "enum_param")
+            .into_iter()
+            .map(|n| self.parse_enum_param(n))
+            .collect();
         let variants = self.children_of_kind(node, "field")
             .into_iter()
             .map(|f| self.parse_enum_variant(f))
             .collect();
-        Enum { name, variants }
+        Enum { name, params, variants }
+    }
+    fn parse_enum_param(&self, node: Node) -> EnumParam {
+        // enum_param: var_identifier ":" type
+        let name = node.named_child(0).map(|n| self.text(n)).unwrap_or_default();
+        let ty = node
+            .named_child(1)
+            .map(|n| self.parse_type(n))
+            .unwrap_or(Type { name: String::new(), generics: vec![] });
+        EnumParam { name, ty }
     }
     fn parse_enum_variant(&self, node: Node) -> EnumVariant {
-        // enum_field (aliased to field): "|" type_identifier ("[" (type_identifier | generic),* "]")?
+        // enum_field (aliased to field): "|" type_identifier
+        //   ("[" (type_identifier | generic),* "]")?     -- existing: generic type payload
+        //   | ("(" expression,* ")")?                    -- new: discriminant value literals
-        // named children: type_identifier (name), then each field type inside "[]" — a
+        // named children after the name: either type_identifier/generic (fields) or
-        // `type_identifier` (concrete, e.g. `Int`) or a `generic` node (single uppercase letter).
+        // expression (values) — the two are disjoint child-kind sets, never mixed.
         let name = node.named_child(0).map(|n| self.text(n)).unwrap_or_default();
-        let fields: Vec<String> = (1..node.named_child_count())
+        let rest: Vec<Node> = (1..node.named_child_count())
             .filter_map(|i| node.named_child(i as u32))
+            .collect();
+        let fields: Vec<String> = rest.iter()
             .filter(|n| matches!(n.kind(), "type_identifier" | "generic"))
-            .map(|n| self.text(n))
+            .map(|n| self.text(*n))
+            .collect();
+        let values: Vec<Expr> = rest.iter()
+            .filter(|n| n.kind() == "expression")
+            .map(|n| { let u = self.unwrap_expr_node(*n); self.parse_expression(u) })
             .collect();
-        EnumVariant { name, fields }
+        EnumVariant { name, fields, values }
     }
     // ---- functions --------------------------------------------------------

plum-core/tests/parser_test.rs CHANGED Viewed

@@ -18,6 +18,10 @@ fn only_trait(source: &Source) -> &Trait {
     source.items.iter().find_map(|i| match i { Item::Trait(t) => Some(t), _ => None }).expect("expected a Trait item")
 }
+fn only_enum(source: &Source) -> &Enum {
+    source.items.iter().find_map(|i| match i { Item::Enum(e) => Some(e), _ => None }).expect("expected an Enum item")
+}
 #[test]
 fn nested_class_methods_become_top_level_fn_items_with_type_param_set() {
     let src = "\
@@ -63,6 +67,22 @@ enum Step =
     assert_eq!(to_number.type_param, Some("Step".to_string()));
 }
+#[test]
+fn enum_discriminant_values_parse_into_params_and_variant_values() {
+    let src = "\
+enum Step(n: Int) =
+  | ReadMin(0)
+  | ReadMax(1)
+";
+    let source = parse(src);
+    let e = only_enum(&source);
+    assert_eq!(e.params, vec![EnumParam { name: "n".to_string(), ty: Type { name: "Int".to_string(), generics: vec![] } }]);
+    assert_eq!(e.variants[0].fields, Vec::<String>::new());
+    assert_eq!(e.variants[0].values, vec![Expr::Int(0)]);
+    assert_eq!(e.variants[1].fields, Vec::<String>::new());
+    assert_eq!(e.variants[1].values, vec![Expr::Int(1)]);
+}
 #[test]
 fn class_and_enum_with_no_nested_methods_produce_no_extra_fn_items() {
     let src = "\