f9467e7 | plum | pyrossh

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

f9467e7 — Peter John 2026-10-25T16:02:16+05:30

fix(checker): refutable payload patterns don't cover a tag in exhaustiveness

Files changed (2) hide show

plum-checker/src/lib.rs CHANGED Viewed

@@ -1262,8 +1262,18 @@ fn checkMatch(
                         catch_all = true; // a binding
                     }
                 }
-                Some(ast::CasePattern::Class { name, .. }) => {
+                Some(ast::CasePattern::Class { name, fields }) => {
+                    // `B(0)` is refutable and does not cover `B`.
+                    let irrefutable = |p: &ast::CasePattern| match p {
+                        ast::CasePattern::Wildcard => true,
+                        ast::CasePattern::Name(n) => {
+                            !n.chars().next().is_some_and(|c| c.is_uppercase())
+                        }
+                        _ => false,
+                    };
+                    if fields.iter().all(irrefutable) {
-                    covered.insert(name.as_str());
+                        covered.insert(name.as_str());
+                    }
                 }
                 _ => {}
             }

plum-checker/tests/checker_tests.rs CHANGED Viewed

@@ -1626,3 +1626,57 @@ fun f() -> Try[Int, [Mapped]] =
     );
     assert!(r.is_ok(), "got {:?}", r.err());
 }
+#[test]
+fn refutable_payload_pattern_does_not_cover_tag() {
+    let r = errText(checkTry(
+        "\
+fun f(t: [A, B(Int)]) -> Int =
+  match t
+    A => 1
+    B(0) => 2
+",
+    ));
+    assert!(r.contains("non-exhaustive") && r.contains("B"), "got: {}", r);
+}
+#[test]
+fn question_mark_wider_inner_than_outer_with_payload() {
+    let r = errText(checkTry(
+        "\
+fun g() -> Try[Int, [A, B(Str)]] =
+  Err(A)
+fun f() -> Try[Int, [A, B(Int)]] =
+  x := g()?
+  Ok(x)
+",
+    ));
+    assert!(r.contains("not part of"), "got: {}", r);
+}
+#[test]
+fn tag_literal_does_not_shadow_declared_enum_variant() {
+    let r = checkTry(
+        "\
+enum Color =
+  | Red
+  | Blue
+fun f() -> Color =
+  Red
+",
+    );
+    assert!(r.is_ok(), "got {:?}", r.err());
+    let bad = checkTry(
+        "\
+enum Color =
+  | Red
+  | Blue
+fun f() -> Try[Int, [Red]] =
+  Err(Red)
+",
+    );
+    assert!(bad.is_err());
+}