cf9e06f | plum | pyrossh

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

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

cf9e06f — Peter John 2026-10-25T17:43:07+05:30

fix(checker): enforce enum variant exhaustiveness in match (recursive through payloads)

Files changed (2) hide show

plum-checker/src/lib.rs +186 -138
plum-checker/tests/checker_tests.rs +118 -8

plum-checker/src/lib.rs CHANGED Viewed

@@ -1220,6 +1220,169 @@ fn checkStmt(
     errors
 }
+enum CoverFail {
+    /// Not covered, but no constructor set to blame here (literal/opaque column
+    /// or no rows) — the enclosing constructor is reported as missing instead.
+    Opaque,
+    /// Uncovered constructors of the type labelled `.0`.
+    Reported(String, Vec<String>),
+}
+struct CoverCtor {
+    name: String,
+    fields: Vec<PlumType>,
+}
+static COVER_WILDCARD: ast::CasePattern = ast::CasePattern::Wildcard;
+fn patCatchAll(p: &ast::CasePattern) -> bool {
+    match p {
+        ast::CasePattern::Wildcard => true,
+        ast::CasePattern::Name(n) => !n.chars().next().is_some_and(|c| c.is_uppercase()),
+        _ => false,
+    }
+}
+/// A constructor pattern: `Ok(n)` / `Red` / `#Tag` -> (name, sub-patterns).
+fn patCtor(p: &ast::CasePattern) -> Option<(&str, &[ast::CasePattern])> {
+    match p {
+        ast::CasePattern::Class { name, fields } => Some((name.as_str(), fields.as_slice())),
+        ast::CasePattern::Name(n) if n.chars().next().is_some_and(|c| c.is_uppercase()) => {
+            Some((n.as_str(), &[]))
+        }
+        _ => None,
+    }
+}
+/// The constructors of a column type (label for messages, constructors), if it
+/// is an enum, `Bool` or a tag union.
+fn coverCtors(ty: &PlumType, ctx: &CheckCtx) -> Option<(String, Vec<CoverCtor>)> {
+    match ty {
+        PlumType::TBool => Some((
+            "Bool".to_string(),
+            ["True", "False"]
+                .iter()
+                .map(|n| CoverCtor {
+                    name: n.to_string(),
+                    fields: Vec::new(),
+                })
+                .collect(),
+        )),
+        PlumType::TTags(tags) => Some((
+            ty.to_string(),
+            tags.iter()
+                .map(|(n, payload)| CoverCtor {
+                    name: n.clone(),
+                    fields: payload.iter().map(|p| (**p).clone()).collect(),
+                })
+                .collect(),
+        )),
+        PlumType::TNamed(enum_name) => {
+            let mut vs: Vec<(&String, &EnumVariantInfo)> = ctx
+                .enum_variants
+                .iter()
+                .filter(|(_, i)| &i.enum_name == enum_name)
+                .collect();
+            if vs.is_empty() {
+                return None;
+            }
+            vs.sort_by_key(|(_, i)| i.tag);
+            Some((
+                variantBaseName(enum_name).to_string(),
+                vs.into_iter()
+                    .map(|(k, i)| CoverCtor {
+                        name: variantBaseName(k).to_string(),
+                        // A discriminant enum's field types are its shared
+                        // params, which patterns never destructure.
+                        fields: if ctx.enum_params.contains_key(enum_name) {
+                            Vec::new()
+                        } else {
+                            i.field_types.clone()
+                        },
+                    })
+                    .collect(),
+            ))
+        }
+        _ => None,
+    }
+}
+/// Pattern-matrix coverage check: do `rows` (one pattern per column of
+/// `types`) match every possible value? Constructor sets are expanded only
+/// where some row actually destructures, so recursive enums terminate.
+fn coverRows<'a>(
+    rows: Vec<Vec<&'a ast::CasePattern>>,
+    types: &[PlumType],
+    ctx: &CheckCtx,
+) -> Result<(), CoverFail> {
+    let Some((ty, rest)) = types.split_first() else {
+        return if rows.is_empty() {
+            Err(CoverFail::Opaque)
+        } else {
+            Ok(())
+        };
+    };
+    let ctors = coverCtors(ty, ctx);
+    let has_ctor_pat = rows.iter().any(|r| patCtor(r[0]).is_some());
+    let (label, ctors) = match ctors {
+        Some(c) if has_ctor_pat => c,
+        other => {
+            // Unresolved/opaque column: a constructor pattern against an
+            // unknown type is given the benefit of the doubt.
+            let unknown = other.is_none();
+            let default: Vec<Vec<&ast::CasePattern>> = rows
+                .iter()
+                .filter(|r| patCatchAll(r[0]) || (unknown && patCtor(r[0]).is_some()))
+                .map(|r| r[1..].to_vec())
+                .collect();
+            return coverRows(default, rest, ctx);
+        }
+    };
+    let mut missing: Vec<String> = Vec::new();
+    let mut deeper: Option<CoverFail> = None;
+    for c in &ctors {
+        let mut sub: Vec<Vec<&ast::CasePattern>> = Vec::new();
+        for r in &rows {
+            let mut row: Vec<&ast::CasePattern> = Vec::new();
+            if patCatchAll(r[0]) {
+                row.extend(std::iter::repeat(&COVER_WILDCARD).take(c.fields.len()));
+            } else if let Some((n, fs)) = patCtor(r[0]) {
+                if tagLiteralName(variantBaseName(n)) != c.name {
+                    continue;
+                }
+                if let ast::CasePattern::Name(_) = r[0] {
+                    // Bare `Circle` against a payload variant: tag check only.
+                    row.extend(std::iter::repeat(&COVER_WILDCARD).take(c.fields.len()));
+                } else if fs.len() == c.fields.len() {
+                    row.extend(fs.iter());
+                } else {
+                    continue;
+                }
+            } else {
+                continue;
+            }
+            row.extend(r[1..].iter().copied());
+            sub.push(row);
+        }
+        let mut tys = c.fields.clone();
+        tys.extend(rest.iter().cloned());
+        match coverRows(sub, &tys, ctx) {
+            Ok(()) => {}
+            Err(CoverFail::Opaque) => missing.push(c.name.clone()),
+            Err(e @ CoverFail::Reported(..)) => {
+                deeper.get_or_insert(e);
+            }
+        }
+    }
+    if !missing.is_empty() {
+        Err(CoverFail::Reported(label, missing))
+    } else if let Some(e) = deeper {
+        Err(e)
+    } else {
+        Ok(())
+    }
+}
 fn checkMatch(
     m: &ast::Match,
     env: &TypeEnv,
@@ -1245,144 +1408,29 @@ fn checkMatch(
         return errors; // a subject failed to type — cases can't be checked meaningfully
     }
-    // A match over a tag union without a catch-all must cover every tag.
-    if let [PlumType::TTags(tags)] = subject_types.as_slice() {
-        let mut covered: std::collections::BTreeSet<&str> = Default::default();
-        let mut catch_all = false;
-        for case in &m.cases {
-            if case.guard.is_some() {
-                continue;
-            }
-            match case.patterns.first() {
-                Some(ast::CasePattern::Wildcard) => catch_all = true,
-                Some(ast::CasePattern::Name(n)) => {
-                    if tags.contains_key(n) {
-                        covered.insert(n.as_str());
-                    } else {
-                        catch_all = true; // a binding
-                    }
-                }
-                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());
-                    }
-                }
-                _ => {}
-            }
-        }
-        if !catch_all {
-            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,
-                        PlumType::TTags(tags.clone()),
-                        missing.join(", ")
-                    ),
-                ));
-            }
-        }
-    }
-    // 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(", ")
-                            ),
-                        ));
-                    }
-                }
-            }
+    // Exhaustiveness: enum / Bool / tag-union subjects must cover every
+    // constructor (recursively through variant payloads) unless a catch-all
+    // arm exists. Literal (Int/Str/Float) subjects are left alone.
+    if let [subject_ty] = subject_types.as_slice() {
+        let rows: Vec<Vec<&ast::CasePattern>> = m
+            .cases
+            .iter()
+            .filter(|c| c.guard.is_none() && c.patterns.len() == 1)
+            .map(|c| vec![&c.patterns[0]])
+            .collect();
+        if let Err(CoverFail::Reported(label, missing)) =
+            coverRows(rows, std::slice::from_ref(subject_ty), ctx)
+        {
+            errors.push(CheckError::at(
+                fn_pos.0,
+                fn_pos.1,
+                format!(
+                    "fn '{}': non-exhaustive match on {}: missing {}",
+                    fn_name,
+                    label,
+                    missing.join(", ")
+                ),
+            ));
         }
     }

plum-checker/tests/checker_tests.rs CHANGED Viewed

@@ -580,9 +580,9 @@ enum Maybe[T] =
 fun get() -> Int =
   o = Just(5)
   match o
-    Some(v) =>
+    Just(v) =>
       v
-    None =>
+    Nothing =>
       0
 ";
     let source = parse(src);
@@ -636,17 +636,17 @@ enum Maybe[T] =
 fun useInt() -> Int =
   o = Just(5)
   match o
-    Some(v) =>
+    Just(v) =>
       v
-    None =>
+    Nothing =>
       0
 fun useStr() -> Str =
   o = Just(\"x\")
   match o
-    Some(v) =>
+    Just(v) =>
       v
-    None =>
+    Nothing =>
       \"z\"
 ";
     let source = parse(src);
@@ -730,9 +730,9 @@ enum Maybe[T] =
 fun unwrapOr(o: Maybe, default: Int) -> Int =
   match o
-    Some(v) =>
+    Just(v) =>
       v
-    None =>
+    Nothing =>
       default
 fun use() -> Int =
@@ -1849,3 +1849,113 @@ fn nested_refutable_payload_does_not_cover_tag() {
     ));
     assert!(r.contains("missing TooOld"), "got: {}", r);
 }
+// ---------- enum variant exhaustiveness ----------
+fn enumMatch(prelude: &str, arms: &str) -> Result<(), Vec<CheckError>> {
+    checkSource(&parseClean(&format!("{}{}", prelude, arms)))
+}
+const COLOR_DEF: &str = "\
+enum Color =
+  | Red
+  | Green
+  | Blue
+fun pick() -> Color =
+  Red
+fun name() -> Str =
+  color := pick()
+  match color
+";
+#[test]
+fn missing_try_ok_variant_is_rejected() {
+    let r = errText(nestedMatch("    Err(BadNumStr) => \"nan\"\n    Err(_) => \"e\"\n"));
+    assert!(r.contains("non-exhaustive match on Try: missing Ok"), "got: {}", r);
+}
+#[test]
+fn missing_enum_variant_is_rejected() {
+    let r = errText(enumMatch(COLOR_DEF, "    Red => \"r\"\n    Green => \"g\"\n"));
+    assert!(r.contains("non-exhaustive match on Color: missing Blue"), "got: {}", r);
+    let ok = enumMatch(COLOR_DEF, "    Red => \"r\"\n    Green => \"g\"\n    Blue => \"b\"\n");
+    assert!(ok.is_ok(), "got {:?}", ok.err());
+}
+#[test]
+fn wildcard_and_binding_arms_make_enum_match_exhaustive() {
+    let w = enumMatch(COLOR_DEF, "    Red => \"r\"\n    _ => \"x\"\n");
+    assert!(w.is_ok(), "got {:?}", w.err());
+    let b = enumMatch(COLOR_DEF, "    Red => \"r\"\n    other => \"x\"\n");
+    assert!(b.is_ok(), "got {:?}", b.err());
+}
+const WRAP_DEF: &str = "\
+enum Inner =
+  | Present(Int)
+  | Absent
+enum Outer =
+  | Wrap(Inner)
+  | Empty
+fun mk() -> Outer =
+  Empty
+fun name() -> Str =
+  o := mk()
+  match o
+";
+#[test]
+fn nested_enum_payload_coverage() {
+    let ok = enumMatch(
+        WRAP_DEF,
+        "    Wrap(Present(v)) => \"p\"\n    Wrap(Absent) => \"a\"\n    Empty => \"e\"\n",
+    );
+    assert!(ok.is_ok(), "got {:?}", ok.err());
+    let r = errText(enumMatch(
+        WRAP_DEF,
+        "    Wrap(Present(v)) => \"p\"\n    Empty => \"e\"\n",
+    ));
+    assert!(r.contains("non-exhaustive match on Inner: missing Absent"), "got: {}", r);
+    let lit = errText(enumMatch(
+        WRAP_DEF,
+        "    Wrap(Present(0)) => \"p\"\n    Wrap(Absent) => \"a\"\n    Empty => \"e\"\n",
+    ));
+    assert!(lit.contains("non-exhaustive match on Inner: missing Present"), "got: {}", lit);
+}
+#[test]
+fn bool_match_exhaustiveness() {
+    let def = "\
+enum Bool =
+  | True
+  | False
+fun f(b: Bool) -> Int =
+  match b
+";
+    let ok = enumMatch(def, "    True => 1\n    False => 0\n");
+    assert!(ok.is_ok(), "got {:?}", ok.err());
+    let r = errText(enumMatch(def, "    True => 1\n"));
+    assert!(r.contains("non-exhaustive match on Bool: missing False"), "got: {}", r);
+}
+#[test]
+fn discriminant_enum_match_exhaustiveness() {
+    let def = "\
+enum Step(n: Int) =
+  | ReadMin(10)
+  | ReadMax(20)
+fun f(s: Step) -> Int =
+  match s
+";
+    let ok = enumMatch(def, "    ReadMin => 1\n    ReadMax => 2\n");
+    assert!(ok.is_ok(), "got {:?}", ok.err());
+    let r = errText(enumMatch(def, "    ReadMin => 1\n"));
+    assert!(r.contains("non-exhaustive match on Step: missing ReadMax"), "got: {}", r);
+}