3c73b0b | plum | pyrossh

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

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

3c73b0b — Peter John 2026-11-01T21:26:50+05:30

feat: Array[T] is a generic primitive, not a fake single-variant enum; legacy exemption removed

Files changed (7) hide show

plum-checker/src/lib.rs +17 -0
plum-core/src/ast.rs +2 -0
plum-core/src/loader.rs +2 -25
plum-core/src/parser.rs +1 -0
plum-std/Array.plum +9 -3
plum-wasm-codegen/src/lib.rs +6 -1
plum-wasm-codegen/tests/codegen_tests.rs +2 -4

plum-checker/src/lib.rs CHANGED Viewed

@@ -1013,6 +1013,23 @@ pub fn buildGlobalTables(source: &ast::Source) -> (TypeEnv, MethodEnv, EnumVaria
         }
     }
+    // A generic builtin `primitive` (`Array[T]`) has no variants; its generic
+    // parameters are recorded under an unnameable key so `enumGenericsOf` finds them.
+    for p in source.primitives.iter().filter(|p| !p.generics.is_empty()) {
+        enum_variants.insert(
+            format!("<primitive {}>", p.name),
+            EnumVariantInfo {
+                enum_name: p.name.clone(),
+                tag: 0,
+                field_types: Vec::new(),
+                field_names: Vec::new(),
+                values: Vec::new(),
+                generics: p.generics.clone(),
+                is_value: false,
+            },
+        );
+    }
     // Second pass: register top-level function/method signatures and consts.
     // Methods (`name<Receiver>(...)`) live in `methods`, keyed by receiver type,
     // so a bare call can't accidentally resolve to some other type's method.

plum-core/src/ast.rs CHANGED Viewed

@@ -33,6 +33,8 @@ pub struct PrimitiveDecl {
     pub name: String,
     pub line: usize,
     pub column: usize,
+    /// The type's own generic parameter names (`Array[T]`).
+    pub generics: Vec<String>,
     /// The first `fun` in the block that declares `self` (name, line, column).
     pub selfFn: Option<(String, usize, usize)>,
 }

plum-core/src/loader.rs CHANGED Viewed

@@ -254,30 +254,7 @@ fn mergeItems(
     prims: &mut Vec<PrimitiveDecl>,
 ) -> Result<(), String> {
     // Removed forms (inline variant payloads, lone self-named variant).
-    // A payload-less self-named single variant (`enum Array[T] = | Array`)
-    // is an opaque builtin handle and stays legal.
-    let opaque: Vec<String> = source
-        .items
-        .iter()
-        .filter_map(|i| match i {
-            Item::Enum(e)
-                if e.variants.len() == 1
-                    && e.variants[0].name == e.name
-                    && e.variants[0].fields.is_empty()
-                    && e.variants[0].values.is_empty() =>
-            {
-                Some(format!(
-                    "enum {0} has a single variant named {0} — write record {0}(...)",
-                    e.name
-                ))
-            }
-            _ => None,
-        })
-        .collect();
-    let legacy: Vec<String> = crate::unions::legacyErrors(source)
+    let legacy: Vec<String> = crate::unions::legacyErrors(source);
-        .into_iter()
-        .filter(|m| !opaque.contains(m))
-        .collect();
     if !legacy.is_empty() {
         return Err(legacy.join("\n"));
     }
@@ -289,7 +266,7 @@ fn mergeItems(
         source
             .primitives
             .iter()
-            .filter(|p| !BUILTIN_PRIMITIVES.contains(&p.name.as_str()))
+            .filter(|p| !BUILTIN_PRIMITIVES.contains(&p.name.as_str()) || !p.generics.is_empty())
             .cloned(),
     );
     for item in &source.items {

plum-core/src/parser.rs CHANGED Viewed

@@ -112,6 +112,7 @@ impl<'a> AstParser<'a> {
                         name: name.clone(),
                         line: pos.row + 1,
                         column: pos.column + 1,
+                        generics: self.parseGenericsField(child).into_iter().map(|g| g.name).collect(),
                         selfFn,
                     });
                     for c in consts {

plum-std/Array.plum CHANGED Viewed

@@ -1,6 +1,7 @@
 module std
 import std/Int
 import std/Float
+import std/Str
 # A fixed-length, O(1)-indexable array of `T`, backed directly by a wasm-gc
 # `array<anyref>` — `Array[T]` is erased, so every `T` shares the SAME
@@ -29,9 +30,7 @@ import std/Float
 # hood — so `get` on an index that was never `set` traps rather than
 # returning some default `T` value (there is no way to conjure a default `T`
 # generically).
-enum Array[T] =
+primitive Array[T] =
-  | Array
   # A new, empty array.
   fun init() -> Array[T] =
     todo
@@ -76,3 +75,10 @@ enum Array[T] =
       a.set(i, v)
       i = i + 1
     return a
+test "Array is a primitive with working generic methods"
+  a := Array[Str]().push("x").push("y")
+  assert a.length() == 2
+  assert a.get(1) == "y"
+  b := Array.filled(3, 7)
+  assert b.at(2) == 7

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

@@ -1156,13 +1156,13 @@ fn buildGcTypeRegistry(
         });
         reg.app_super.insert(a.clone(), idx);
         reg.app_class.insert(a.clone(), idx);
-        reg.app_variant.insert((a.clone(), "Array".to_string()), idx);
     }
     let enum_generics = |n: &str| -> Vec<String> {
         enum_decls
             .get(n)
             .map(|e| e.generics.iter().map(|g| g.name.clone()).collect())
+            .or_else(|| source.primitives.iter().find(|p| p.name == n).map(|p| p.generics.clone()))
             .unwrap_or_default()
     };
     let subst_for = |ty: &PlumType| -> std::collections::BTreeMap<String, PlumType> {
@@ -1856,6 +1856,11 @@ fn compileSourceInner(
             eg.insert(e.name.clone(), e.generics.iter().map(|g| g.name.clone()).collect());
         }
     }
+    for p in &source.primitives {
+        if !p.generics.is_empty() {
+            eg.insert(p.name.clone(), p.generics.clone());
+        }
+    }
     // ---- units: every non-generic fn, plus one per reached instantiation ----
     let all_fns: Vec<&ast::Fn> = source

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

@@ -3072,16 +3072,14 @@ primitive Alpha =
 primitive Beta =
   X = 20
-enum Gamma =
+record Gamma(n: Int) =
-  | Gamma
   X = 300
   fun sum(self) -> Int =
     X + Alpha.X + Beta.X
 fun main() -> Int =
-  g := Gamma
+  g := Gamma(n: 0)
   Alpha.X + Beta.X + Gamma.X + g.sum()
 ", STD_HEAD);
     assert_eq!(runMerged::<i64>("const_names", &src), 1 + 20 + 300 + 321);