45a1469 | plum | pyrossh

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

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

45a1469 — Peter John 2026-10-25T17:31:17+05:30

fix(checker): enforce tag exhaustiveness inside variant payloads (Err(Tag) arms)

Files changed (2) hide show

plum-checker/src/lib.rs +87 -0
plum-checker/tests/checker_tests.rs +61 -0

plum-checker/src/lib.rs CHANGED Viewed

@@ -1299,6 +1299,93 @@ fn checkMatch(
         }
     }
+    // A variant field that is itself a tag union (`Err(E)` of `Try[T, [A, B]]`)
+    // must have every tag covered across that variant's arms, unless an arm
+    // catches everything. Only irrefutable sub-patterns count (see `B(0)` above).
+    if let [PlumType::TNamed(enum_name)] = subject_types.as_slice() {
+        let top_catch_all = m.cases.iter().any(|c| {
+            c.guard.is_none()
+                && match c.patterns.first() {
+                    Some(ast::CasePattern::Wildcard) => true,
+                    Some(ast::CasePattern::Name(n)) => {
+                        !n.chars().next().is_some_and(|ch| ch.is_uppercase())
+                    }
+                    _ => false,
+                }
+        });
+        if !top_catch_all {
+            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,
+            };
+            for (vname, info) in ctx.enum_variants.iter() {
+                if &info.enum_name != enum_name {
+                    continue;
+                }
+                let base = variantBaseName(vname);
+                for (idx, fty) in info.field_types.iter().enumerate() {
+                    let PlumType::TTags(tags) = fty else { continue };
+                    let mut seen_arm = false;
+                    let mut catch_all = false;
+                    let mut covered: std::collections::BTreeSet<&str> = Default::default();
+                    for case in &m.cases {
+                        if case.guard.is_some() {
+                            continue;
+                        }
+                        let Some(ast::CasePattern::Class { name, fields }) = case.patterns.first()
+                        else {
+                            continue;
+                        };
+                        if variantBaseName(name) != base || fields.len() != info.field_types.len() {
+                            continue;
+                        }
+                        seen_arm = true;
+                        let others_ok = fields
+                            .iter()
+                            .enumerate()
+                            .all(|(j, f)| j == idx || irrefutable(f));
+                        if !others_ok {
+                            continue;
+                        }
+                        match &fields[idx] {
+                            p if irrefutable(p) => catch_all = true,
+                            ast::CasePattern::Name(t) => {
+                                covered.insert(tagLiteralName(t));
+                            }
+                            ast::CasePattern::Class { name: t, fields: tf }
+                                if tf.iter().all(irrefutable) =>
+                            {
+                                covered.insert(tagLiteralName(t));
+                            }
+                            _ => {}
+                        }
+                    }
+                    if !seen_arm || catch_all {
+                        continue;
+                    }
+                    let missing: Vec<&str> = tags
+                        .keys()
+                        .map(|k| k.as_str())
+                        .filter(|k| !covered.contains(k))
+                        .collect();
+                    if !missing.is_empty() {
+                        errors.push(CheckError::at(
+                            fn_pos.0,
+                            fn_pos.1,
+                            format!(
+                                "fn '{}': non-exhaustive match on {}: missing {}",
+                                fn_name,
+                                fty,
+                                missing.join(", ")
+                            ),
+                        ));
+                    }
+                }
+            }
+        }
+    }
     for case in &m.cases {
         let mut case_env = env.clone();
         if case.patterns.len() == subject_types.len() {

plum-checker/tests/checker_tests.rs CHANGED Viewed

@@ -1788,3 +1788,64 @@ fun main() -> Int =
     let r = checkTry(src);
     assert!(r.is_ok(), "expected Ok, got {}", errText(r));
 }
+const NESTED_E: &str = "[BadNumStr, Negative, TooOld(Int)]";
+fn nestedMatch(arms: &str) -> Result<(), Vec<CheckError>> {
+    checkTry(&format!(
+        "\
+fun parseAge(s: Str) -> Try[Int, {}] =
+  Err(BadNumStr)
+fun describe(s: Str) -> Str =
+  match parseAge(s)
+{}",
+        NESTED_E, arms
+    ))
+}
+#[test]
+fn nested_tag_missing_in_err_is_rejected() {
+    let r = errText(nestedMatch(
+        "    Ok(n) => \"ok\"\n    Err(BadNumStr) => \"nan\"\n    Err(Negative) => \"neg\"\n",
+    ));
+    assert!(
+        r.contains("non-exhaustive match on [BadNumStr,Negative,TooOld(Int)]: missing TooOld"),
+        "got: {}",
+        r
+    );
+}
+#[test]
+fn nested_tags_all_covered_passes() {
+    let r = nestedMatch(
+        "    Ok(n) => \"ok\"\n    Err(BadNumStr) => \"nan\"\n    Err(Negative) => \"neg\"\n    Err(TooOld(a)) => \"old\"\n",
+    );
+    assert!(r.is_ok(), "got {:?}", r.err());
+    let r = nestedMatch(
+        "    Ok(n) => \"ok\"\n    Err(BadNumStr) => \"nan\"\n    Err(Negative) => \"neg\"\n    Err(TooOld(_)) => \"old\"\n",
+    );
+    assert!(r.is_ok(), "got {:?}", r.err());
+}
+#[test]
+fn nested_err_catch_all_passes() {
+    let r = nestedMatch("    Ok(n) => \"ok\"\n    Err(BadNumStr) => \"nan\"\n    Err(_) => \"other\"\n");
+    assert!(r.is_ok(), "got {:?}", r.err());
+    let r = nestedMatch("    Ok(n) => \"ok\"\n    Err(BadNumStr) => \"nan\"\n    Err(e) => \"other\"\n");
+    assert!(r.is_ok(), "got {:?}", r.err());
+}
+#[test]
+fn nested_top_level_wildcard_passes() {
+    let r = nestedMatch("    Ok(n) => \"ok\"\n    Err(BadNumStr) => \"nan\"\n    _ => \"other\"\n");
+    assert!(r.is_ok(), "got {:?}", r.err());
+}
+#[test]
+fn nested_refutable_payload_does_not_cover_tag() {
+    let r = errText(nestedMatch(
+        "    Ok(n) => \"ok\"\n    Err(BadNumStr) => \"nan\"\n    Err(Negative) => \"neg\"\n    Err(TooOld(0)) => \"old\"\n",
+    ));
+    assert!(r.contains("missing TooOld"), "got: {}", r);
+}