2b8194c | plum

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

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

2b8194c — Peter John 2026-08-09T21:03:00+05:30

refactor(plum-core): drop dead receiver-vs-return-type disambiguation from parse_fn

Files changed (4) hide show

plum-core/src/parser.rs +14 -31
plum-core/tests/formatter_test.rs +1 -1
plum-core/tests/loader_test.rs +4 -4
plum-core/tests/parser_test.rs +2 -2

plum-core/src/parser.rs CHANGED Viewed

@@ -243,52 +243,35 @@ impl<'a> AstParser<'a> {
     // ---- functions --------------------------------------------------------
     fn parse_fn(&self, node: Node) -> Fn {
-        // fn: fn_identifier type? "(" param,* ")" ("->" type)? "=" body_or_expr
+        // fn: "fun" fn_identifier "(" param,* ")" ("->" type)? "=" body_or_expr
-        // Named children: fn_identifier, type?, param*, type?, body/expr
+        // Named children: fn_identifier, param*, type?, body/expr
+        //
+        // `type_param` (the method's receiver, e.g. `Cat` in a method nested inside
+        // `type Cat = ...`) is never set here — a bare `fn` node has no receiver of
+        // its own; `parse_source`'s `collect_nested_fns` forces it afterward for any
+        // `fn` nested inside a `class`/`enum` body. There is no top-level
+        // `<Receiver>` annotation syntax to parse.
         let mut cursor = node.walk();
         let named: Vec<Node> = node.named_children(&mut cursor).collect();
         let name = named.first().map(|n| self.text(*n)).unwrap_or_default();
-        // The `<Cat>` receiver annotation and the function's `-> Type` return
-        // annotation both have kind "type" now, so they can't be told apart by
-        // kind alone. They're disambiguated by field instead: the grammar's
-        // `type` field (`field("type", optional(alias($.fn_type, $.type)))`)
-        // wraps only the receiver's own alias node, so `child_by_field_name`
-        // resolves it unambiguously.
-        //
-        // Note: the grammar's `returns` field, by contrast, wraps the whole
-        // `optional(seq("->", $.type))` — so `child_by_field_name("returns")`
-        // resolves to the anonymous `"->"` token (the first element of that
-        // seq), not the `type` node, and can't be used to find the return
-        // type here. Instead the return type is derived as "whichever `type`
-        // named child isn't the receiver".
-        let receiver_node = node.child_by_field_name("type");
-        // type param — the `<Cat>` node has kind "type" and contains a type_identifier
-        let type_param = receiver_node
-            .and_then(|t| t.named_child(0))
-            .map(|n| self.text(n));
         let params: Vec<Param> = named
             .iter()
             .filter(|n| n.kind() == "param")
             .map(|n| self.parse_param(*n))
             .collect();
+        // The grammar's `returns` field wraps the whole `optional(seq("->", $.type))`,
+        // so `child_by_field_name("returns")` resolves to the anonymous `"->"` token,
+        // not the `type` node — find the `type`-kind named child instead.
         let returns = named
             .iter()
-            .find(|n| n.kind() == "type" && Some(**n) != receiver_node)
+            .find(|n| n.kind() == "type")
             .map(|n| self.parse_type(*n));
         // body is the last named child — it is either a `body` node (block)
-        // or an expression node when the body is a single expression. The
+        // or an expression node when the body is a single expression.
-        // `<Cat>` receiver annotation and the `returns` type both have kind
-        // "type" now (return_type no longer exists as a separate node kind),
-        // but that's fine: neither can ever be the LAST named child when a
-        // body is present, since `body`/the trailing expression always comes
-        // after them in the grammar — so this match doesn't need to
-        // distinguish the two "type" cases from each other, only from `body`.
         let body = named.last().and_then(|last| {
             match last.kind() {
                 // Skip non-body trailing nodes
@@ -301,7 +284,7 @@ impl<'a> AstParser<'a> {
             }
         }).unwrap_or(FnBody::Block(Block { stmts: vec![] }));
-        Fn { name, type_param, params, returns, body }
+        Fn { name, type_param: None, params, returns, body }
     }
     fn parse_const(&self, node: Node) -> Const {

plum-core/tests/formatter_test.rs CHANGED Viewed

@@ -10,7 +10,7 @@ fn formats_simple_function() {
 #[test]
 fn formats_binary_operator_spacing() {
-    let input = "fun add<Int>(a: Int, b: Int) -> Int =\n  a+b\n";
+    let input = "fun add(a: Int, b: Int) -> Int =\n  a+b\n";
     let result = format_source(input).expect("format_source should succeed");
     assert!(result.contains("a + b"));
 }

plum-core/tests/loader_test.rs CHANGED Viewed

@@ -109,8 +109,8 @@ module fixtures
 type Cat =
   age: Int
-fun length<Cat>(self) -> Int =
+  fun length(self) -> Int =
-  self.age
+    self.age
 ");
     let entry = write_lib_file(&lib_path, "main", "\
 module fixtures
@@ -120,8 +120,8 @@ import cat
 type Box =
   items: Int
-fun length<Box>(self) -> Int =
+  fun length(self) -> Int =
-  self.items
+    self.items
 fun main() -> Int =
   0

plum-core/tests/parser_test.rs CHANGED Viewed

@@ -142,8 +142,8 @@ fn fn_without_receiver_but_with_return_type_has_no_type_param() {
 }
 #[test]
-fn fn_with_receiver_and_return_type_has_correct_type_param() {
+fn nested_method_with_return_type_has_correct_type_param() {
-    let src = "fun toStr<Cat>() -> Str =\n  \"x\"\n";
+    let src = "type Cat =\n  name: Str\n\n  fun toStr() -> Str =\n    \"x\"\n";
     let source = parse(src);
     let f = only_fn(&source);
     assert_eq!(f.type_param, Some("Cat".to_string()));