a039616 | plum | pyrossh

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

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

a039616 — Peter John 2026-11-02T10:41:03+05:30

feat: a fun without self is a static; Type.f() and x.f() are checked

Files changed (7) hide show

README.md +4 -1
plum-checker/src/lib.rs +61 -3
plum-checker/tests/checker_tests.rs +11 -6
plum-examples/structs_records.plum +3 -3
plum-lsp/src/completion.rs +4 -0
plum-lsp/src/main.rs +2 -0
plum-wasm-codegen/src/lib.rs +1 -0

README.md CHANGED Viewed

@@ -507,7 +507,7 @@ enum Step(n: Int) =
 ### Methods, `self` and field access
-A `fun` declared indented directly inside an `enum`, `struct` or `record` body is a method; its first parameter is `self`:
+A `fun` declared indented directly inside an `enum`, `struct` or `record` body whose first parameter is `self` is a method, called on a value (`c.getAge()`). One without `self` is a static function, called on the type (`Cat.named("Tom")`), and can't use `self`. Calling a static on a value, or a method on the type, is an error:
 ```plum
 record Cat(name: Str, age: Int) =
@@ -517,6 +517,9 @@ record Cat(name: Str, age: Int) =
   fun birthday(self) -> Int =
     self.age + 1
+  fun named(name: Str) -> Cat =   # static: Cat.named("Tom")
+    Cat(name: name, age: 0)
 record Wrapper(inner: Cat, tag: Int)
 fun main() -> Int =

plum-checker/src/lib.rs CHANGED Viewed

@@ -943,6 +943,23 @@ pub fn buildPrimitiveGenerics(source: &ast::Source) -> PrimitiveGenerics {
         .collect()
 }
+/// `(type, name)` of every function declared in a type body without `self`: a
+/// static, called as `Type.name(args)`, never on a value.
+pub type StaticMethods = BTreeSet<(String, String)>;
+pub fn buildStaticMethods(source: &ast::Source) -> StaticMethods {
+    source
+        .items
+        .iter()
+        .filter_map(|item| match item {
+            ast::Item::Fn(f) if !f.has_self => {
+                f.type_param.as_ref().map(|t| (t.clone(), f.name.clone()))
+            }
+            _ => None,
+        })
+        .collect()
+}
 pub fn buildMinRequiredArgs(source: &ast::Source) -> MinRequiredArgs {
     let mut result = MinRequiredArgs::new();
     for item in &source.items {
@@ -969,6 +986,9 @@ pub struct CheckCtx<'a> {
     pub enum_params: &'a EnumParams,
     pub min_required: &'a MinRequiredArgs,
     pub primitive_generics: &'a PrimitiveGenerics,
+    /// `None` skips the static-vs-method call check: codegen re-infers source
+    /// the checker already accepted.
+    pub statics: Option<&'a StaticMethods>,
 }
 /// Builds the global lookup tables (function/const signatures, class fields, method
@@ -1616,12 +1636,14 @@ 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 statics = buildStaticMethods(source);
     let ctx = CheckCtx {
         methods: &methods,
         enum_variants: &enum_variants,
         enum_params: &enum_params,
         min_required: &min_required,
         primitive_generics: &primitive_generics,
+        statics: Some(&statics),
     };
     // 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)`).
@@ -2105,8 +2127,9 @@ fn checkFn(
         }
     }
+    // Methods (a `fun` in a type body whose first parameter is `self`) get a
-    // Methods (`name<Receiver>(...)`) get an implicit `self: Receiver` binding.
+    // `self: Receiver` binding; a `fun` without `self` is a static.
-    if let Some(recv) = &f.type_param {
+    if let (Some(recv), true) = (&f.type_param, f.has_self) {
         let generics = enumGenericsOf(recv, ctx);
         let self_ty = if generics.is_empty() {
             plumTypeFromName(recv)
@@ -3905,7 +3928,9 @@ fn inferExprInner(
             Some(s) if !s.vars.is_empty() => Ok(instSig(&s.body, &BTreeMap::new())),
             _ => lookup(env, name),
         },
-        ast::Expr::Self_ => lookup(env, "self"),
+        ast::Expr::Self_ => lookup(env, "self").map_err(|_| {
+            "`self` is only available in a method, a `fun` in a type body whose first parameter is `self` (one without `self` is a static, called as `Type.f()`)".to_string()
+        }),
         // A bare `NAME` lexes as a type_identifier whenever it starts with an
         // uppercase letter — which includes every SCREAMING_CASE top-level
         // const (`PI`, `MAX_VALUE`, ...), since there's no separate "constant"
@@ -4309,6 +4334,7 @@ fn inferExprInner(
                     )),
                 },
                 ast::AttrKind::Method(call) => {
+                    checkStaticUse(&attr.object, &obj_ty, &call.name, ctx)?;
                     // 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?;
@@ -4322,6 +4348,38 @@ fn inferExprInner(
     }
 }
+/// `Type.f()` must name a static (a `fun` without `self`) and `x.f()` a
+/// method: a static has no value to run on, and a method needs one.
+fn checkStaticUse(
+    object: &ast::Expr,
+    obj_ty: &PlumType,
+    name: &str,
+    ctx: &CheckCtx,
+) -> Result<(), String> {
+    let (Some(statics), Some(class)) = (ctx.statics, methodReceiverName(obj_ty)) else {
+        return Ok(());
+    };
+    let key = (class.clone(), name.to_string());
+    if !ctx.methods.contains_key(&key) {
+        return Ok(());
+    }
+    let on_type = matches!(object, ast::Expr::TypeName(n) if *n == class);
+    let is_static = statics.contains(&key);
+    if on_type && !is_static {
+        return Err(format!(
+            "'{}' is a method of {} (it takes `self`): call it on a value, `x.{}(...)`",
+            name, class, name
+        ));
+    }
+    if !on_type && is_static {
+        return Err(format!(
+            "'{}' is a static function of {} (no `self`): call it as `{}.{}(...)`",
+            name, class, class, name
+        ));
+    }
+    Ok(())
+}
 /// Makes errors from expanded for-forms and from `fun*` definitions
 /// readable: the checker only sees the expanded code (hygienic locals named
 /// `__f<id>_x`) and ordinary-fn copies named `__star_<name>`.

plum-checker/tests/checker_tests.rs CHANGED Viewed

@@ -14,12 +14,14 @@ fn emptyCtx() -> CheckCtx<'static> {
     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();
+    static STATICS: OnceLock<plum_checker::StaticMethods> = 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),
+        statics: Some(STATICS.get_or_init(Default::default)),
     }
 }
@@ -463,7 +465,7 @@ fn rejects_basic_expressions_and_calls() {
         r("fun bad() -> Int =\n  false\n", &["return type mismatch"]),
         r("fun bad() -> Int =\n  x\n", &["undefined name 'x'"]),
         r("fun bad() -> Int =\n  1 + 2.0\n", &["binary op: type mismatch"]),
-        r("fun bad() -> Int =\n  self\n", &["undefined name 'self'"]),
+        r("fun bad() -> Int =\n  self\n", &["`self` is only available in a method"]),
         r("fun f() -> Int =\n  nope\n", &["undefined name 'nope'"]),
         r("fun f() -> Int =\n  crash 5\n", &["Str"]),
         r("fun f(c: Bool) -> Int =\n  if c then 1 else \"no\"\n", &["inline if branches"]),
@@ -478,13 +480,16 @@ fn rejects_basic_expressions_and_calls() {
         r("fun f(a: Int?) -> Bool =\n  a == 3\n", &["cannot compare"]),
         r("fun f(a: error{Bad}!Int) -> Bool =\n  a == 3\n", &["cannot compare"]),
         // enum/class fields and constructors
-        r(&format!("{cat}fun getAge() -> Int =\n  self.age\n"), &["undefined name 'self'"]),
+        r(&format!("{cat}fun getAge() -> Int =\n  self.age\n"), &["`self` is only available in a method"]),
+        // a `fun` without `self` is a static: called on the type, never on a value
-        r("enum Cat =\n  | Cat(name: Str)\n\n  fun getAge() -> Int =\n    self.age\n", &["no field 'age' on type 'Cat'"]),
+        r("record Cat(age: Int) =\n  fun getAge() -> Int =\n    self.age\n", &["`self` is only available in a method"]),
+        r("record Cat(age: Int) =\n  fun make() -> Cat =\n    Cat(age: 1)\n\nfun f() -> Cat =\n  Cat(age: 2).make()\n", &["'make' is a static function of Cat", "Cat.make(...)"]),
+        r("record Cat(age: Int) =\n  fun getAge(self) -> Int =\n    self.age\n\nfun f() -> Int =\n  Cat.getAge()\n", &["'getAge' is a method of Cat", "call it on a value"]),
         r("enum Cat =\n  | Cat(name: Str)\n\n  fun getAge(self) -> Int =\n    self.age\n", &["no field 'age' on type 'Cat'"]),
         r(&format!("{cat}fun makeCat() -> Cat =\n  Cat(name: \"x\", age: \"y\")\n"), &["variant 'Cat' field 'age': type mismatch"]),
         r("enum Cat =\n  | Cat(name: Str)\n\nfun makeCat() -> Cat =\n  Cat(name: \"x\", age: 1)\n", &["unknown field 'age' on variant 'Cat'"]),
-        r(&format!("{cat}  fun breakCat() =\n    self.age = \"oops\"\n"), &["assign 'self.age': type mismatch"]),
+        r(&format!("{cat}  fun breakCat(self) =\n    self.age = \"oops\"\n"), &["assign 'self.age': type mismatch"]),
-        r(&format!("{cat}  fun breakCat() =\n    self.nope = 1\n"), &["no field 'nope' on type 'Cat'"]),
+        r(&format!("{cat}  fun breakCat(self) =\n    self.nope = 1\n"), &["no field 'nope' on type 'Cat'"]),
         r("enum Shape =\n  | Square(x: Int, y: Int)\n\nfun bad() -> Shape =\n  Square(x: 1)\n", &["variant 'Square' missing field 'y'"]),
         r("enum Shape =\n  | Square(x: Int, y: Int)\n\nfun bad() -> Shape =\n  Square(x: 1, y: 2, z: 3)\n", &["unknown field 'z' on variant 'Square'"]),
         r("enum Shape =\n  | Circle(radius: Int)\n  | Square(radius: Int)\n\nfun bad() -> Int =\n  r := Circle(radius: 5)\n  return r.radius\n", &["field 'radius' is ambiguous across multiple variants of enum 'Shape'"]),
@@ -546,7 +551,7 @@ fn rejects_bad_generics_and_duck_typed_calls() {
         r("fun wrong(x: T) -> Int =\n  \"hello\"\n\nfun useIt() -> Str =\n  wrong(\"s\")\n", &["in wrong[Str]"]),
         r("fun identity(value: T) -> T =\n  value\n\nfun a() -> Str =\n  identity(5)\n", &["expected Str, found Int"]),
         r("fun f(x: T) -> Int =\n  x\n\nfun main() -> Int =\n  f(\"s\")\n", &["in f[Str]"]),
-        r("enum Box[T] =\n  | Box(value: T)\n\n  fun get() -> Int =\n    self.value\n\nfun main() -> Int =\n  Box(value: \"s\").get()\n", &["in Box.get[Str]"]),
+        r("enum Box[T] =\n  | Box(value: T)\n\n  fun get(self) -> Int =\n    self.value\n\nfun main() -> Int =\n  Box(value: \"s\").get()\n", &["in Box.get[Str]"]),
         r(&generic("fun f() -> List[Box[Str]] =\n  List(items: Box(value: 1))\n"), &["variant 'Box' field 'value': type mismatch"]),
         r(&generic("fun f() -> List[Str] =\n  List(items: 1).map(|x| x + 1)\n"), &["method 'List.map' arg 0: type mismatch"]),
         r(&generic("fun f(xs: List[Int]) -> List[Int] =\n  xs.map(|n| \"{n}\")\n"), &["type mismatch"]),

plum-examples/structs_records.plum CHANGED Viewed

@@ -83,10 +83,10 @@ fun bump(v: Vec2) -> Float =
 record Point(x: Int, y: Int)
-# `self` is implicit inside a record body, or can be written out.
+# A method takes `self` first; a `fun` without `self` is a static (`Vec2.zero()`).
 record Cat(name: Str, age: Int) =
-  fun getAge() -> Int =
+  fun getAge(self) -> Int =
     self.age
   fun birthday(self) -> Int =
@@ -225,7 +225,7 @@ test "record construction is named or positional"
   assert Point(x: 3, y: 4).y == 4
   assert Point(3, 4).y == 4
-test "record methods, with and without an explicit self"
+test "record methods"
   c := Cat(name: "x", age: 7)
   assert c.getAge() == 7
   assert c.birthday() == 8

plum-lsp/src/completion.rs CHANGED Viewed

@@ -326,6 +326,10 @@ pub fn memberItems(
         if !owners.contains(r) || (r != &recv_name && items.iter().any(|i| i.label == *name)) {
             continue;
         }
+        // A static (no `self`) is reached as `Type.f()`, not on a value.
+        if ctx.statics.is_some_and(|st| st.contains(&(r.clone(), name.clone()))) {
+            continue;
+        }
         let detail = match fn_ty {
             PlumType::TFun(params, ret) => Some(format!(
                 "({}) -> {:?}",

plum-lsp/src/main.rs CHANGED Viewed

@@ -330,12 +330,14 @@ fn memberCompletionFor(
         plum_checker::buildGlobalTables(&merged);
     let min_required = plum_checker::buildMinRequiredArgs(&merged);
     let primitive_generics = plum_checker::buildPrimitiveGenerics(&merged);
+    let statics = plum_checker::buildStaticMethods(&merged);
     let ctx = plum_checker::CheckCtx {
         methods: &methods,
         enum_variants: &enum_variants,
         enum_params: &enum_params,
         min_required: &min_required,
         primitive_generics: &primitive_generics,
+        statics: Some(&statics),
     };
     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

@@ -1370,6 +1370,7 @@ fn checkCtxOf<'a>(
         enum_params: ctx_enum_params,
         min_required: ctx_min_required,
         primitive_generics: ctx_primitive_generics,
+        statics: None,
     }
 }