0c02603 | plum | pyrossh

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

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

0c02603 — Peter John 2026-10-26T11:48:56+05:30

fix(checker): strict missing methods on builtin receivers; exact call sites

Files changed (5) hide show

plum-checker/src/lib.rs +40 -14
plum-checker/tests/checker_tests.rs +28 -0
plum-core/src/ast.rs +4 -0
plum-core/src/parser.rs +25 -3
plum-wasm-codegen/src/lib.rs +8 -0

plum-checker/src/lib.rs CHANGED Viewed

@@ -21,8 +21,9 @@ thread_local! {
     static TSUBST: RefCell<Option<BTreeMap<String, PlumType>>> = const { RefCell::new(None) };
     /// True while checking an instantiated generic body (method lookups on declared types are strict).
     static INST_MODE: Cell<bool> = const { Cell::new(false) };
+    /// Position (line, column) of the innermost call expression being inferred, or of the
-    /// Line of the declaration currently being checked (the "called at" line of recorded calls).
+    /// declaration being checked outside any call: the "called at" site of recorded calls.
-    static CUR_LINE: Cell<usize> = const { Cell::new(0) };
+    static CUR_POS: Cell<(usize, usize)> = const { Cell::new((0, 0)) };
     /// Address of the expression `inferExprWith` is currently inferring (the innermost one).
     static CUR_EXPR: Cell<usize> = const { Cell::new(0) };
     /// While checking the last statement of a value-producing tail (an fn body's
@@ -40,6 +41,7 @@ struct CallSite {
     name: String,
     args: BTreeMap<String, PlumType>,
     line: usize,
+    column: usize,
     /// Address of the call expression (or, for an implicit call, of the expression it is made on).
     expr: usize,
     /// A call codegen makes on its own (string interpolation's `toStr`), not written in source.
@@ -60,13 +62,15 @@ fn recordCallAt(
     if args.is_empty() {
         return;
     }
+    let (line, column) = CUR_POS.with(|p| p.get());
     CALLS.with(|c| {
         if let Some(v) = c.borrow_mut().as_mut() {
             v.push(CallSite {
                 recv: recv.map(|r| r.to_string()),
                 name: name.to_string(),
                 args,
-                line: CUR_LINE.with(|l| l.get()),
+                line,
+                column,
                 expr,
                 implicit,
             });
@@ -112,8 +116,10 @@ pub struct Instantiation {
     pub type_args: Vec<PlumType>,
     /// Instantiation whose body first called this one (`None` = a root).
     pub parent: Option<usize>,
-    /// Declaration line of the calling root/instantiation.
+    /// Position of the call expression that first reached this instantiation
+    /// (the declaration's own position for a call with none, e.g. an implicit one).
     pub called_at_line: usize,
+    pub called_at_column: usize,
 }
 /// Both operands of a binary/compare operator have the same type, so an
@@ -1391,7 +1397,7 @@ fn checkSourceInner(source: &ast::Source) -> (CheckResult<()>, TypedInfo) {
     // name-resolved here (its body is type-checked per instantiation below).
     for item in &source.items {
         if let ast::Item::Fn(f) = item {
-            CUR_LINE.with(|l| l.set(f.line));
+            CUR_POS.with(|l| l.set((f.line, f.column)));
             let mut local_errors = checkFn(f, &global_env, &ctx, &enums_by_name);
             if !fnGenericNames(f, &ctx).is_empty() {
                 local_errors.retain(|e| isResolutionError(&e.message));
@@ -1405,7 +1411,7 @@ fn checkSourceInner(source: &ast::Source) -> (CheckResult<()>, TypedInfo) {
     for item in &source.items {
         if let ast::Item::Test(t) = item {
-            CUR_LINE.with(|l| l.set(t.line));
+            CUR_POS.with(|l| l.set((t.line, t.column)));
             let mut env = global_env.clone();
             let mut block_errors = checkBlock(
                 &t.body,
@@ -1436,7 +1442,7 @@ fn checkSourceInner(source: &ast::Source) -> (CheckResult<()>, TypedInfo) {
             .collect();
         TSUBST.with(|s| *s.borrow_mut() = Some(subst));
         INST_MODE.with(|m| m.set(true));
-        CUR_LINE.with(|l| l.set(f.line));
+        CUR_POS.with(|l| l.set((f.line, f.column)));
         let saved = RECORD.with(|r| r.borrow_mut().replace(HashMap::new()));
         let errs = checkFn(f, &global_env, &ctx, &enums_by_name);
         let own = RECORD.with(|r| std::mem::replace(&mut *r.borrow_mut(), saved));
@@ -1464,7 +1470,7 @@ fn checkSourceInner(source: &ast::Source) -> (CheckResult<()>, TypedInfo) {
 struct InstState {
     info: TypedInfo,
-    /// Per instantiation id: the "in X[T] (called at f:l): " chain prefix.
+    /// Per instantiation id: the "in X[T] (called at f:l:c): " chain prefix.
     chains: Vec<String>,
     queue: std::collections::VecDeque<usize>,
     file: String,
@@ -1563,12 +1569,13 @@ fn registerCalls(
         let id = st.info.instantiations.len();
         let arg_str: Vec<String> = args.iter().map(|a| a.to_string()).collect();
         st.chains.push(format!(
-            "{}in {}[{}] (called at {}:{}): ",
+            "{}in {}[{}] (called at {}:{}:{}): ",
             parent_chain,
             item,
             arg_str.join(", "),
             st.file,
-            cs.line
+            cs.line,
+            cs.column
         ));
         st.info.instantiations.push(Instantiation {
             id,
@@ -1579,6 +1586,7 @@ fn registerCalls(
             type_args: args,
             parent,
             called_at_line: cs.line,
+            called_at_column: cs.column,
         });
         st.info.inst_index.insert(key, id);
         st.info.call_inst.insert((parent, cs.expr, cs.implicit), id);
@@ -2973,6 +2981,11 @@ fn inferMethodCall(
         ));
     }
     let Some(class_name) = methodReceiverName(obj_ty) else {
+        // Inside an instantiation a concrete receiver with no method table at
+        // all (unit, tag union, fn type) has no methods.
+        if INST_MODE.with(|m| m.get()) && !hasFreeVars(obj_ty) && !matches!(obj_ty, PlumType::TVar(_)) {
+            return Err(format!("{} has no method '{}'", obj_ty, name));
+        }
         return Ok(PlumType::TVar("_".to_string()));
     };
     // Fallback: a primitive/class receiver's method might be defined once on
@@ -2999,12 +3012,12 @@ fn inferMethodCall(
         }
         // Inside an instantiated generic body the receiver is a concrete type:
         // a declared type lacking the method is a real (duck-typing) error.
+        // Builtin/primitive receivers too: their methods are those declared in
+        // plum-std plus the compiler intrinsics handled before this lookup.
-        if INST_MODE.with(|m| m.get())
+        if INST_MODE.with(|m| m.get()) && !hasFreeVars(obj_ty) {
-            && ctx.enum_variants.values().any(|i| i.enum_name == class_name)
-        {
             return Err(format!("{} has no method '{}'", obj_ty, name));
         }
-        // Unmodeled method (e.g. builtin/std): allow, codegen will catch.
+        // Outside an instantiation (erased pass): allow, the per-instance pass decides.
         return Ok(PlumType::TVar("_".to_string()));
     };
     let PlumType::TFun(..) = sig else {
@@ -3109,7 +3122,20 @@ pub fn inferExprWith(
     expected: Option<&PlumType>,
 ) -> Result<PlumType, String> {
     let prev = CUR_EXPR.with(|c| c.replace(expr as *const ast::Expr as usize));
+    let call_pos = match expr {
+        ast::Expr::FnCall(c) => Some((c.line, c.column)),
+        ast::Expr::Attribute(a) => match &a.attr {
+            ast::AttrKind::Method(c) => Some((c.line, c.column)),
+            _ => None,
+        },
+        _ => None,
+    };
+    let prev_pos = CUR_POS.with(|p| p.get());
+    if let Some(pos) = call_pos.filter(|p| p.0 != 0) {
+        CUR_POS.with(|p| p.set(pos));
+    }
     let r = inferExprInner(expr, env, ctx, expected);
+    CUR_POS.with(|p| p.set(prev_pos));
     CUR_EXPR.with(|c| c.set(prev));
     if let Ok(t) = &r {
         recordType(expr, t);

plum-checker/tests/checker_tests.rs CHANGED Viewed

@@ -2353,3 +2353,31 @@ fn true_false_are_never_tags() {
     let r = checkSource(&parseClean(src));
     assert!(r.is_ok(), "got {:?}", r.err());
 }
+#[test]
+fn builtin_missing_method_strict() {
+    let src = "fun maxOf(a: T, b: T) -> T =\n  a.lt(b) ? b : a\n\nfun main() -> Int =\n  maxOf(1, 2)\n";
+    let msg = errText(checkSource(&parseClean(src)));
+    assert!(msg.contains("in maxOf[Int] (called at "), "{}", msg);
+    assert!(msg.contains("Int has no method 'lt'"), "{}", msg);
+}
+#[test]
+fn called_at_exact_line_col() {
+    // `maxOf` is declared on line 4 but called on line 7, col 3.
+    let src = "enum Plain =\n  | Plain(v: Int)\n\nfun maxOf(a: T, b: T) -> T =\n  a.lt(b) ? b : a\nfun main() -> Plain =\n  maxOf(Plain(v: 1), Plain(v: 2))\n";
+    let msg = errText(checkSource(&parseClean(&src)));
+    assert!(msg.contains("in maxOf[Plain] (called at "), "{}", msg);
+    assert!(msg.contains(":7:3): "), "{}", msg);
+    assert!(!msg.contains(":4:"), "{}", msg);
+}
+#[test]
+fn nested_chain_exact_sites() {
+    let src = "enum Plain =\n  | Plain(v: Int)\n\nfun inner(a: T) -> T =\n  a.nope()\n\nfun outer(a: T) -> T =\n  x := 1\n  inner(a)\n\nfun main() -> Plain =\n  outer(Plain(v: 1))\n";
+    let msg = errText(checkSource(&parseClean(src)));
+    assert!(msg.contains("in outer[Plain] (called at "), "{}", msg);
+    assert!(msg.contains(":12:3): in inner[Plain] (called at "), "{}", msg);
+    assert!(msg.contains(":9:3): "), "{}", msg);
+    assert!(msg.contains("Plain has no method 'nope'"), "{}", msg);
+}

plum-core/src/ast.rs CHANGED Viewed

@@ -461,6 +461,10 @@ pub struct ElvisExpr {
 pub struct FnCall {
     pub name: String,
     pub args: Vec<Arg>,
+    /// 1-based position of the call expression (a method call: the whole
+    /// `obj.name(...)`), for diagnostics. `(0, 0)` for a synthetic call.
+    pub line: usize,
+    pub column: usize,
 }
 #[derive(Debug, Clone, PartialEq)]

plum-core/src/parser.rs CHANGED Viewed

@@ -1112,6 +1112,7 @@ impl<'a> AstParser<'a> {
         // attribute: primary_expression "." fn_identifier fn_argument_list?
         // The member name is always fn_identifier (a superset of var_identifier); an
         // optional trailing argument list distinguishes a method call from field access.
+        let pos = node.start_position();
         let named: Vec<Node> = self.namedChildren(node);
         let object = named
             .first()
@@ -1128,7 +1129,12 @@ impl<'a> AstParser<'a> {
                     .named_children(&mut acursor)
                     .map(|n| self.parseArg(n))
                     .collect();
-                AttrKind::Method(FnCall { name: member, args })
+                AttrKind::Method(FnCall {
+                    name: member,
+                    args,
+                    line: pos.row + 1,
+                    column: pos.column + 1,
+                })
             }
             None => AttrKind::Field(member),
         };
@@ -1152,6 +1158,8 @@ impl<'a> AstParser<'a> {
                 attr: AttrKind::Method(FnCall {
                     name: "mapErr".to_string(),
                     args: vec![Arg::Positional(closure)],
+                    line: node.start_position().row + 1,
+                    column: node.start_position().column + 1,
                 }),
             }))));
         }
@@ -1171,6 +1179,7 @@ impl<'a> AstParser<'a> {
     fn parseSafeAttribute(&self, node: Node) -> Expr {
         const SAFE_NAV_PARAM: &str = "__safe_nav";
+        let pos = node.start_position();
         let named: Vec<Node> = self.namedChildren(node);
         let object = named
             .first()
@@ -1187,7 +1196,12 @@ impl<'a> AstParser<'a> {
                     .named_children(&mut acursor)
                     .map(|n| self.parseArg(n))
                     .collect();
-                AttrKind::Method(FnCall { name: member, args })
+                AttrKind::Method(FnCall {
+                    name: member,
+                    args,
+                    line: pos.row + 1,
+                    column: pos.column + 1,
+                })
             }
             None => AttrKind::Field(member),
         };
@@ -1207,6 +1221,8 @@ impl<'a> AstParser<'a> {
             attr: AttrKind::Method(FnCall {
                 name: "map".to_string(),
                 args: vec![Arg::Positional(Expr::Closure(Box::new(closure)))],
+                line: pos.row + 1,
+                column: pos.column + 1,
             }),
         }))
     }
@@ -1228,7 +1244,13 @@ impl<'a> AstParser<'a> {
                     .collect()
             })
             .unwrap_or_default();
+        let pos = node.start_position();
-        FnCall { name, args }
+        FnCall {
+            name,
+            args,
+            line: pos.row + 1,
+            column: pos.column + 1,
+        }
     }
     fn parseArg(&self, node: Node) -> Arg {

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

@@ -6637,6 +6637,8 @@ fn compileExpr(
                 let init_call = ast::FnCall {
                     name: "init".to_string(),
                     args: call.args.clone(),
+                    line: call.line,
+                    column: call.column,
                 };
                 compileMethodCall(
                     &object,
@@ -6694,6 +6696,8 @@ fn compileExpr(
                             .cloned()
                             .map(ast::Arg::Positional)
                             .collect(),
+                        line: 0,
+                        column: 0,
                     };
                     compileVariantConstruction(info, &synthetic_call, expr, body, ctx, state)?;
                 }
@@ -6740,6 +6744,8 @@ fn compileExpr(
             let init_call = ast::FnCall {
                 name: "init".to_string(),
                 args: vec![],
+                line: 0,
+                column: 0,
             };
             compileMethodCall(
                 &object,
@@ -7414,6 +7420,8 @@ fn compileInterpolatedString(
                         let to_str = ast::FnCall {
                             name: "toStr".to_string(),
                             args: vec![],
+                            line: 0,
+                            column: 0,
                         };
                         let str_ty = PlumType::TStr;
                         let is_dyn = match &other {