78eed27 | plum | pyrossh

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

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

78eed27 — Peter John 2026-11-01T21:38:06+05:30

refactor: real CheckCtx field for primitive generics

Files changed (5) hide show

plum-checker/src/lib.rs +17 -17
plum-checker/tests/checker_tests.rs +2 -0
plum-checker/tests/primitive_generics_test.rs +43 -0
plum-lsp/src/main.rs +2 -0
plum-wasm-codegen/src/lib.rs +10 -1

plum-checker/src/lib.rs CHANGED Viewed

@@ -429,6 +429,7 @@ fn enumGenericsOf<'a>(name: &str, ctx: &'a CheckCtx) -> &'a [String] {
         .values()
         .find(|i| i.enum_name == name)
         .map(|i| i.generics.as_slice())
+        .or_else(|| ctx.primitive_generics.get(name).map(|g| g.as_slice()))
         .unwrap_or(&[])
 }
@@ -944,6 +945,19 @@ pub type EnumParams = BTreeMap<String, Vec<(String, PlumType)>>;
 /// and the matching codegen logic in `plum-wasm-codegen`).
 pub type MinRequiredArgs = BTreeMap<(Option<String>, String), usize>;
+/// Generic parameter names of each generic builtin `primitive` (`Array[T]`).
+/// Primitives have no variants, so they don't live in `EnumVariants`.
+pub type PrimitiveGenerics = BTreeMap<String, Vec<String>>;
+pub fn buildPrimitiveGenerics(source: &ast::Source) -> PrimitiveGenerics {
+    source
+        .primitives
+        .iter()
+        .filter(|p| !p.generics.is_empty())
+        .map(|p| (p.name.clone(), p.generics.clone()))
+        .collect()
+}
 pub fn buildMinRequiredArgs(source: &ast::Source) -> MinRequiredArgs {
     let mut result = MinRequiredArgs::new();
     for item in &source.items {
@@ -969,6 +983,7 @@ pub struct CheckCtx<'a> {
     pub enum_variants: &'a EnumVariants,
     pub enum_params: &'a EnumParams,
     pub min_required: &'a MinRequiredArgs,
+    pub primitive_generics: &'a PrimitiveGenerics,
 }
 /// Builds the global lookup tables (function/const signatures, class fields, method
@@ -1025,23 +1040,6 @@ 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.
@@ -1562,11 +1560,13 @@ fn checkSourceInner(source: &ast::Source) -> (CheckResult<()>, TypedInfo) {
     );
     let (mut global_env, methods, enum_variants, enum_params) = buildGlobalTables(source);
     let min_required = buildMinRequiredArgs(source);
+    let primitive_generics = buildPrimitiveGenerics(source);
     let ctx = CheckCtx {
         methods: &methods,
         enum_variants: &enum_variants,
         enum_params: &enum_params,
         min_required: &min_required,
+        primitive_generics: &primitive_generics,
     };
     // Constants are inlined at their use sites, so their type is whatever their
     // initializer infers to (`FLAG = true`, `N = LIMIT * 2 + 1`, `T = List(1, 2)`).

plum-checker/tests/checker_tests.rs CHANGED Viewed

@@ -13,11 +13,13 @@ fn emptyCtx() -> CheckCtx<'static> {
     static ENUM_VARIANTS: OnceLock<plum_checker::EnumVariants> = OnceLock::new();
     static ENUM_PARAMS: OnceLock<plum_checker::EnumParams> = OnceLock::new();
     static MIN_REQUIRED: OnceLock<plum_checker::MinRequiredArgs> = OnceLock::new();
+    static PRIM_GENERICS: OnceLock<plum_checker::PrimitiveGenerics> = OnceLock::new();
     CheckCtx {
         methods: METHODS.get_or_init(Default::default),
         enum_variants: ENUM_VARIANTS.get_or_init(Default::default),
         enum_params: ENUM_PARAMS.get_or_init(Default::default),
         min_required: MIN_REQUIRED.get_or_init(Default::default),
+        primitive_generics: PRIM_GENERICS.get_or_init(Default::default),
     }
 }

plum-checker/tests/primitive_generics_test.rs ADDED Viewed

@@ -0,0 +1,43 @@
+#![allow(non_snake_case)]
+use plum_checker::{buildGlobalTables, checkSource};
+fn repoRoot() -> std::path::PathBuf {
+    std::path::Path::new(env!("CARGO_MANIFEST_DIR")).join("..")
+}
+fn load(name: &str, body: &str) -> plum_core::ast::Source {
+    let dir = std::env::temp_dir().join(format!("plum_prim_generics_{}", std::process::id()));
+    std::fs::create_dir_all(&dir).unwrap();
+    let path = dir.join(format!("{name}.plum"));
+    std::fs::write(&path, body).unwrap();
+    plum_core::loadAndMerge(&path, &repoRoot()).unwrap()
+}
+#[test]
+fn primitiveGenericsAreNotPseudoVariants() {
+    let source = load("a", "import std/Array\nimport std/Int\n\nfun main() -> Int =\n  1\n");
+    assert!(source.primitives.iter().any(|p| p.name == "Array"));
+    let (_, _, enum_variants, _) = buildGlobalTables(&source);
+    let bad: Vec<_> = enum_variants.keys().filter(|k| k.contains("<primitive")).collect();
+    assert!(bad.is_empty(), "pseudo-entries in enum_variants: {bad:?}");
+}
+#[test]
+fn arrayIntMethodsStillTypeCheck() {
+    let source = load(
+        "b",
+        "import std/Array\nimport std/Int\n\nfun main() -> Int =\n  a := Array[Int]().push(3).push(4)\n  return a.get(1) + a.length()\n",
+    );
+    if let Err(errs) = checkSource(&source) {
+        panic!("{:?}", errs.iter().map(|e| e.message.clone()).collect::<Vec<_>>());
+    }
+}
+#[test]
+fn arrayElementTypeIsEnforced() {
+    let source = load(
+        "c",
+        "import std/Array\nimport std/Int\nimport std/Str\n\nfun main() -> Str =\n  a := Array[Int]().push(3)\n  return a.get(0)\n",
+    );
+    assert!(checkSource(&source).is_err());
+}

plum-lsp/src/main.rs CHANGED Viewed

@@ -329,11 +329,13 @@ fn memberCompletionFor(
     let (global_env, methods, enum_variants, enum_params) =
         plum_checker::buildGlobalTables(&merged);
     let min_required = plum_checker::buildMinRequiredArgs(&merged);
+    let primitive_generics = plum_checker::buildPrimitiveGenerics(&merged);
     let ctx = plum_checker::CheckCtx {
         methods: &methods,
         enum_variants: &enum_variants,
         enum_params: &enum_params,
         min_required: &min_required,
+        primitive_generics: &primitive_generics,
     };
     let cursor_fn = completion::enclosingFn(&own_source, cursor_line);
     completion::memberItems(cursor_fn, receiver, &global_env, &ctx, &merged.stars)

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

@@ -388,6 +388,7 @@ pub struct CompileCtx<'a> {
     pub enum_variants: EnumVariants,
     pub enum_params: EnumParams,
     pub min_required: plum_checker::MinRequiredArgs,
+    pub primitive_generics: plum_checker::PrimitiveGenerics,
     pub global_env: TypeEnv,
     /// Closure literal (keyed by `&Expr::Closure` pointer identity) -> its `ClosureInfo`.
     pub closures: HashMap<(usize, usize), ClosureInfo>,
@@ -466,6 +467,7 @@ struct LocalCtx<'a> {
     enum_variants: &'a EnumVariants,
     enum_params: &'a EnumParams,
     min_required: &'a plum_checker::MinRequiredArgs,
+    primitive_generics: &'a plum_checker::PrimitiveGenerics,
     gc_types: &'a GcTypeRegistry,
     singleton_globals: &'a HashMap<(PlumType, String), u32>,
     /// Tracks each binding's inferred type as compilation proceeds through
@@ -1318,12 +1320,14 @@ fn checkCtxOf<'a>(
     ctx_enum_variants: &'a EnumVariants,
     ctx_enum_params: &'a EnumParams,
     ctx_min_required: &'a plum_checker::MinRequiredArgs,
+    ctx_primitive_generics: &'a plum_checker::PrimitiveGenerics,
 ) -> plum_checker::CheckCtx<'a> {
     plum_checker::CheckCtx {
         methods: ctx_methods,
         enum_variants: ctx_enum_variants,
         enum_params: ctx_enum_params,
         min_required: ctx_min_required,
+        primitive_generics: ctx_primitive_generics,
     }
 }
@@ -1348,6 +1352,7 @@ fn inferFallbackType(expr: &ast::Expr, ctx: &LocalCtx) -> PlumType {
         ctx.enum_variants,
         ctx.enum_params,
         ctx.min_required,
+        ctx.primitive_generics,
     );
     plum_checker::inferExpr(expr, &env, &cctx).unwrap_or(PlumType::TInt)
 }
@@ -1858,6 +1863,7 @@ fn compileSourceInner(
     let bool_to_str_fn = plum_checker::needsBuiltinBoolToStr(source).then(plum_checker::builtinBoolToStr);
     let (global_env, methods, enum_variants, enum_params) = plum_checker::buildGlobalTables(source);
     let min_required = plum_checker::buildMinRequiredArgs(source);
+    let primitive_generics = plum_checker::buildPrimitiveGenerics(source);
     let mut eg: EnumGenerics = HashMap::new();
     for item in &source.items {
         if let ast::Item::Enum(e) = item {
@@ -1883,7 +1889,7 @@ fn compileSourceInner(
     let mut units: Vec<UnitDef> = Vec::new();
     let mut known_fns: HashSet<String> = HashSet::new();
     {
-        let cctx = checkCtxOf(&methods, &enum_variants, &enum_params, &min_required);
+        let cctx = checkCtxOf(&methods, &enum_variants, &enum_params, &min_required, &primitive_generics);
         for f in &all_fns {
             if f.type_param.is_none() {
                 known_fns.insert(f.name.clone());
@@ -2512,6 +2518,7 @@ fn compileSourceInner(
         enum_variants,
         enum_params,
         min_required,
+        primitive_generics,
         global_env,
         closures,
         closure_asts,
@@ -4310,6 +4317,7 @@ fn compileFnBodyImpl(
         enum_variants: &ctx.enum_variants,
         enum_params: &ctx.enum_params,
         min_required: &ctx.min_required,
+        primitive_generics: &ctx.primitive_generics,
         gc_types: &ctx.gc_types,
         singleton_globals: &ctx.singleton_globals,
         type_env: RefCell::new(base_env),
@@ -7818,6 +7826,7 @@ fn compileClosureBody(
         enum_variants: &ctx.enum_variants,
         enum_params: &ctx.enum_params,
         min_required: &ctx.min_required,
+        primitive_generics: &ctx.primitive_generics,
         gc_types: &ctx.gc_types,
         singleton_globals: &ctx.singleton_globals,
         type_env: RefCell::new(base_env),