fe4959d | plum | pyrossh

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

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

fe4959d — Peter John 2026-11-02T19:47:30+05:30

T4: checker trait rules

Files changed (4) hide show

plum-checker/src/lib.rs +78 -19
plum-checker/src/traits.rs +58 -0
plum-checker/tests/trait_fields_tests.rs +0 -1
plum-checker/tests/traits_tests.rs +115 -0

plum-checker/src/lib.rs CHANGED Viewed

@@ -2,6 +2,7 @@
 // naming convention), not Rust's idiomatic snake_case — silence the resulting lint.
 #![allow(non_snake_case)]
+pub mod traits;
 pub mod types;
 pub mod unions;
@@ -1032,6 +1033,7 @@ pub struct CheckCtx<'a> {
 /// `plum-wasm-codegen`, which needs the same tables to resolve `self`, field access,
 /// and method dispatch during code generation.
 pub fn buildGlobalTables(source: &ast::Source) -> (TypeEnv, MethodEnv, EnumVariants, EnumParams) {
+    traits::register(source);
     let conv = plumTypeFromAstG;
     let mut global_env: TypeEnv = TypeEnv::new();
     let mut methods: MethodEnv = BTreeMap::new();
@@ -1209,10 +1211,7 @@ fn checkUnions(
     plum_core::unions::beginPlan();
     let (result, info) = check(&copy);
     let plan = plum_core::unions::takePlan();
-    let empty = plan.wraps.is_empty()
+    let empty = plan.isEmpty();
-        && plan.patterns.is_empty()
-        && plan.narrowings.is_empty()
-        && plan.dispatches.is_empty();
     let out = if result.is_err() {
         // Report errors against the original, whose addresses codegen never sees.
         (result, info)
@@ -2781,12 +2780,31 @@ fn checkStmtInner(
                             ));
                             continue;
                         }
+                        let stmtAddr = stmt as *const ast::Stmt as usize;
-                        let field_expected = inferExpr(object, env, ctx)
+                        let objTy = inferExpr(object, env, ctx).ok();
+                        if let Some(msg) = objTy
-                            .ok()
+                            .as_ref()
+                            .and_then(|o| unions::nestedTraitWrite(object, o, ctx))
+                        {
+                            errors.push(CheckError::at(
+                                fn_pos.0,
+                                fn_pos.1,
+                                format!("fn '{}': assign '{}': {}", fn_name, label, msg),
+                            ));
+                            continue;
+                        }
+                        let traitTy = objTy
+                            .as_ref()
+                            .and_then(|o| unions::traitField(o, field_name, stmtAddr, true, ctx));
+                        let field_expected = match &traitTy {
+                            Some(r) => r.clone().ok(),
+                            None => objTy
+                                .as_ref()
-                            .and_then(|o| fieldTypeOf(&o, field_name, ctx).ok());
+                                .and_then(|o| fieldTypeOf(o, field_name, ctx).ok()),
+                        };
                         match (inferExpr(object, env, ctx), inferExprWith(value, env, ctx, field_expected.as_ref())) {
                             (Ok(obj_ty @ (PlumType::TNamed(_) | PlumType::TApp(..))), Ok(value_ty)) => {
-                                match fieldTypeOf(&obj_ty, field_name, ctx) {
+                                match traitTy.unwrap_or_else(|| fieldTypeOf(&obj_ty, field_name, ctx)) {
                                     Ok(field_ty) => {
                                         if let Err(msg) = unifyArg(&field_ty, &value_ty, value, ctx) {
                                             errors.push(CheckError::at(fn_pos.0, fn_pos.1, format!("fn '{}': assign '{}': {}", fn_name, label, msg)));
@@ -3255,6 +3273,31 @@ fn checkMatch(
     // Exhaustiveness: enum / Bool / error-name subjects must cover every
     // constructor (recursively through variant payloads) unless a catch-all
     // arm exists. Literal (Int/Str/Float) subjects are left alone.
+    if let [PlumType::TNamed(tn)] = subject_types.as_slice() {
+        if traits::isTrait(tn, ctx) {
+            let hasWildcard = m.cases.iter().any(|c| {
+                c.guard.is_none()
+                    && c.patterns.len() == 1
+                    && matches!(c.patterns[0], ast::CasePattern::Wildcard)
+            });
+            // Lowered dispatch matches name hidden variants (`Entity__House`) and stay exhaustive.
+            let lowered = m.cases.iter().any(|c| {
+                c.patterns.iter().any(|p| match p {
+                    ast::CasePattern::Class { name, .. } | ast::CasePattern::Name(name) => {
+                        name.contains("__")
+                    }
+                    _ => false,
+                })
+            });
+            if !hasWildcard && !lowered {
+                errors.push(CheckError::at(
+                    fn_pos.0,
+                    fn_pos.1,
+                    format!("fn '{}': match on trait {} needs a `_` case", fn_name, tn),
+                ));
+            }
+        }
+    }
     if let [subject_ty] = subject_types.as_slice() {
         let rows: Vec<Vec<&ast::CasePattern>> = m
             .cases
@@ -3262,19 +3305,23 @@ fn checkMatch(
             .filter(|c| c.guard.is_none() && c.patterns.len() == 1)
             .map(|c| vec![&c.patterns[0]])
             .collect();
+        let isTraitSubject =
+            matches!(subject_ty, PlumType::TNamed(tn) if traits::isTrait(tn, ctx));
         if let Err(CoverFail::Reported(label, missing)) =
             coverRows(rows, std::slice::from_ref(subject_ty), ctx)
         {
+            if !isTraitSubject {
-            errors.push(CheckError::at(
+                errors.push(CheckError::at(
-                fn_pos.0,
+                    fn_pos.0,
-                fn_pos.1,
+                    fn_pos.1,
-                format!(
+                    format!(
-                    "fn '{}': non-exhaustive match on {}: missing {}",
+                        "fn '{}': non-exhaustive match on {}: missing {}",
-                    fn_name,
+                        fn_name,
-                    label,
+                        label,
-                    missing.join(", ")
+                        missing.join(", ")
-                ),
+                    ),
-            ));
+                ));
+            }
         }
     }
@@ -4730,7 +4777,16 @@ fn inferExprInner(
                     // `Str` is an ordinary class with a real field; a generic
                     // class substitutes its receiver's type arguments.
                     PlumType::TNamed(_) | PlumType::TApp(..) => {
+                        match unions::traitField(
+                            &obj_ty,
+                            field_name,
+                            expr as *const ast::Expr as usize,
+                            false,
+                            ctx,
+                        ) {
+                            Some(r) => r,
-                        fieldTypeOf(&obj_ty, field_name, ctx)
+                            None => fieldTypeOf(&obj_ty, field_name, ctx),
+                        }
                     }
                     // An unresolved generic return reaches here as a plain `TVar`;
                     // field access on it is unmodeled — allow, codegen will catch.
@@ -4742,6 +4798,9 @@ fn inferExprInner(
                 },
                 ast::AttrKind::Method(call) => {
                     checkStaticUse(&attr.object, &obj_ty, &call.name, ctx)?;
+                    if let Some(msg) = traits::methodError(&obj_ty, &call.name, ctx) {
+                        return Err(msg);
+                    }
                     // A member value calling a method only its enum defines.
                     if let Some(r) = unions::memberFallback(&obj_ty, &call.name, ctx) {
                         let (en, variant) = r?;

plum-checker/src/traits.rs ADDED Viewed

@@ -0,0 +1,58 @@
+//! Trait rules in the checker. A trait is a union enum (`Enum.isTrait`) whose
+//! members are the embedding records; the declared methods come from `Source.traits`.
+use crate::CheckCtx;
+use plum_core::ast;
+use std::cell::RefCell;
+use std::collections::BTreeMap;
+thread_local! {
+    static TRAITS: RefCell<BTreeMap<String, Vec<String>>> = const { RefCell::new(BTreeMap::new()) };
+}
+/// Records the traits of `source` (called while the global tables are built).
+pub fn register(source: &ast::Source) {
+    let mut out: BTreeMap<String, Vec<String>> = BTreeMap::new();
+    for item in &source.items {
+        if let ast::Item::Enum(e) = item {
+            if e.isTrait {
+                out.insert(e.name.clone(), Vec::new());
+            }
+        }
+    }
+    for t in &source.traits {
+        let names = t
+            .required
+            .iter()
+            .chain(t.methods.iter())
+            .map(|f| f.name.clone())
+            .collect();
+        out.insert(t.name.clone(), names);
+    }
+    TRAITS.with(|c| *c.borrow_mut() = out);
+}
+pub fn isTrait(name: &str, _ctx: &CheckCtx) -> bool {
+    TRAITS.with(|c| c.borrow().contains_key(name))
+}
+/// The trait's declared methods: required first, then defaults, declaration order.
+pub fn traitMethods(name: &str, _ctx: &CheckCtx) -> Vec<String> {
+    TRAITS.with(|c| c.borrow().get(name).cloned().unwrap_or_default())
+}
+/// The error for calling `method` on a value of trait type `ty`, if it is not declared.
+pub fn methodError(ty: &crate::types::PlumType, method: &str, ctx: &CheckCtx) -> Option<String> {
+    let name = match ty {
+        crate::types::PlumType::TNamed(n) => n,
+        _ => return None,
+    };
+    if !isTrait(name, ctx)
+        || method.starts_with("__get_")
+        || method.starts_with("__set_")
+        || traitMethods(name, ctx).iter().any(|m| m == method)
+        || ctx.methods.contains_key(&(name.clone(), method.to_string()))
+    {
+        return None;
+    }
+    Some(format!("trait {name} has no method {method}"))
+}

plum-checker/tests/trait_fields_tests.rs CHANGED Viewed

@@ -208,7 +208,6 @@ fn plain_union_unaffected() {
 /// Through the checker proper (needs the `traitField` call sites in lib.rs and
 /// `UnionPlan::isEmpty` in `checkUnions`).
 #[test]
-#[ignore = "needs T4 call sites"]
 fn typed_source_lowers_field_access() {
     let s = lowered(
         "fun bump(e: Ent) -> Float =\n  e.z = e.z + 1.0\n  e.z\n\nfun nest(e: Ent) =\n  e.pos.x = 1.0\n",

plum-checker/tests/traits_tests.rs ADDED Viewed

@@ -0,0 +1,115 @@
+#![allow(non_snake_case)]
+//! Checker rules for traits: only declared methods on a trait value, `_` required in a
+//! match, conversion of embedding records, default methods calling the record's own.
+use plum_checker::checkSource;
+use plum_core::traits::lowerTraits;
+use plum_core::unions::resolveMembers;
+use plum_core::AstParser;
+const DEFS: &str = "\
+record Vec2(x: Float, y: Float)
+trait Entity(pos: Vec2, z: Int) =
+  fun update(self, dt: Float)
+  fun draw(self) -> Int
+  fun moveBy(self, d: Vec2) =
+    _ := self.draw()
+    self.z = self.z + 1
+record House(Entity, kind: Int) =
+  fun update(self, dt: Float) =
+    _ := self.draw()
+  fun draw(self) -> Int = 1
+  fun onClick(self) -> Int = 2
+record Soldier(Entity) =
+  fun update(self, dt: Float) =
+    _ := self.draw()
+  fun draw(self) -> Int = 3
+";
+fn run(defs: &str, body: &str) -> Result<(), String> {
+    let src = format!("{defs}\n{body}\n");
+    let mut parser = tree_sitter::Parser::new();
+    parser
+        .set_language(&tree_sitter_plum::LANGUAGE.into())
+        .unwrap();
+    let tree = parser.parse(&src, None).unwrap();
+    assert!(!tree.root_node().has_error(), "parse errors:\n{src}");
+    let mut source = AstParser::new(&src).parseSourceRaw(tree.root_node());
+    let errs = lowerTraits(&mut source);
+    assert!(errs.is_empty(), "{errs:?}");
+    let errs = resolveMembers(&mut source);
+    assert!(errs.is_empty(), "{errs:?}");
+    checkSource(&source).map_err(|e| e.into_iter().map(|x| x.message).collect::<Vec<_>>().join(" | "))
+}
+#[test]
+fn only_trait_methods() {
+    let e = run(DEFS, "fun f(e: Entity) =\n  e.onClick()").unwrap_err();
+    assert!(e.contains("trait Entity has no method onClick"), "{e}");
+    run(DEFS, "fun f(e: Entity) =\n  _ := e.draw()").unwrap();
+    run(DEFS, "fun f(e: Entity) =\n  e.moveBy(Vec2(x: 1.0, y: 1.0))").unwrap();
+}
+#[test]
+fn match_trait_needs_wildcard() {
+    let e = run(DEFS, "fun f(e: Entity) -> Int =\n  match e\n    House(a, b, c) => 1").unwrap_err();
+    assert!(e.contains("match on trait Entity needs a `_` case"), "{e}");
+}
+#[test]
+fn match_trait_wildcard_narrows() {
+    run(
+        DEFS,
+        "fun f(e: Entity) -> Int =\n  match e\n    House(p, z, k) => k\n    _ => 0",
+    )
+    .unwrap();
+}
+#[test]
+fn union_enum_keeps_exhaustive_and_shared_dispatch() {
+    let defs = "\
+record Circle(r: Float) =
+  fun area(self) -> Float = self.r
+record Square(s: Float) =
+  fun area(self) -> Float = self.s
+enum Shape = Circle | Square
+";
+    run(defs, "fun f(s: Shape) -> Float =\n  s.area()").unwrap();
+    run(
+        defs,
+        "fun f(s: Shape) -> Int =\n  match s\n    Circle(r) => 1\n    Square(q) => 2",
+    )
+    .unwrap();
+    let e = run(defs, "fun f(s: Shape) -> Int =\n  match s\n    Circle(r) => 1").unwrap_err();
+    assert!(e.contains("non-exhaustive"), "{e}");
+}
+#[test]
+fn record_in_trait_and_union_enum() {
+    let defs = format!("{DEFS}\nenum Thing = House | Soldier\n");
+    run(&defs, "fun f(t: Thing) -> Int =\n  1\n\nfun g() -> Int =\n  f(Soldier(pos: Vec2(x: 1.0, y: 1.0), z: 0))").unwrap();
+    run(&defs, "fun f(e: Entity) -> Int =\n  e.draw()\n\nfun g() -> Int =\n  f(Soldier(pos: Vec2(x: 1.0, y: 1.0), z: 0))").unwrap();
+}
+#[test]
+fn trait_param_accepts_record() {
+    run(
+        DEFS,
+        "fun f(e: Entity) -> Int =\n  e.draw()\n\nfun g() -> Int =\n  f(House(pos: Vec2(x: 1.0, y: 1.0), z: 0, kind: 1))",
+    )
+    .unwrap();
+}
+#[test]
+fn default_self_call_checks() {
+    run(DEFS, "fun f(h: House) =\n  h.moveBy(Vec2(x: 1.0, y: 1.0))").unwrap();
+}
+#[test]
+fn trait_helpers() {
+    // traitMethods order is covered through the rule: declared methods pass, others fail.
+    let e = run(DEFS, "fun f(e: Entity) =\n  e.nope()").unwrap_err();
+    assert!(e.contains("trait Entity has no method nope"), "{e}");
+}