4659312 | plum | pyrossh

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

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

4659312 — Peter John 2026-11-01T21:08:17+05:30

fix: member values fall back to their enum's methods

Files changed (6) hide show

README.md +2 -0
plum-checker/src/lib.rs +6 -0
plum-checker/src/unions.rs +63 -4
plum-checker/tests/unions_dispatch_test.rs +42 -0
plum-examples/match.plum +6 -12
plum-examples/shapes.plum +4 -10

README.md CHANGED Viewed

@@ -479,6 +479,8 @@ enum Round = Circle | Oval
 record Oval(a: Float)
 ```
+A method call on a member value falls back to the enum when the member has no such method and exactly one enum it belongs to defines it (`Circle(r: 1.5).area()` calls `Shape.area`); if two enums define it, the call is an error until you convert the value first.
 A discriminant enum gives every tag a shared number:
 ```plum

plum-checker/src/lib.rs CHANGED Viewed

@@ -4192,6 +4192,12 @@ fn inferExprInner(
                     )),
                 },
                 ast::AttrKind::Method(call) => {
+                    // 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_core::unions::recordWrap(&attr.object as *const ast::Expr as usize, variant);
+                        return inferMethodCall(&en, &call.name, &call.args, env, ctx, expected);
+                    }
                     inferMethodCall(&obj_ty, &call.name, &call.args, env, ctx, expected)
                 }
             }

plum-checker/src/unions.rs CHANGED Viewed

@@ -104,8 +104,8 @@ pub fn recordMemberWrap(expr: &ast::Expr, actual: &PlumType, expected: Option<&P
     }
 }
-/// Enums that `ty` is a member of, plus `ty`'s own enum.
+/// Enums that `ty` is a member of.
-fn candidates(ty: &PlumType, ctx: &CheckCtx) -> BTreeSet<String> {
+fn memberOfEnums(ty: &PlumType, ctx: &CheckCtx) -> BTreeSet<String> {
     let mut out = BTreeSet::new();
     for (vn, info) in ctx.enum_variants.iter() {
         if info.field_types.len() == 1
@@ -121,6 +121,12 @@ fn candidates(ty: &PlumType, ctx: &CheckCtx) -> BTreeSet<String> {
             }
         }
     }
+    out
+}
+/// Enums that `ty` is a member of, plus `ty`'s own enum.
+fn candidates(ty: &PlumType, ctx: &CheckCtx) -> BTreeSet<String> {
+    let mut out = memberOfEnums(ty, ctx);
     if let Some((n, _)) = enumOf(ty) {
         if !members(n, &[], ctx).is_empty() {
             out.insert(n.to_string());
@@ -129,6 +135,48 @@ fn candidates(ty: &PlumType, ctx: &CheckCtx) -> BTreeSet<String> {
     out
 }
+/// For `recv.name(..)` where `recv` is a member value whose type has no method
+/// `name`: the one enum it is a member of that defines `name` (itself or by
+/// auto-dispatch) and the hidden variant that wraps the receiver. `None` when
+/// the ordinary rules apply; an error when two or more enums qualify.
+pub fn memberFallback(
+    obj: &PlumType,
+    name: &str,
+    ctx: &CheckCtx,
+) -> Option<Result<(PlumType, String), String>> {
+    let recv = crate::methodReceiverName(obj)?;
+    if ctx.methods.contains_key(&(recv, name.to_string())) {
+        return None;
+    }
+    if let Ok(PlumType::TFun(..)) = crate::fieldTypeOf(obj, name, ctx) {
+        return None;
+    }
+    let qualifying: Vec<String> = memberOfEnums(obj, ctx)
+        .into_iter()
+        .filter(|e| {
+            let generic = ctx.enum_variants.values().any(|i| &i.enum_name == e && !i.generics.is_empty());
+            !generic
+                && (ctx.methods.contains_key(&(e.clone(), name.to_string()))
+                    || matches!(dispatchPlan(&PlumType::TNamed(e.clone()), name, ctx), Some(Ok(_))))
+        })
+        .collect();
+    match qualifying.len() {
+        0 => None,
+        1 => {
+            let en = PlumType::TNamed(qualifying[0].clone());
+            let v = wrapVariantFor(&en, obj, ctx)?;
+            Some(Ok((en, v)))
+        }
+        _ => {
+            let (last, rest) = qualifying.split_last().unwrap();
+            Some(Err(format!(
+                "{obj} has no method '{name}' (it is a member of {} and {last}, which both define it — convert first)",
+                rest.join(", ")
+            )))
+        }
+    }
+}
 /// Joins two branch types through their one common union enum. `None` when
 /// neither branch involves unions (the ordinary rules apply).
 pub fn joinBranches(
@@ -347,6 +395,18 @@ pub fn dispatchSig(
     callAddr: usize,
     ctx: &CheckCtx,
 ) -> Option<Result<(Vec<PlumType>, PlumType), String>> {
+    Some(dispatchPlan(obj, name, ctx)?.map(|(variants, params, ret)| {
+        plan::recordDispatch(callAddr, variants);
+        (params, ret)
+    }))
+}
+/// `dispatchSig` without recording: `(variants, params, return type)`.
+fn dispatchPlan(
+    obj: &PlumType,
+    name: &str,
+    ctx: &CheckCtx,
+) -> Option<Result<(Vec<String>, Vec<PlumType>, PlumType), String>> {
     let (en, args) = enumOf(obj)?;
     if ctx.methods.contains_key(&(en.to_string(), name.to_string())) || !isUnion(en, ctx) {
         return None;
@@ -381,9 +441,8 @@ pub fn dispatchSig(
         variants.push(v);
     }
     let (_, sig) = first?;
-    plan::recordDispatch(callAddr, variants);
     let PlumType::TFun(params, ret) = sig else { return None };
-    Some(Ok((params, *ret)))
+    Some(Ok((variants, params, *ret)))
 }
 /// `"{e}"` on a union enum: records a `toStr` dispatch when every member has `toStr`.

plum-checker/tests/unions_dispatch_test.rs CHANGED Viewed

@@ -28,6 +28,25 @@ enum WithTag = Circle | Plain
 enum Missing = Circle | NoArea
 enum Clash = Circle | Odd
+record Bare(x: Float)
+enum Boxed =
+  | Bare
+  | Circle
+  fun area(self) -> Float = 1.0
+enum Round =
+  | Bare
+  | Rectangle
+  fun area(self) -> Float = 2.0
+enum Lone =
+  | Bare
+  fun size(self) -> Float = 3.0
 record Wrap[T](v: T) =
   fun toStr(self) -> Str = \"w\"
@@ -106,3 +125,26 @@ fn generic_member_dispatch() {
     r.unwrap();
     assert_eq!(p.dispatches.values().next().unwrap().len(), 2);
 }
+#[test]
+fn member_falls_back_to_its_enum() {
+    let (r, p) = run("fun g() -> Float =\n  Bare(x: 1.0).size()");
+    r.unwrap();
+    assert_eq!(p.wraps.len(), 1, "{:?}", p.wraps);
+    assert_eq!(p.wraps.values().next().unwrap(), "Lone__Bare");
+}
+#[test]
+fn member_fallback_ambiguous_error() {
+    let (r, _) = run("fun f() -> Float =\n  Bare(x: 1.0).area()");
+    assert!(
+        errs(r).ends_with("Bare has no method 'area' (it is a member of Boxed and Round, which both define it — convert first)")
+    );
+}
+#[test]
+fn member_own_method_wins() {
+    let (r, p) = run("fun f() -> Float =\n  Circle(r: 1.5).area()");
+    r.unwrap();
+    assert!(p.wraps.is_empty() && p.dispatches.is_empty());
+}

plum-examples/match.plum CHANGED Viewed

@@ -175,12 +175,6 @@ enum Figure =
 record Ring(radius: Int)
 record Rect(w: Int, h: Int)
-fun measureOf(s: Shape) -> Int =
-  s.measure()
-fun areaOf(f: Figure) -> Int =
-  f.area()
 test "match example computes correctly"
   assert main() == 5
@@ -235,16 +229,16 @@ test "match on a plain class supports literal/wildcard sub-patterns and case fal
   assert Point(x: 5, y: 5).classify() == "elsewhere"
 test "a plain class nested inside an enum variant pattern destructures correctly"
-  assert measureOf(Circle(Point(x: 3, y: 4))) == 7
+  assert Circle(Point(x: 3, y: 4)).measure() == 7
-  assert measureOf(Square(Point(x: 3, y: 4))) == 12
+  assert Square(Point(x: 3, y: 4)).measure() == 12
 test "named-payload enum variant constructs via named args and destructures by position"
-  assert areaOf(Ring(radius: 5)) == 25
+  assert Ring(radius: 5).area() == 25
-  assert areaOf(Rect(w: 3, h: 4)) == 12
+  assert Rect(w: 3, h: 4).area() == 12
 test "named-payload enum variant still supports positional construction too"
-  assert areaOf(Ring(5)) == 25
+  assert Ring(5).area() == 25
-  assert areaOf(Rect(3, 4)) == 12
+  assert Rect(3, 4).area() == 12
 test "a pattern name reused with different types in one fn"
   r := Sample(1)

plum-examples/shapes.plum CHANGED Viewed

@@ -21,16 +21,10 @@ enum Shape =
 record Circle(r: Float)
 record Rect(w: Float, h: Float)
-fun areaOf(s: Shape) -> Float =
-  s.area()
-fun nameOf(s: Shape) -> Str =
-  s.name()
 test "area dispatches on the variant"
-  assert areaOf(Circle(r: 1.5)) == 6.75
+  assert Circle(r: 1.5).area() == 6.75
-  assert areaOf(Rect(w: 2.0, h: 3.0)) == 6.0
+  assert Rect(w: 2.0, h: 3.0).area() == 6.0
 test "name dispatches on the variant"
-  assert nameOf(Circle(r: 1.0)) == "circle"
+  assert Circle(r: 1.0).name() == "circle"
-  assert nameOf(Rect(w: 1.0, h: 1.0)) == "rect"
+  assert Rect(w: 1.0, h: 1.0).name() == "rect"