a9d88ec | plum | pyrossh

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

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

a9d88ec — Peter John 2026-11-01T23:13:23+05:30

test: dedupe checker Rust tests (246 -> 61), rejection cases as table tests (146 rows)

Files changed (9) hide show

plum-checker/tests/annotated_decl_test.rs +0 -113
plum-checker/tests/checker_tests.rs +184 -1746
plum-checker/tests/error_union_tests.rs +45 -382
plum-checker/tests/examples_test.rs +0 -48
plum-checker/tests/primitive_generics_test.rs +0 -11
plum-checker/tests/unions_coerce_test.rs +0 -120
plum-checker/tests/unions_dispatch_test.rs +0 -150
plum-checker/tests/unions_pattern_test.rs +0 -138
plum-checker/tests/unions_tests.rs +330 -0

plum-checker/tests/annotated_decl_test.rs DELETED Viewed

@@ -1,113 +0,0 @@
-#![allow(non_snake_case)]
-use plum_checker::checkSource;
-use plum_core::unions::{beginPlan, resolveMembers, takePlan, UnionPlan};
-use plum_core::AstParser;
-const DEFS: &str = "\
-record Circle(r: Float)
-record Square(s: Float)
-record Oval(a: Float)
-enum Shape = Circle | Square
-enum Round = Circle | Oval
-enum Json = Float | Str
-enum Tree[T] = Node[T] | Leaf
-record Node[T](v: T)
-";
-fn run(body: &str) -> (Result<(), Vec<String>>, UnionPlan) {
-    let src = format!("{DEFS}\n{body}\n");
-    let mut parser = tree_sitter::Parser::new();
-    parser.set_language(&tree_sitter_plum::LANGUAGE.into()).unwrap();
-    let tree = parser.parse(&src, None).unwrap();
-    assert!(!tree.root_node().has_error(), "parse errors:\n{src}");
-    let mut source = AstParser::new(&src).parseSource(tree.root_node());
-    let errs = resolveMembers(&mut source);
-    assert!(errs.is_empty(), "{errs:?}");
-    beginPlan();
-    let r = checkSource(&source).map_err(|e| e.into_iter().map(|x| x.message).collect());
-    (r, takePlan())
-}
-fn wraps(p: &UnionPlan) -> Vec<String> {
-    let mut v: Vec<String> = p.wraps.values().cloned().collect();
-    v.sort();
-    v
-}
-fn errs(body: &str) -> Vec<String> {
-    run(body).0.unwrap_err()
-}
-#[test]
-fn annotatedUnionLocalRecordsTheWrap() {
-    let (r, p) = run("fun go() -> Int =\n  s: Shape := Circle(r: 2.0)\n  1");
-    r.unwrap();
-    assert_eq!(wraps(&p), vec!["Shape__Circle"]);
-}
-#[test]
-fn annotatedLocalHasTheAnnotationType() {
-    // `s` is a `Shape`, so passing it where a `Shape` is expected needs no wrap.
-    let (r, p) = run("fun take(s: Shape) -> Int =\n  1\n\nfun go() -> Int =\n  s: Shape := Circle(r: 2.0)\n  take(s)");
-    r.unwrap();
-    assert_eq!(wraps(&p), vec!["Shape__Circle"]);
-}
-#[test]
-fn annotatedReassignmentConverts() {
-    let (r, p) = run("fun go() -> Int =\n  s: Shape := Circle(r: 2.0)\n  s = Square(s: 1.0)\n  1");
-    r.unwrap();
-    assert_eq!(wraps(&p), vec!["Shape__Circle", "Shape__Square"]);
-}
-#[test]
-fn annotatedOptionalAcceptsValueAndNull() {
-    let (r, _) = run("fun go() -> Int =\n  a: Int? := 3\n  b: Int? := null\n  1");
-    r.unwrap();
-}
-#[test]
-fn annotatedListAndFnTypes() {
-    let (r, _) = run("fun go() -> Int =\n  xs: List[Int] := List[Int]()\n  f: fn(Int) -> Int := |n| n + 1\n  f(1)");
-    r.unwrap();
-}
-#[test]
-fn annotatedGenericParamInGenericFn() {
-    let (r, _) = run("fun id(x: T) -> T =\n  y: T := x\n  y");
-    r.unwrap();
-}
-#[test]
-fn annotatedMismatchUsesTheNormalText() {
-    let e = errs("fun go() -> Int =\n  s: Int := \"x\"\n  1");
-    assert!(e.iter().any(|m| m.contains("assign 's'") && m.contains("mismatch")), "{e:?}");
-}
-#[test]
-fn annotationWithEqualsIsRejected() {
-    let e = errs("fun go() -> Int =\n  s: Shape = Circle(r: 1.0)\n  1");
-    assert!(e.iter().any(|m| m.contains("annotated declarations use :=")), "{e:?}");
-}
-#[test]
-fn bareAnnotationIsRejected() {
-    let e = errs("fun go() -> Int =\n  total: Float\n  1");
-    assert!(e.iter().any(|m| m.contains("needs a value")), "{e:?}");
-}
-#[test]
-fn annotatedRedeclarationIsRejected() {
-    let e = errs("fun go() -> Int =\n  s := 1\n  s: Int := 2\n  s");
-    assert!(e.iter().any(|m| m.contains("already declared")), "{e:?}");
-}
-#[test]
-fn annotatedFloatTakesAnIntLikeAParamDoes() {
-    let (via_param, _) = run("fun take(x: Float) -> Float =\n  x\n\nfun go() -> Float =\n  take(3)");
-    let (via_decl, _) = run("fun go() -> Float =\n  n: Float := 3\n  n");
-    // Today an Int never converts to a Float param; the annotation adds nothing.
-    assert!(via_param.is_err());
-    assert!(via_decl.is_err());
-}

plum-checker/tests/checker_tests.rs CHANGED Viewed

@@ -1,7 +1,7 @@
 #![allow(non_snake_case)]
 use plum_checker::types::*;
 use plum_checker::{
-    checkSource, plumTypeFromAst, plumTypeFromName,
+    checkSource, plumTypeFromAst,
     typedSource, unify, CheckCtx,
 };
 use plum_core::ast::Type as AstType;
@@ -85,961 +85,25 @@ fn monoScheme() {
 }
 #[test]
-fn validAddFnPasses() {
-    let src = "fun add(a: Int, b: Int) -> Int =\n  a + b\n";
-    let source = parse(src);
-    assert!(checkSource(&source).is_ok(), "expected Ok");
-}
-#[test]
-fn validTestBlockPasses() {
-    let src = "\
-fun add(a: Int, b: Int) -> Int =
-  a + b
-test \"add works\"
-  assert add(1, 2) == 3
-  assert add(2, 2) == 4
-";
-    let source = parse(src);
-    assert!(checkSource(&source).is_ok(), "expected Ok");
-}
-#[test]
-fn nonBoolAssertConditionIsError() {
-    let src = "\
-test \"bad assert\"
-  assert 1 + 2
-";
-    let source = parse(src);
-    let result = checkSource(&source);
-    assert!(result.is_err());
-    let errs = result.unwrap_err();
-    assert!(
-        errs[0].message.contains("assert must be Bool"),
-        "got: {}",
-        errs[0].message
-    );
-}
-#[test]
-fn wrongReturnTypeIsError() {
-    let src = "fun bad() -> Int =\n  true\n";
-    let source = parse(src);
-    let result = checkSource(&source);
-    assert!(result.is_err());
-    let errs = result.unwrap_err();
-    assert!(
-        errs[0].message.contains("return type mismatch"),
-        "got: {}",
-        errs[0].message
-    );
-}
-#[test]
-fn undeclaredVarIsError() {
-    let src = "fun bad() -> Int =\n  x\n";
-    let source = parse(src);
-    let result = checkSource(&source);
-    assert!(result.is_err());
-}
-#[test]
-fn typeMismatchInBinaryOpIsError() {
-    let src = "fun bad() -> Int =\n  1 + 2.0\n";
-    let source = parse(src);
-    let result = checkSource(&source);
-    assert!(result.is_err());
-}
-#[test]
-fn boolLiteralTrueFalseAreBool() {
-    let src = "fun isTrue() -> Bool =\n  true\n";
-    let source = parse(src);
-    assert!(
-        checkSource(&source).is_ok(),
-        "expected Ok, got {:?}",
-        checkSource(&source).err()
-    );
-}
-#[test]
-fn boolLiteralWrongReturnTypeIsError() {
-    let src = "fun bad() -> Int =\n  false\n";
-    let source = parse(src);
-    let result = checkSource(&source);
-    assert!(result.is_err());
-}
-#[test]
-fn methodSelfFieldAccessPasses() {
-    let src =
-        "enum Cat =\n  | Cat(name: Str, age: Int)\n\n  fun getName() -> Str =\n    self.name\n";
-    let source = parse(src);
-    let result = checkSource(&source);
-    assert!(result.is_ok(), "expected Ok, got {:?}", result.err());
-}
-#[test]
-fn methodSelfUnknownFieldIsError() {
-    let src = "enum Cat =\n  | Cat(name: Str)\n\n  fun getAge() -> Int =\n    self.age\n";
-    let source = parse(src);
-    let result = checkSource(&source);
-    assert!(result.is_err());
-}
-#[test]
-fn nestedMethodTypeChecks() {
-    let src =
-        "enum Cat =\n  | Cat(name: Str, age: Int)\n\n  fun getName(self) -> Str =\n    self.name\n";
-    let result = checkSource(&parse(src));
-    assert!(result.is_ok(), "expected Ok, got {:?}", result.err());
-}
-#[test]
-fn nestedMethodUnknownFieldIsError() {
-    let src = "enum Cat =\n  | Cat(name: Str)\n\n  fun getAge(self) -> Int =\n    self.age\n";
-    assert!(checkSource(&parse(src)).is_err());
-}
-#[test]
-fn selfOutsideMethodIsError() {
-    let src = "fun bad() -> Int =\n  self\n";
-    let source = parse(src);
-    let result = checkSource(&source);
-    assert!(result.is_err());
-}
-#[test]
-fn classCallChecksFieldTypes() {
-    let src = "enum Cat =\n  | Cat(name: Str, age: Int)\n\nfun makeCat() -> Cat =\n  Cat(name: \"x\", age: 1)\n";
-    let source = parse(src);
-    let result = checkSource(&source);
-    assert!(result.is_ok(), "expected Ok, got {:?}", result.err());
-}
-#[test]
-fn classCallWrongFieldTypeIsError() {
-    let src = "enum Cat =\n  | Cat(name: Str, age: Int)\n\nfun makeCat() -> Cat =\n  Cat(name: \"x\", age: \"y\")\n";
-    let source = parse(src);
-    let result = checkSource(&source);
-    assert!(result.is_err());
-}
-#[test]
-fn classCallUnknownFieldIsError() {
-    let src =
-        "enum Cat =\n  | Cat(name: Str)\n\nfun makeCat() -> Cat =\n  Cat(name: \"x\", age: 1)\n";
-    let source = parse(src);
-    let result = checkSource(&source);
-    assert!(result.is_err());
-}
-#[test]
-fn methodCallViaAttributeTypeChecksArgs() {
-    let src = "enum Cat =\n  | Cat(name: Str)\n\n  fun rename(n: Str) -> Str =\n    n\n\nfun use(c: Cat) -> Str =\n  c.rename(\"x\")\n";
-    let source = parse(src);
-    let result = checkSource(&source);
-    assert!(result.is_ok(), "expected Ok, got {:?}", result.err());
-}
-#[test]
-fn matchBindsNamePatternToSubjectType() {
-    let src = "fun main(a: Int) -> Int =\n  match a\n    x =>\n      x\n    _ =>\n      0\n";
-    let source = parse(src);
-    let result = checkSource(&source);
-    assert!(result.is_ok(), "expected Ok, got {:?}", result.err());
-}
-#[test]
-fn matchInlineCaseBodyTypeChecks() {
-    // Case bodies can be a single inline expression, not just an indented block.
-    let src = "fun main(a: Int) -> Int =\n  match a\n    1 => 10\n    _ => 0\n";
-    let source = parse(src);
-    let result = checkSource(&source);
-    assert!(result.is_ok(), "expected Ok, got {:?}", result.err());
-}
-#[test]
-fn matchTrueFalseAreVariantPatternsNotBindingsWithoutEnumDecl() {
-    // true/false are built-in Bool variants — they must be recognized as tag
-    // comparisons even when the source doesn't redeclare `enum Bool`, so a
-    // later `_` wildcard arm remains reachable (each pattern binds/compares,
-    // it doesn't just re-bind the subject under the name "true").
-    let src =
-        "fun pick(a: Bool) -> Int =\n  match a\n    true =>\n      1\n    false =>\n      0\n";
-    let source = parse(src);
-    let result = checkSource(&source);
-    assert!(result.is_ok(), "expected Ok, got {:?}", result.err());
-}
-#[test]
-fn matchIntPatternAgainstStrSubjectIsError() {
-    let src = "fun main(a: Str) -> Int =\n  match a\n    1 =>\n      1\n    _ =>\n      0\n";
-    let source = parse(src);
-    let result = checkSource(&source);
-    assert!(result.is_err());
-}
-#[test]
-fn bareEnumTagUnifiesWithOwningEnumType() {
-    // Regression: a bare non-Bool tag like `Nothing` used to type as `TNamed("Nothing")`
-    // (itself, not its enum), so comparing it against a `Maybe` value would wrongly
-    // fail with a type mismatch.
-    let src = "\
-enum Maybe =
-  | Just(Int)
-  | Nothing
-fun isNone(o: Maybe) -> Bool = o == Nothing
-";
-    let source = parse(src);
-    let result = checkSource(&source);
-    assert!(result.is_ok(), "expected Ok, got {:?}", result.err());
-}
-#[test]
-fn variantConstructionChecksArgCountAndTypes() {
-    let src = "\
-enum Maybe =
-  | Just(Int)
-  | Nothing
-fun makeJust(v: Int) -> Maybe =
-  Just(v)
-";
-    let source = parse(src);
-    let result = checkSource(&source);
-    assert!(result.is_ok(), "expected Ok, got {:?}", result.err());
-}
-#[test]
-fn variantConstructionWrongArgTypeIsError() {
-    let src = "\
-enum Maybe =
-  | Just(Int)
-  | Nothing
-fun bad() -> Maybe =
-  Just(\"x\")
-";
-    let source = parse(src);
-    let result = checkSource(&source);
-    assert!(result.is_err());
-}
-#[test]
-fn variantConstructionWrongArgCountIsError() {
-    let src = "\
-enum Shape =
-  | Rect(Float, Float)
-  | Circle(Float)
-fun bad() -> Shape =
-  Rect(1.0)
-";
-    let source = parse(src);
-    let result = checkSource(&source);
-    assert!(result.is_err());
-}
-#[test]
-fn enumDiscriminantValuesTypeCheckWithNoErrors() {
-    let src = "\
-enum Step(n: Int) =
-  | ReadMin(0)
-  | ReadMax(1)
-";
-    let source = parse(src);
-    let result = checkSource(&source);
-    assert!(result.is_ok(), "expected Ok, got {:?}", result.err());
-}
-#[test]
-fn enumDiscriminantWrongValueCountIsError() {
-    let src = "\
-enum Step(n: Int) =
-  | ReadMin(0)
-  | ReadMax
-";
-    let source = parse(src);
-    let result = checkSource(&source);
-    assert!(result.is_err());
-}
-#[test]
-fn enumDiscriminantWronglyTypedValueIsError() {
-    let src = "\
-enum Step(n: Int) =
-  | ReadMin(0)
-  | ReadMax(\"x\")
-";
-    let source = parse(src);
-    let result = checkSource(&source);
-    assert!(result.is_err());
-}
-#[test]
-fn enumDiscriminantValueOnParamLessEnumIsError() {
-    let src = "\
-enum Maybe =
-  | Just(5)
-  | Nothing
-";
-    let source = parse(src);
-    let result = checkSource(&source);
-    assert!(result.is_err());
-}
-#[test]
-fn fieldAccessOnDiscriminantEnumReceiverTypeChecks() {
-    let src = "\
-enum Step(n: Int) =
-  | ReadMin(0)
-  | ReadMax(1)
-  fun toNumber(self) -> Int =
-    self.n
-";
-    let source = parse(src);
-    let result = checkSource(&source);
-    assert!(result.is_ok(), "expected Ok, got {:?}", result.err());
-}
-#[test]
-fn fieldAccessOnOrdinaryEnumReceiverIsUnaffectedByEnumParams() {
-    // An ordinary enum (no discriminant `params`) isn't in `ctx.classes` OR
-    // `ctx.enum_params`, so it falls through to the same permissive "unmodeled
-    // type" escape hatch every other type not in `ctx.classes` gets (codegen,
-    // not the checker, is what would catch a genuinely bad field access here) —
-    // exactly as it did before discriminant enums existed.
-    let src = "\
-enum Maybe =
-  | Just(Int)
-  | Nothing
-  fun bad(self) -> Int =
-    self.n
-";
-    let source = parse(src);
-    let result = checkSource(&source);
-    assert!(result.is_ok(), "expected Ok, got {:?}", result.err());
-}
-#[test]
-fn constructorPatternBindsFieldsToDeclaredTypes() {
-    let src = "\
-enum Shape =
-  | Rect(Float, Float)
-  | Circle(Float)
-fun area(s: Shape) -> Float =
-  match s
-    Rect(w, h) =>
-      w * h
-    Circle(r) =>
-      r * r
-";
-    let source = parse(src);
-    let result = checkSource(&source);
-    assert!(result.is_ok(), "expected Ok, got {:?}", result.err());
-}
-#[test]
-fn constructorPatternWrongFieldCountIsError() {
-    let src = "\
-enum Shape =
-  | Rect(Float, Float)
-  | Circle(Float)
-fun bad(s: Shape) -> Float =
-  match s
-    Rect(w) =>
-      w
-    _ =>
-      0.0
-";
-    let source = parse(src);
-    let result = checkSource(&source);
-    assert!(result.is_err());
-}
-#[test]
-fn bareTypeEnumVariantSugarWrapsTheSameNamedRecordShapedEnum() {
-    // `| Cat` (bare, no `[...]`) naming an already-declared record-shaped enum
-    // (the `type Cat = ...` replacement) is sugar for wrapping that whole
-    // record as the variant's single payload field — shorthand for `| Cat[Cat]`
-    // under a separate tag name. This is the DOP-friendly form: a sealed union
-    // of plain records, matching Java's "sealed interface implemented directly
-    // by records" shape.
-    let src = "\
-record Cat(name: Str)
-enum Animal = Cat | Dog
-fun catName(a: Animal) -> Str =
-  match a
-    Cat(n) =>
-      n
-    Dog =>
-      \"unknown\"
-";
-    let source = parse(src);
-    let result = checkSource(&source);
-    assert!(result.is_ok(), "expected Ok, got: {:?}", result.err());
-}
-#[test]
-fn genericClassInstantiatedAtTwoConcreteTypesTypeChecks() {
-    let src = "\
-enum Box[T] =
-  | Box(value: T)
-fun makeIntBox() -> Box[Int] =
-  Box(value: 5)
-fun makeStrBox() -> Box[Str] =
-  Box(value: \"x\")
-";
-    let source = parse(src);
-    let result = checkSource(&source);
-    assert!(result.is_ok(), "expected Ok, got {:?}", result.err());
-}
-#[test]
-fn genericFunctionCalledWithDifferentConcreteTypesPerSiteTypeChecks() {
-    let src = "\
-fun wrap(value: T) -> Bool =
-  true
-fun useInt() -> Bool =
-  wrap(5)
-fun useStr() -> Bool =
-  wrap(\"x\")
-";
-    let source = parse(src);
-    let result = checkSource(&source);
-    assert!(result.is_ok(), "expected Ok, got {:?}", result.err());
-}
-#[test]
-fn genericFunctionWithTwoIndependentTypeParamsTypeChecks() {
-    let src = "\
-fun pair(first: T, second: U) -> Bool =
-  true
-fun use() -> Bool =
-  pair(1, \"x\")
-";
-    let source = parse(src);
-    let result = checkSource(&source);
-    assert!(result.is_ok(), "expected Ok, got {:?}", result.err());
-}
-#[test]
-fn genericFunctionWithInternallyInconsistentBodyIsRejectedAfterSpecialization() {
-    // A generic function whose body is genuinely inconsistent with its concrete,
-    // correct declared return type must still be REJECTED after specialization.
-    // The `-> Str` on `useIt` means the buggy (unconditional return-overwrite)
-    // behavior — rewriting `wrong$Str`'s `-> Int` to `-> Str` — would make the
-    // whole program type-check, masking the real `expected Int, found Str` error.
-    let src = "\
-fun wrong(x: T) -> Int =
-  \"hello\"
-fun useIt() -> Str =
-  wrong(\"s\")
-";
-    let source = parse(src);
-    let result = checkSource(&source);
-    assert!(
-        result.is_err(),
-        "expected the internally-inconsistent generic function to be rejected, got Ok"
-    );
-}
-#[test]
-fn genericEnumSingleInstantiationTypeChecks() {
-    // A generic Maybe-shaped enum, constructed at one concrete type (`Just(5)`),
-    // matched, must resolve end-to-end via checkSource.
-    let src = "\
-enum Maybe[T] =
-  | Just(T)
-  | Nothing
-fun get() -> Int =
-  o = Just(5)
-  match o
-    Just(v) =>
-      v
-    Nothing =>
-      0
-";
-    let source = parse(src);
-    let result = checkSource(&source);
-    assert!(result.is_ok(), "expected Ok, got {:?}", result.err());
-}
-#[test]
-fn genericEnumMultipleInstantiationsCoexistAndTypeCheck() {
-    // The SAME generic enum instantiated at two different concrete types in one
-    // program must now type-check correctly for BOTH instantiations — this is the
-    // behavior this task adds (previously this was a documented, rejected limitation).
-    let src = "\
-enum Maybe[T] =
-  | Just(T)
-  | Nothing
-fun useInt() -> Int =
-  o = Just(5)
-  match o
-    Just(v) =>
-      v
-    Nothing =>
-      0
-fun useStr() -> Str =
-  o = Just(\"x\")
-  match o
-    Just(v) =>
-      v
-    Nothing =>
-      \"z\"
-";
-    let source = parse(src);
-    let result = checkSource(&source);
-    assert!(result.is_ok(), "expected Ok, got {:?}", result.err());
-}
-#[test]
-fn genericMethodOnGenericClassTypeChecks() {
-    let src = "\
-enum Box[T] =
-  | Box(value: T)
-  fun getValue() -> T =
-    self.value
-fun use() -> Int =
-  b = Box(value: 5)
-  b.getValue()
-";
-    let source = parse(src);
-    let result = checkSource(&source);
-    assert!(result.is_ok(), "expected Ok, got {:?}", result.err());
-}
-#[test]
-fn ordinaryFunctionWithBareGenericEnumParamTypeChecks() {
-    // The shape that broke the pre-existing codegen test: an otherwise-ordinary
-    // function taking a bare generic-enum-typed parameter.
-    let src = "\
-enum Maybe[T] =
-  | Just(T)
-  | Nothing
-fun unwrapOr(o: Maybe[Int], default: Int) -> Int =
-  match o
-    Just(v) =>
-      v
-    Nothing =>
-      default
-fun use() -> Int =
-  unwrapOr(Just(5), 0)
-";
-    let source = parse(src);
-    let result = checkSource(&source);
-    assert!(result.is_ok(), "expected Ok, got {:?}", result.err());
-}
-#[test]
-fn ordinaryFunctionWithBareGenericClassParamTypeChecks() {
-    // The same shape, for a generic CLASS param instead of an enum — untested until
-    // now, but the identical root cause: a generic class param must carry its type
-    // arguments.
-    let src = "\
-enum Box[T] =
-  | Box(value: T)
-  fun getBoxValue() -> T =
-    self.value
-fun sumBox(b: Box[Int]) -> Int =
-  b.getBoxValue()
-fun use() -> Int =
-  sumBox(Box(value: 5))
-";
-    let source = parse(src);
-    let result = checkSource(&source);
-    assert!(result.is_ok(), "expected Ok, got {:?}", result.err());
-}
-#[test]
-fn closureLiteralInfersAsAFunctionType() {
-    let src = "\
-fun useClosure() -> Bool =
-  cb = |v|
-    true
-  cb(5)
-";
-    let source = parse(src);
-    let result = checkSource(&source);
-    assert!(result.is_ok(), "expected Ok, got {:?}", result.err());
-}
-#[test]
-fn fnValueTypedParamCanBeCalled() {
-    let src = "\
-fun each(cb: fn(Int) -> Bool) -> Bool =
-  cb(5)
-";
-    let source = parse(src);
-    let result = checkSource(&source);
-    assert!(result.is_ok(), "expected Ok, got {:?}", result.err());
-}
-#[test]
-fn fieldAssignmentTargetWithMatchingTypePasses() {
-    let src = "\
-enum Cat =
-  | Cat(name: Str, age: Int)
-  fun haveBirthday() =
-    self.age = self.age + 1
-";
-    let source = parse(src);
-    assert!(checkSource(&source).is_ok(), "expected Ok");
-}
-#[test]
-fn fieldAssignmentTargetWithMismatchedTypeIsError() {
-    let src = "\
-enum Cat =
-  | Cat(name: Str, age: Int)
-  fun breakCat() =
-    self.age = \"oops\"
-";
-    let source = parse(src);
-    let result = checkSource(&source);
-    assert!(result.is_err());
-}
-#[test]
-fn fieldAssignmentTargetUnknownFieldIsError() {
-    let src = "\
-enum Cat =
-  | Cat(name: Str, age: Int)
-  fun breakCat() =
-    self.nope = 1
-";
-    let source = parse(src);
-    let result = checkSource(&source);
-    assert!(result.is_err());
-}
-#[test]
-fn closurePassedToFnValueTypedParamTypeChecks() {
-    let src = "\
-fun each(cb: fn(Int) -> Bool) -> Bool =
-  cb(5)
-fun use() -> Bool =
-  each(|v|
-    true)
-";
-    let source = parse(src);
-    let result = checkSource(&source);
-    assert!(result.is_ok(), "expected Ok, got {:?}", result.err());
-}
-#[test]
-fn variadicCallWithZeroTrailingArgsPasses() {
-    let src = "\
-fun sumAll(nums: ...Int) -> Int =
-  0
-fun useSumAll() -> Int =
-  sumAll()
-";
-    let source = parse(src);
-    assert!(checkSource(&source).is_ok(), "expected Ok");
-}
-#[test]
-fn variadicCallWithSeveralTrailingArgsPasses() {
-    let src = "\
-fun sumAll(nums: ...Int) -> Int =
-  0
-fun useSumAll() -> Int =
-  sumAll(1, 2, 3)
-";
-    let source = parse(src);
-    assert!(checkSource(&source).is_ok(), "expected Ok");
-}
-#[test]
-fn enumVariantAsParamTypeAcceptsThatVariant() {
-    let src = "\
-enum Color =
-  | Red
-  | Blue
-fun stringifyColor(v: Red) -> Int =
-  0
-fun useIt() -> Int =
-  stringifyColor(Red)
-";
-    let source = parse(src);
-    assert!(checkSource(&source).is_ok(), "expected Ok");
-}
-#[test]
-fn enumVariantAsParamTypeRejectsADifferentVariant() {
-    let src = "\
-enum Color =
-  | Red
-  | Blue
-fun stringifyColor(v: Red) -> Int =
-  0
-fun useIt() -> Int =
-  stringifyColor(Blue)
-";
-    let source = parse(src);
-    assert!(checkSource(&source).is_err());
-}
-#[test]
-fn variadicCallWithMismatchedTrailingArgTypeIsError() {
-    let src = "\
-fun sumAll(nums: ...Int) -> Int =
-  0
-fun useSumAll() -> Int =
-  sumAll(1, \"two\")
-";
-    let source = parse(src);
-    assert!(checkSource(&source).is_err());
-}
-#[test]
-fn variadicCallWithFixedPrefixPasses() {
-    let src = "\
-fun combine(prefix: Int, rest: ...Int) -> Int =
-  prefix
-fun useCombine() -> Int =
-  combine(1, 2, 3)
-";
-    let source = parse(src);
-    assert!(checkSource(&source).is_ok(), "expected Ok");
-}
-#[test]
-fn twoVariadicParamsIsError() {
-    let src = "\
-fun bad(a: ...Int, b: ...Int) -> Int =
-  0
-";
-    let source = parse(src);
-    assert!(checkSource(&source).is_err());
-}
-#[test]
-fn variadicParamNotLastIsError() {
-    let src = "\
-fun bad(a: ...Int, b: Int) -> Int =
-  0
-";
-    let source = parse(src);
-    assert!(checkSource(&source).is_err());
-}
-#[test]
-fn forLoopOverVariadicBindsElementType() {
-    let src = "\
-fun sumAll(nums: ...Int) -> Int =
-  total = 0
-  for v := range nums
-    total = total + v
-  total
-";
-    let source = parse(src);
-    assert!(checkSource(&source).is_ok(), "expected Ok");
-}
-#[test]
-fn forLoopOverVariadicWithTwoVarsBindsIndexAndElement() {
-    let src = "\
-fun f(nums: ...Int) -> Int =
-  total := 0
-  for i, v := range nums
-    total = total + i * v
-  total
-";
-    let source = parse(src);
-    assert!(checkSource(&source).is_ok(), "expected Ok");
-}
-#[test]
-fn matchDestructuresPlainClassAndBindsFieldTypes() {
-    let src = "\
-enum Point =
-  | Point(x: Int, y: Int)
-fun sumPoint(p: Point) -> Int =
-  match p
-    Point(x, y) => x + y
-";
-    let source = parse(src);
-    assert!(
-        checkSource(&source).is_ok(),
-        "expected Ok, got: {:?}",
-        checkSource(&source)
-    );
-}
-#[test]
-fn matchClassPatternWrongFieldCountIsError() {
-    let src = "\
-enum Point =
-  | Point(x: Int, y: Int)
-fun sumPoint(p: Point) -> Int =
-  match p
-    Point(x) => x
-";
-    let source = parse(src);
-    let result = checkSource(&source);
-    assert!(result.is_err());
-    let errs = result.unwrap_err();
-    assert!(
-        errs.iter()
-            .any(|e| e.message.contains("expects 2 field(s), got 1")),
-        "got: {:?}",
-        errs
-    );
-}
-#[test]
-fn namedPayloadEnumVariantConstructsWithNamedArgs() {
-    let src = "\
-enum Shape =
-  | Circle(radius: Int)
-  | Square(x: Int, y: Int)
-  fun area(self) -> Int =
-    match self
-      Circle(radius) => radius * radius
-      Square(x, y) => x * y
-fun makeCircle() -> Shape =
-  Circle(radius: 5)
-";
-    let source = parse(src);
-    assert!(
-        checkSource(&source).is_ok(),
-        "expected Ok, got: {:?}",
-        checkSource(&source)
-    );
-}
-#[test]
-fn namedPayloadEnumVariantMissingFieldIsError() {
-    let src = "\
-enum Shape =
-  | Square(x: Int, y: Int)
-fun bad() -> Shape =
-  Square(x: 1)
-";
-    let source = parse(src);
-    let result = checkSource(&source);
-    assert!(result.is_err());
-    let errs = result.unwrap_err();
-    assert!(
-        errs.iter()
-            .any(|e| e.message.contains("variant 'Square' missing field 'y'")),
-        "got: {:?}",
-        errs
-    );
-}
-#[test]
-fn namedPayloadEnumVariantUnknownFieldIsError() {
-    let src = "\
-enum Shape =
-  | Square(x: Int, y: Int)
-fun bad() -> Shape =
-  Square(x: 1, y: 2, z: 3)
-";
-    let source = parse(src);
-    let result = checkSource(&source);
-    assert!(result.is_err());
-    let errs = result.unwrap_err();
-    assert!(
-        errs.iter()
-            .any(|e| e.message.contains("unknown field 'z' on variant 'Square'")),
-        "got: {:?}",
-        errs
-    );
-}
-#[test]
-fn fieldAccessOnMultiVariantEnumValueResolvesViaTheUniqueOwningVariant() {
-    // `radius` belongs to exactly one of `Shape`'s variants, so `.radius` on a
-    // `Shape`-typed value type-checks even though `Shape` itself has more than
-    // one variant — codegen compiles it as a checked downcast to `Circle`.
+fn fieldAccessOnOrdinaryEnumReceiverIsUnaffectedByEnumParams() {
+    // An ordinary enum (no discriminant `params`) isn't in `ctx.classes` OR
+    // `ctx.enum_params`, so it falls through to the same permissive "unmodeled
+    // type" escape hatch every other type not in `ctx.classes` gets (codegen,
+    // not the checker, is what would catch a genuinely bad field access here) —
+    // exactly as it did before discriminant enums existed.
     let src = "\
-enum Shape =
+enum Maybe =
-  | Circle(radius: Int)
-  | Square(side: Int)
+  | Just(Int)
+  | Nothing
-fun getRadius(s: Shape) -> Int =
+  fun bad(self) -> Int =
-  r := Circle(radius: 5)
-  return r.radius
+    self.n
 ";
     let source = parse(src);
     let result = checkSource(&source);
     assert!(result.is_ok(), "expected Ok, got {:?}", result.err());
 }
-#[test]
-fn fieldAccessOnMultiVariantEnumValueIsAmbiguousAcrossSameNamedFields() {
-    let src = "\
-enum Shape =
-  | Circle(radius: Int)
-  | Square(radius: Int)
-fun bad() -> Int =
-  r := Circle(radius: 5)
-  return r.radius
-";
-    let source = parse(src);
-    let result = checkSource(&source);
-    assert!(result.is_err());
-    let errs = result.unwrap_err();
-    assert!(
-        errs.iter().any(|e| e
-            .message
-            .contains("field 'radius' is ambiguous across multiple variants of enum 'Shape'")),
-        "got: {:?}",
-        errs
-    );
-}
 // ---------------------------------------------------------------------------
 // Roc-style tag unions + `Try` (T2). Sources define a local `Try` inline.
 // ---------------------------------------------------------------------------
@@ -1071,142 +135,6 @@ fn errText(r: Result<(), Vec<CheckError>>) -> String {
         .join(" | ")
 }
-// ---------- 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_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 = "\
-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);
-}
-fn repoRoot() -> std::path::PathBuf {
-    std::path::Path::new(env!("CARGO_MANIFEST_DIR")).join("..")
-}
-/// Acceptance: every std and example file checks with zero errors on the
-/// source as written (generics are erased, never specialized).
-#[test]
-fn everyStdAndExampleChecksStructurally() {
-    let mut failures: Vec<String> = Vec::new();
-    for dir in ["plum-std", "plum-examples"] {
-        let mut files: Vec<_> = std::fs::read_dir(repoRoot().join(dir))
-            .unwrap()
-            .filter_map(|e| e.ok())
-            .map(|e| e.path())
-            .filter(|p| p.extension().and_then(|e| e.to_str()) == Some("plum"))
-            .collect();
-        files.sort();
-        for path in files {
-            let source = plum_core::loadAndMerge(&path, &repoRoot())
-                .unwrap_or_else(|e| panic!("failed to load {}: {}", path.display(), e));
-            if let Err(errs) = checkSource(&source) {
-                for e in errs {
-                    failures.push(format!(
-                        "{}: {}",
-                        path.file_name().unwrap().to_string_lossy(),
-                        e.message
-                    ));
-                }
-            }
-        }
-    }
-    assert!(failures.is_empty(), "structural check errors:\n{}", failures.join("\n"));
-}
 // ---- structural generics (T2) ----
 const GENERIC_DEFS: &str = "\
@@ -1282,13 +210,6 @@ fn method_own_generic_instantiated_per_call() {
     assert!(errText(bad).contains("type mismatch"));
 }
-#[test]
-fn unbounded_tparam_method_now_ok() {
-    // Bounds are ignored: a method on a bare `T` is checked per instantiation.
-    let r = checkSource(&parseClean("fun f(x: T) -> Int =\n  x.hash()\n"));
-    assert!(r.is_ok(), "uninstantiated unbounded T must not error: {:?}", r.err());
-}
 const DUCK_DEFS: &str = "\
 enum Num =
   | Num(v: Int)
@@ -1304,33 +225,16 @@ fun maxOf(a: T, b: T) -> T =
 ";
-#[test]
-fn duck_ok() {
-    let src = format!(
-        "{}fun main() -> Num =\n  maxOf(Num(v: 1), Num(v: 2))\n",
-        DUCK_DEFS
-    );
-    let r = checkSource(&parseClean(&src));
-    assert!(r.is_ok(), "{:?}", r.err());
-}
-#[test]
-fn duck_missing_method_chain() {
-    let src = format!(
-        "{}fun main() -> Plain =\n  maxOf(Plain(v: 1), Plain(v: 2))\n",
+/// A generic body is only checked per instantiation: an uninstantiated one is never type-errored.
-        DUCK_DEFS
-    );
-    let msg = errText(checkSource(&parseClean(&src)));
-    assert!(msg.contains("called at"), "{}", msg);
-    assert!(msg.contains("in maxOf[Plain]"), "{}", msg);
-    assert!(msg.contains("Plain has no method 'lt'"), "{}", msg);
-}
 #[test]
 fn uninstantiated_generic_not_type_errored() {
     let src = format!("{}fun unused(a: T) -> Int =\n  a.nothing() + \"s\"\n", DUCK_DEFS);
     let r = checkSource(&parseClean(&src));
     assert!(r.is_ok(), "{:?}", r.err());
+    for src in ["fun f(x: T) -> Int =\n  x.hash()\n", "fun f(x: T) -> Int =\n  x\n"] {
+        let r = checkSource(&parseClean(src));
+        assert!(r.is_ok(), "{src}: {:?}", r.err());
+    }
 }
 #[test]
@@ -1347,18 +251,6 @@ fn nested_instantiation_chain() {
     assert!(msg.contains("Plain has no method 'lt'"), "{}", msg);
 }
-#[test]
-fn operator_missing_method_error() {
-    let src = format!(
-        "{}fun twice(a: T) -> T =\n  a + a\n\nfun main() -> Plain =\n  twice(Plain(v: 1))\n",
-        DUCK_DEFS
-    );
-    let msg = errText(checkSource(&parseClean(&src)));
-    assert!(msg.contains("in twice[Plain]"), "{}", msg);
-    assert!(msg.contains("called at"), "{}", msg);
-    assert!(msg.contains("Plain has no operator '+' (define add)"), "{}", msg);
-}
 #[test]
 fn instantiation_set_listed() {
     let src = format!(
@@ -1378,49 +270,6 @@ fn instantiation_set_listed() {
     assert!(!info.inst_expr_types.is_empty());
 }
-#[test]
-fn duck_typed_generic_method_ok() {
-    let src = "\
-enum Keyed[T] =
-  | Keyed(value: T)
-  fun h(self) -> Int =
-    self.value.hash()
-";
-    let r = checkSource(&parseClean(src));
-    assert!(r.is_ok(), "got {:?}", r.err());
-}
-#[test]
-fn generic_free_fn_instantiated_per_call() {
-    let defs = "\
-fun identity(value: T) -> T =
-  value
-fun a() -> Int =
-  identity(5)
-fun b() -> Str =
-  identity(\"x\")
-";
-    assert!(checkSource(&parseClean(&format!("{}{}", GENERIC_DEFS, defs))).is_ok());
-    let bad = "fun identity(value: T) -> T =\n  value\n\nfun a() -> Str =\n  identity(5)\n";
-    assert!(checkSource(&parseClean(bad)).is_err());
-}
-#[test]
-fn generic_return_of_param_rejected_for_concrete_declared_return() {
-    // Duck typing: only an instantiation where `T` is not `Int` is rejected.
-    assert!(checkSource(&parseClean("fun f(x: T) -> Int =\n  x\n")).is_ok());
-    assert!(checkSource(&parseClean(
-        "fun f(x: T) -> Int =\n  x\n\nfun main() -> Int =\n  f(\"s\")\n"
-    ))
-    .is_err());
-    let method = "enum Box[T] =\n  | Box(value: T)\n\n  fun get() -> Int =\n    self.value\n\nfun main() -> Int =\n  Box(value: \"s\").get()\n";
-    assert!(checkSource(&parseClean(method)).is_err());
-    assert!(checkSource(&parseClean("fun f(x: T) -> T =\n  x\n")).is_ok());
-}
 fn hasInferVar(t: &PlumType) -> bool {
     match t {
         PlumType::TVar(_) => true,
@@ -1460,96 +309,8 @@ fn typed_source_has_no_unresolved_infer_vars() {
     assert!(bad.is_empty(), "{:#?}", bad);
 }
-#[test]
-fn probe_nested_generic_substitution() {
-    let ok = "fun f() -> List[Box[Int]] =\n  List(items: Box(value: 1))\n";
-    assert!(checkSource(&parseClean(&format!("{}{}", GENERIC_DEFS, ok))).is_ok());
-    let bad = "fun f() -> List[Box[Str]] =\n  List(items: Box(value: 1))\n";
-    assert!(checkSource(&parseClean(&format!("{}{}", GENERIC_DEFS, bad))).is_err());
-    let m = "fun f() -> List[Str] =\n  List(items: 1).map(|x| x + 1)\n";
-    assert!(checkSource(&parseClean(&format!("{}{}", GENERIC_DEFS, m))).is_err());
-    let m2 = "fun f() -> List[Int] =\n  List(items: 1).map(|x| x + 1)\n";
-    assert!(checkSource(&parseClean(&format!("{}{}", GENERIC_DEFS, m2))).is_ok());
-}
-#[test]
-fn bare_generic_type_in_signature_is_rejected() {
-    let src = "\
-enum Parcel[T] =
-  | Delivered(T)
-  | Lost
-fun contentsOr(p: Parcel, default: Int) -> Int =
-  match p
-    Delivered(v) => v
-    Lost => default
-";
-    let errs = checkSource(&parse(src)).unwrap_err();
-    assert!(
-        errs.iter().any(|e| e
-            .message
-            .contains("generic type 'Parcel' needs type arguments, e.g. Parcel[T]")),
-        "got: {:?}",
-        errs
-    );
-}
-#[test]
-fn bare_generic_type_allowed_inside_its_own_methods() {
-    let src = "\
-enum Box[T] =
-  | Box(value: T)
-  fun same(self) -> Box =
-    self
-";
-    let result = checkSource(&parse(src));
-    assert!(result.is_ok(), "got {:?}", result.err());
-}
 // ---------- built-in Bool (no `import std/Bool`, no `enum Bool`) ----------
-#[test]
-fn builtin_bool_needs_no_import() {
-    let src = "\
-fun both(a: Bool, b: Bool) -> Bool =
-  a && !b || false
-fun main() -> Bool =
-  x := true
-  x == both(true, false)
-";
-    let r = checkSource(&parseClean(src));
-    assert!(r.is_ok(), "got {:?}", r.err());
-}
-#[test]
-fn builtin_bool_match_missing_false_is_rejected() {
-    let r = errText(checkSource(&parseClean(
-        "fun name(b: Bool) -> Str =\n  match b\n    true => \"y\"\n",
-    )));
-    assert!(r.contains("non-exhaustive match on Bool: missing false"), "got: {}", r);
-    let ok = checkSource(&parseClean(
-        "fun name(b: Bool) -> Str =\n  match b\n    true => \"y\"\n    false => \"n\"\n",
-    ));
-    assert!(ok.is_ok(), "got {:?}", ok.err());
-}
-#[test]
-fn true_false_are_never_tags() {
-    let src = "fun f() -> Int =\n  x := true\n  y := false\n  if x == y then 1 else 0\n";
-    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  if a.lt(b) then b else 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.
@@ -1570,48 +331,10 @@ fn nested_chain_exact_sites() {
     assert!(msg.contains("Plain has no method 'nope'"), "{}", msg);
 }
-fn valueErrors(src: &str) -> Vec<String> {
-    match checkSource(&parse(src)) {
-        Ok(()) => vec![],
-        Err(es) => es.into_iter().map(|e| e.message).collect(),
-    }
-}
-#[test]
-fn value_enum_str_field_rejected() {
-    let errs = valueErrors("struct Named(label: Str, n: Int)\n");
-    assert!(
-        errs.iter().any(|e| e.contains("struct field 'label' must be Int, Float, Bool, Byte or a struct")),
-        "{errs:?}"
-    );
-}
-#[test]
-fn value_enum_recursion_rejected() {
-    let errs = valueErrors("struct Ping(b: Pong)\nstruct Pong(a: Ping)\n");
-    assert!(errs.iter().any(|e| e.contains("cannot contain itself")), "{errs:?}");
-}
-#[test]
-fn value_enum_valid_accepted() {
-    let errs = valueErrors("struct Vec2(x: Float, y: Float)\nstruct Rect(pos: Vec2, size: Vec2)\n");
-    assert!(errs.is_empty(), "{errs:?}");
-}
-#[test]
-fn not_iterable_error() {
-    let src = "fun main() -> Int =\n  total := 0\n  for x := range 5.5f\n    total = total + 1\n  total\n";
-    let msg = errText(checkSource(&parseClean(src)));
-    assert!(msg.contains("'5.5f' is not a for-form or iterable"), "{}", msg);
-}
 // ---------------------------------------------------------------------------
 // for-forms: inline funs expanded at `for x := range form(..)` sites (plum-core forms.rs)
 // ---------------------------------------------------------------------------
-const UPTO: &str = "fun* upTo(start: Int, end: Int) *Int =\n  i := start\n  while i < end\n    cur := i\n    i = i + 1\n    yield cur\n\n";
-const TWICE: &str = "fun* twice(n: Int) *Int =\n  for i := range upTo(0, n)\n    yield i\n\n";
 fn twice() -> String {
     format!("{UPTO}{TWICE}")
 }
@@ -1620,22 +343,8 @@ fn formErrors(src: &str) -> String {
     errText(checkSource(&parseClean(src)))
 }
-#[test]
-fn form_expands_and_checks() {
-    let src = format!(
-        "{}fun main() -> Int =\n  total := 0\n  for i := range twice(4), if i > 1\n    total = total + i\n  total\n",
+const UPTO: &str = "fun* upTo(start: Int, end: Int) *Int =\n  i := start\n  while i < end\n    cur := i\n    i = i + 1\n    yield cur\n\n";
-        twice()
-    );
-    assert!(checkSource(&parseClean(&src)).is_ok());
-}
-#[test]
-fn fun_star_range() {
-    let src = format!(
-        "{UPTO}fun main() -> Int =\n  total := 0\n  for i := range upTo(2, 5)\n    total = total + i\n  total\n"
+const TWICE: &str = "fun* twice(n: Int) *Int =\n  for i := range upTo(0, n)\n    yield i\n\n";
-    );
-    assert!(checkSource(&parseClean(&src)).is_ok());
-}
 #[test]
 fn clause_if_keeps_when_true() {
@@ -1650,75 +359,6 @@ fn clause_if_keeps_when_true() {
     assert!(dbg.contains("Not("), "guard should be `if !cond {{ continue }}`: {}", dbg);
 }
-#[test]
-fn misplaced_yield_rejected() {
-    let src = "fun* leaky(n: Int) *Int =\n  x := 1 + yield n\n  x\n\nfun main() -> Int =\n  for i := range leaky(3)\n    i\n  0\n";
-    let parsed = parseClean(src);
-    let msg = errText(checkSource(&parsed));
-    assert!(msg.contains("yield"), "{msg}");
-}
-#[test]
-fn inline_recursion_rejected() {
-    let direct = "fun* loopy(n: Int) *Int =\n  for i := range loopy(n)\n    yield i\n\nfun main() -> Int =\n  for i := range loopy(3)\n    i\n  0\n";
-    assert!(formErrors(direct).contains("fun* 'loopy' can't be recursive"));
-    let mutual = "fun* pingF(n: Int) *Int =\n  for i := range pongF(n)\n    yield i\n\nfun* pongF(n: Int) *Int =\n  for i := range pingF(n)\n    yield i\n\nfun main() -> Int =\n  for i := range pingF(3)\n    i\n  0\n";
-    assert!(formErrors(mutual).contains("can't be recursive"));
-}
-#[test]
-fn fun_star_only_as_for_source() {
-    let src = format!("{}fun main() -> Int =\n  x := twice(3)\n  0\n", twice());
-    assert!(formErrors(&src).contains("fun* 'twice' can only be used as a for source"));
-}
-#[test]
-fn not_a_form_error() {
-    let src = "fun five() -> Float =\n  5.0f\n\nfun main() -> Int =\n  for x := range five()\n    x\n  0\n";
-    assert!(formErrors(src).contains("'five()' is not a for-form or iterable"));
-}
-#[test]
-fn binder_arity_mismatch() {
-    let src = format!("{}fun main() -> Int =\n  for a, b := range twice(3)\n    a\n  0\n", twice());
-    assert!(formErrors(&src).contains("binds 2 names but yields 1"));
-    let two = "fun* pairs(n: Int) *(Int, Int) =\n  yield n, n\n\nfun main() -> Int =\n  for a := range pairs(3)\n    a\n  0\n";
-    assert!(formErrors(two).contains("binds 1 names but yields 2"), "{}", formErrors(two));
-}
-#[test]
-fn star_type_only_on_fun_star() {
-    let src = "fun f(n: Int) *Int =\n  n\n\nfun main() -> Int =\n  0\n";
-    assert!(formErrors(src).contains("*T is only allowed on fun*"), "{}", formErrors(src));
-    let seq = "fun g(n: Int, src: *Int) -> Int =\n  n\n\nfun main() -> Int =\n  0\n";
-    assert!(formErrors(seq).contains("*T is only allowed on fun*"));
-}
-#[test]
-fn fun_star_requires_star_type() {
-    let src = "fun* f(n: Int) -> Int =\n  n\n\nfun main() -> Int =\n  0\n";
-    assert!(formErrors(src).contains("fun* 'f' must declare its yield type (*T)"), "{}", formErrors(src));
-}
-#[test]
-fn fun_star_return_rejected() {
-    let src = "fun* f(n: Int) *Int =\n  return 1\n\nfun main() -> Int =\n  0\n";
-    assert!(formErrors(src).contains("'return' is not allowed"), "{}", formErrors(src));
-}
-#[test]
-fn yield_outside_fun_star_rejected() {
-    let src = "fun main() -> Int =\n  yield 1\n  0\n";
-    assert!(formErrors(src).contains("yield is only allowed inside a fun*"), "{}", formErrors(src));
-}
-#[test]
-fn unused_fun_star_is_checked_at_definition() {
-    let src = "fun* broken(n: Int) *Int =\n  yield n + nope\n\nfun main() -> Int =\n  0\n";
-    let msg = formErrors(src);
-    assert!(msg.contains("fun* 'broken'") && msg.contains("nope"), "{msg}");
-}
 #[test]
 fn fun_star_type_error_at_definition_names_the_fun_star() {
     let src = "fun* bad(n: Int) *Int -> Int =\n  total := 0\n  total = total + \"s\"\n  total\n\nfun main() -> Int =\n  0\n";
@@ -1726,89 +366,6 @@ fn fun_star_type_error_at_definition_names_the_fun_star() {
     assert!(msg.contains("fun* 'bad'") && !msg.contains("__star_"), "{msg}");
 }
-#[test]
-fn expansion_error_names_form_and_use_site() {
-    // the user's body is the broken part: the error names the form and the `for` position
-    let src = format!("{}fun main() -> Int =\n  for i := range twice(4)\n    undefinedName\n  0\n", twice());
-    let msg = formErrors(&src);
-    assert!(msg.contains("undefinedName"), "{msg}");
-    let bad = format!("{}fun main() -> Int =\n  for a, b := range twice(3)\n    a\n  0\n", twice());
-    let msg = formErrors(&bad);
-    assert!(msg.contains("in for-form 'twice' (used at"), "{msg}");
-}
-#[test]
-fn nested_fun_star_forms() {
-    let src = format!(
-        "{}fun* outer(n: Int) *Int =\n  for i := range twice(n)\n    yield i + 1\n\nfun main() -> Int =\n  total := 0\n  for j := range outer(3)\n    total = total + j\n  total\n",
-        twice()
-    );
-    assert!(checkSource(&parseClean(&src)).is_ok(), "{}", formErrors(&src));
-}
-#[test]
-fn seq_value_cannot_be_stored() {
-    for body in ["  saved := src\n  for x := range saved\n    yield x\n", "  for x := range src\n    yield x\n  src\n"] {
-        let src = format!(
-            "fun* leak(src: *T) *T =\n{body}\nfun main() -> Int =\n  for i := range leak(List(1))\n    i\n  0\n"
-        );
-        assert!(
-            formErrors(&src).contains("sequence parameter 'src' can only be used as a for source"),
-            "{}",
-            formErrors(&src)
-        );
-    }
-}
-#[test]
-fn indexed_removed() {
-    // `indexed` is gone from std/Seq: two binders over a list give (position, element).
-    let iter = std::fs::read_to_string(
-        std::path::Path::new(env!("CARGO_MANIFEST_DIR")).join("../plum-std/Seq.plum"),
-    )
-    .unwrap();
-    assert!(!iter.contains("fun* indexed"), "indexed must be removed");
-    assert!(!iter.contains("fun* entries"), "entries moved to Map");
-}
-#[test]
-fn star_method_binder_arity_mismatch() {
-    let src = "enum Bag =\n  | Bag(n: Int)\n\n  fun* pairs(self) *(Int, Int) =\n    yield self.n, self.n\n\nfun main() -> Int =\n  b := Bag(n: 1)\n  for d := range b.pairs()\n    d\n  0\n";
-    assert!(formErrors(src).contains("binds 1 names but yields 2"), "{}", formErrors(src));
-}
-fn checkErr(src: &str) -> String {
-    let source = parse(src);
-    match checkSource(&source) {
-        Ok(_) => String::new(),
-        Err(errs) => errs.iter().map(|e| e.message.clone()).collect::<Vec<_>>().join("\n"),
-    }
-}
-#[test]
-fn bool_literals_lowercase() {
-    let ok = "fun f() -> Bool =\n  x := true\n  y := false\n  x && !y\n";
-    assert!(checkSource(&parse(ok)).is_ok());
-    let bad = "fun f() -> Int =\n  true\n";
-    assert!(checkErr(bad).contains("return type mismatch"), "{}", checkErr(bad));
-}
-#[test]
-fn bool_match_exhaustive() {
-    let ok = "fun f(b: Bool) -> Int =\n  match b\n    true => 1\n    false => 0\n";
-    assert!(checkSource(&parse(ok)).is_ok());
-    let bad = "fun f(b: Bool) -> Int =\n  match b\n    true => 1\n";
-    assert!(checkErr(bad).contains("non-exhaustive match on Bool: missing false"), "{}", checkErr(bad));
-}
-#[test]
-fn capital_True_is_plain_identifier() {
-    let r = checkErr("fun f() -> Bool =\n  True\n");
-    assert!(!r.is_empty(), "`True` must no longer be a Bool literal");
-    let r = checkErr("fun f(b: Bool) -> Int =\n  match b\n    True => 1\n    false => 0\n");
-    assert!(!r.is_empty(), "`True` must not be a Bool pattern");
-}
 // ---- error unions in the type checker (the legacy Try/tag-union tests are gone) ----
 #[test]
@@ -1819,28 +376,6 @@ fn nested_generic_field() {
     );
 }
-#[test]
-fn error_sets_are_covariant_in_generic_arguments() {
-    let defs = "\
-fun wide(b: Box[error{A, B}!Int]) -> Int =
-  1
-fun narrow(b: Box[error{A}!Int]) -> Int =
-  wide(b)
-";
-    let r = checkSource(&parseClean(&format!("{}{}", GENERIC_DEFS, defs)));
-    assert!(r.is_ok(), "got {:?}", r.err());
-    let rev = "\
-fun narrow(b: Box[error{A}!Int]) -> Int =
-  1
-fun bad(b: Box[error{A, B}!Int]) -> Int =
-  narrow(b)
-";
-    let r = checkSource(&parseClean(&format!("{}{}", GENERIC_DEFS, rev)));
-    assert!(r.is_err());
-}
 #[test]
 fn typed_source_records_error_union_return() {
     let source = parseClean(&format!(
@@ -1852,194 +387,12 @@ fn typed_source_records_error_union_return() {
     assert_eq!(lastFnBodyType("fun f() -> error{A}!Int =\n  1\n"), PlumType::TInt);
 }
-#[test]
-fn match_exhaustive_over_error_names() {
-    let base = "\
-fun g(n: Int) -> !Int =
-  if n == 0
-    return error.A
-  if n == 1
-    return error.B
-  n
-fun f(n: Int) -> Int =
-  g(n) catch e
-    match e
-{}";
-    let ok = checkSrc(&base.replace("{}", "      A => 1\n      B => 2\n"));
-    assert!(ok.is_ok(), "got {:?}", ok.err());
-    let wild = checkSrc(&base.replace("{}", "      A => 1\n      _ => 2\n"));
-    assert!(wild.is_ok(), "got {:?}", wild.err());
-    let missing = errText(checkSrc(&base.replace("{}", "      A => 1\n")));
-    assert!(missing.contains("non-exhaustive match on error{A, B}: missing B"), "got: {}", missing);
-    let unknown = checkSrc(&base.replace("{}", "      A => 1\n      C => 3\n      _ => 2\n"));
-    assert!(unknown.is_err());
-}
-#[test]
-fn unknown_lowercase_still_error() {
-    let r = checkSrc("fun f() -> Int =\n  nope\n");
-    assert!(r.is_err());
-    assert!(errText(r).contains("undefined name 'nope'"));
-}
-#[test]
-fn crash_requires_str() {
-    assert!(checkSrc("fun f() -> Int =\n  crash \"boom\"\n").is_ok());
-    let bad = errText(checkSrc("fun f() -> Int =\n  crash 5\n"));
-    assert!(bad.contains("Str"), "got: {}", bad);
-}
 const PERSON: &str = "\
 enum Person =
   | Person(name: Str, age: Int)
 ";
-#[test]
-fn nullable_is_a_distinct_optional_type() {
-    // An optional is not an error union (and vice versa).
-    let r = checkSrc(&format!(
-        "{}fun a(p: Person?) -> error{{Bad}}!Person =\n  p\n",
-        PERSON
-    ));
-    assert!(r.is_err());
-    let r = checkSrc(&format!(
-        "{}fun b(p: error{{Bad}}!Person) -> Person? =\n  p\n",
-        PERSON
-    ));
-    assert!(r.is_err());
-}
-#[test]
-fn null_return_absent() {
-    let r = checkSrc(&format!(
-        "{}fun find(n: Int) -> Person? =\n  if n > 0\n    return Person(name: \"a\", age: n)\n  return null\n",
-        PERSON
-    ));
-    assert!(r.is_ok(), "got {:?}", r.err());
-    // `Missing` is an ordinary name: it is not a value.
-    let bad = checkSrc(&format!("{}fun find() -> Person? =\n  return Missing\n", PERSON));
-    assert!(bad.is_err());
-    // null needs an optional slot.
-    assert!(checkSrc("fun f() -> Int =\n  return null\n").is_err());
-    assert!(checkSrc("fun f() -> !Int =\n  return null\n").is_err());
-    assert!(checkSrc("fun f() -> error{Bad}!Int =\n  return null\n").is_err());
-}
-#[test]
-fn null_without_context_error() {
-    let msg = errText(checkSource(&parseClean("fun f() -> Int =\n  x := null\n  1\n")));
-    assert!(msg.contains("cannot infer the type of null"), "{msg}");
-}
-#[test]
-fn catch_on_optional_rejected() {
-    let msg = errText(checkSource(&parseClean("fun f(a: Int?) -> Int =\n  a catch 0\n")));
-    assert!(msg.contains("catch is for errors; use ?:"), "{msg}");
-}
-#[test]
-fn elvis_on_error_rejected() {
-    let msg = errText(checkSource(&parseClean("fun g() -> error{Bad}!Int = 1\n\nfun f() -> Int =\n  g() ?: 0\n")));
-    assert!(msg.contains("?: is for optionals; use catch"), "{msg}");
-}
-#[test]
-fn try_on_optional_rejected() {
-    let msg = errText(checkSource(&parseClean("fun g() -> Int? = 1\n\nfun f() -> !Int =\n  try g()\n")));
-    assert!(msg.contains("try is for errors; use ?: return null"), "{msg}");
-}
-#[test]
-fn elvis_and_bindings_typecheck() {
-    let r = checkSrc(
-        "\
-fun f(a: Int?, b: Int?) -> Int =
-  x := a ?: b ?: 3
-  if y := a
-    return x + y
-  while z := b
-    return z
-  return if w := a then w else 0
-",
-    );
-    assert!(r.is_ok(), "got {:?}", r.err());
-    // The binding needs an optional.
-    assert!(checkSrc("fun f(a: Int) -> Int =\n  if y := a\n    return y\n  0\n").is_err());
-    // It is not visible outside its body.
-    assert!(checkSrc("fun f(a: Int?) -> Int =\n  if y := a\n    return y\n  y\n").is_err());
-}
-#[test]
-fn error_union_of_optional_nests() {
-    let r = checkSrc(
-        "\
-fun g(n: Int) -> error{Bad}!Int? =
-  if n < 0
-    return error.Bad
-  if n == 0
-    return null
-  n
-fun f(n: Int) -> error{Bad}!Int =
-  v := try g(n)
-  v ?: 0
-",
-    );
-    assert!(r.is_ok(), "got {:?}", r.err());
-}
-#[test]
-fn plain_value_is_the_success_value() {
-    let r = checkSrc("fun f(n: Int) -> error{Neg}!Int =\n  if n < 0\n    return error.Neg\n  return n\n\nfun g(n: Int) -> error{Neg}!Int =\n  n\n");
-    assert!(r.is_ok(), "got {:?}", r.err());
-    assert!(checkSrc("fun g() -> error{Neg}!Int =\n  \"x\"\n").is_err());
-}
-#[test]
-fn safe_nav_chain() {
-    let r = checkSrc(
-        "\
-enum Target =
-  | Target(name: Str)
-enum User =
-  | User(target: Target?)
-fun f(u: User?) -> Str? =
-  u?.target?.name
-",
-    );
-    assert!(r.is_ok(), "got {:?}", r.err());
-}
-#[test]
-fn try_merges_error_sets() {
-    let r = checkSrc(
-        "\
-fun a() -> error{Neg}!Int =
-  1
-fun b() -> error{BadNumStr}!Int =
-  1
-fun f() -> error{Neg, BadNumStr}!Int =
-  x := try a()
-  y := try b()
-  x + y
-",
-    );
-    assert!(r.is_ok(), "got {:?}", r.err());
-}
-#[test]
-fn nested_error_union_is_not_wrapped_twice() {
-    // a plain value is the success value exactly once
-    assert!(checkSrc("fun f(i: Int) -> error{Bad}!Int =\n  return i\n").is_ok());
-    assert!(checkSrc("fun f() -> error{Bad}!Int =\n  return Missing\n").is_err());
-}
 #[test]
 fn tag_unions_and_try_are_gone() {
     // Tag-union types and `T ! [..]` do not parse.
@@ -2050,64 +403,6 @@ fn tag_unions_and_try_are_gone() {
     }
 }
-#[test]
-fn inline_if_branch_type_mismatch() {
-    let src = "fun f(c: Bool) -> Int =\n  if c then 1 else \"no\"\n";
-    let msg = errText(checkSource(&parseClean(src)));
-    assert!(msg.contains("inline if branches"), "{}", msg);
-}
-#[test]
-fn try_precedence_unary() {
-    let src = "fun f() -> !Int = 2\n\nfun g(n: Int) -> !Int =\n  n * try f()\n";
-    let r = checkSource(&parseClean(src));
-    assert!(r.is_ok(), "got {:?}", r.err());
-}
-const PATTERN_IF_ENUM: &str = "enum Shape =\n  | Circle(radius: Int)\n  | Rect(w: Int, h: Int)\n  | Dot\n\n";
-#[test]
-fn pattern_bindings_scoped_to_branch() {
-    let ok = format!("{}fun f(s: Shape) -> Int =\n  if Circle(r) := s\n    return r\n  0\n", PATTERN_IF_ENUM);
-    assert!(checkSource(&parseClean(&ok)).is_ok());
-    let bad = format!("{}fun f(s: Shape) -> Int =\n  if Circle(r) := s\n    return r\n  r\n", PATTERN_IF_ENUM);
-    let msg = errText(checkSource(&parseClean(&bad)));
-    assert!(msg.contains("undefined name"), "{}", msg);
-    let other = format!("{}fun f(s: Shape) -> Int =\n  if Circle(r) := s\n    return r\n  else\n    return r\n  0\n", PATTERN_IF_ENUM);
-    assert!(errText(checkSource(&parseClean(&other))).contains("undefined name"));
-}
-#[test]
-fn pattern_if_guard_sees_bindings_and_must_be_bool() {
-    let ok = format!("{}fun f(s: Shape) -> Int =\n  if Rect(w, h) := s, w > h\n    return w\n  0\n", PATTERN_IF_ENUM);
-    assert!(checkSource(&parseClean(&ok)).is_ok());
-    let bad = format!("{}fun f(s: Shape) -> Int =\n  if Rect(w, h) := s, w\n    return w\n  0\n", PATTERN_IF_ENUM);
-    assert!(checkSource(&parseClean(&bad)).is_err());
-}
-#[test]
-fn pattern_if_wrong_arity_and_non_optional_name_are_errors() {
-    let arity = format!("{}fun f(s: Shape) -> Int =\n  if Rect(w) := s\n    return w\n  0\n", PATTERN_IF_ENUM);
-    assert!(checkSource(&parseClean(&arity)).is_err());
-    let plain = "fun f(n: Int) -> Int =\n  if x := n\n    return x\n  0\n";
-    assert!(checkSource(&parseClean(plain)).is_err());
-}
-#[test]
-fn pattern_if_needs_no_exhaustiveness() {
-    let src = format!("{}fun f(s: Shape) -> Int =\n  if Dot := s\n    return 1\n  0\n", PATTERN_IF_ENUM);
-    assert!(checkSource(&parseClean(&src)).is_ok());
-}
-#[test]
-fn comparing_an_optional_or_error_union_with_a_value_is_rejected() {
-    let msg = errText(checkSource(&parseClean("fun f(a: Int?) -> Bool =\n  a == 3\n")));
-    assert!(msg.contains("cannot compare"), "{msg}");
-    let msg = errText(checkSource(&parseClean("fun f(a: error{Bad}!Int) -> Bool =\n  a == 3\n")));
-    assert!(msg.contains("cannot compare"), "{msg}");
-    assert!(checkSource(&parseClean("fun f(a: Int?) -> Bool =\n  a == null\n")).is_ok());
-}
 #[test]
 fn unknown_method_on_heap_const_is_checker_error() {
     let src = |call: &str| {
@@ -2134,31 +429,174 @@ fn recovered_call_failure_does_not_reposition_genuine_error() {
     assert_eq!((e.line, e.column), (9, 1), "{:?}", errs);
 }
-#[test]
+// ---------------------------------------------------------------------------
-fn const_shaped_name_pattern_on_int_is_rejected() {
+// Rejected programs, table-driven by area. Each row is (source, needles): the
-    for src in [
-        "fun f(n: Int) -> Int =\n  match n\n    MAX => 1\n    _ => 0\n",
+// checker must reject the source and every needle must appear in its messages.
+// Valid programs are covered by the Plum `test` blocks in plum-std/plum-examples.
+// ---------------------------------------------------------------------------
-        "fun f(n: Int) -> Int =\n  if MAX := n\n    return 1\n  0\n",
+type Row = (String, &'static [&'static str]);
-    ] {
-        let msg = errText(checkSrc(src));
-        assert!(msg.contains("'MAX' is not a variant of Int"), "{msg}");
+fn r(src: &str, needles: &'static [&'static str]) -> Row {
-    }
+    (src.to_string(), needles)
 }
-#[test]
-fn digit_variant_pattern_still_works() {
-    let src = "enum V2 =\n  | A1(n: Int)\n  | B2\n\nfun f(w: V2) -> Int =\n  match w\n    A1(n) => n\n    B2 => 0\n\nfun g(w: V2) -> Int =\n  if B2 := w\n    return 1\n  0\n";
-    assert!(checkSrc(src).is_ok());
+fn assertRejected(rows: Vec<Row>) {
+    for (src, needles) in rows {
+        let msg = match checkSource(&parseClean(&src)) {
+            Ok(()) => panic!("expected the checker to reject:\n{src}"),
+            Err(es) => es.iter().map(|e| e.message.clone()).collect::<Vec<_>>().join(" | "),
+        };
+        for n in needles {
+            assert!(msg.contains(n), "{src}\nexpected {n:?} in: {msg}");
+        }
+    }
 }
 #[test]
-fn eq_on_functions_and_unit_is_rejected() {
-    for (src, want) in [
-        ("fun f() -> Bool =\n  a := |x| x\n  b := |x| x\n  a == b\n", "can't compare functions"),
-        ("fun f(a: fn(Int) -> Int, b: fn(Int) -> Int) -> Bool =\n  a == b\n", "can't compare functions"),
-        ("fun u() =\n  return\n\nfun f() -> Bool =\n  u() == u()\n", "can't compare Unit values"),
-    ] {
-        let msg = errText(checkSrc(src));
-        assert!(msg.contains(want), "{src}: {msg}");
-    }
+fn rejects_basic_expressions_and_calls() {
+    let cat = "enum Cat =\n  | Cat(name: Str, age: Int)\n\n";
+    assertRejected(vec![
+        r("test \"bad assert\"\n  assert 1 + 2\n", &["assert must be Bool"]),
+        r("fun bad() -> Int =\n  true\n", &["return type mismatch"]),
+        r("fun bad() -> Int =\n  false\n", &["return type mismatch"]),
+        r("fun bad() -> Int =\n  x\n", &["undefined name 'x'"]),
+        r("fun bad() -> Int =\n  1 + 2.0\n", &["binary op: type mismatch"]),
+        r("fun bad() -> Int =\n  self\n", &["undefined name 'self'"]),
+        r("fun f() -> Int =\n  nope\n", &["undefined name 'nope'"]),
+        r("fun f() -> Int =\n  crash 5\n", &["Str"]),
+        r("fun f(c: Bool) -> Int =\n  if c then 1 else \"no\"\n", &["inline if branches"]),
+        r("fun f() -> Bool =\n  True\n", &["found True"]),
+        r("fun f(b: Bool) -> Int =\n  match b\n    True => 1\n    false => 0\n", &["not a variant of Bool"]),
+        r("fun main() -> Int =\n  total := 0\n  for x := range 5.5f\n    total = total + 1\n  total\n", &["'5.5f' is not a for-form or iterable"]),
+        r("fun five() -> Float =\n  5.0f\n\nfun main() -> Int =\n  for x := range five()\n    x\n  0\n", &["'five()' is not a for-form or iterable"]),
+        r("fun a(p: Int) -> Int =\n  p\n\nfun main() =\n  x := a(\"a\" => 1)\n", &["import std/Map"]),
+        r("fun f() -> Bool =\n  a := |x| x\n  b := |x| x\n  a == b\n", &["can't compare functions"]),
+        r("fun f(a: fn(Int) -> Int, b: fn(Int) -> Int) -> Bool =\n  a == b\n", &["can't compare functions"]),
+        r("fun u() =\n  return\n\nfun f() -> Bool =\n  u() == u()\n", &["can't compare Unit values"]),
+        r("fun f(a: Int?) -> Bool =\n  a == 3\n", &["cannot compare"]),
+        r("fun f(a: error{Bad}!Int) -> Bool =\n  a == 3\n", &["cannot compare"]),
+        // enum/class fields and constructors
+        r(&format!("{cat}fun getAge() -> Int =\n  self.age\n"), &["undefined name 'self'"]),
+        r("enum Cat =\n  | Cat(name: Str)\n\n  fun getAge() -> Int =\n    self.age\n", &["no field 'age' on type 'Cat'"]),
+        r("enum Cat =\n  | Cat(name: Str)\n\n  fun getAge(self) -> Int =\n    self.age\n", &["no field 'age' on type 'Cat'"]),
+        r(&format!("{cat}fun makeCat() -> Cat =\n  Cat(name: \"x\", age: \"y\")\n"), &["variant 'Cat' field 'age': type mismatch"]),
+        r("enum Cat =\n  | Cat(name: Str)\n\nfun makeCat() -> Cat =\n  Cat(name: \"x\", age: 1)\n", &["unknown field 'age' on variant 'Cat'"]),
+        r(&format!("{cat}  fun breakCat() =\n    self.age = \"oops\"\n"), &["assign 'self.age': type mismatch"]),
+        r(&format!("{cat}  fun breakCat() =\n    self.nope = 1\n"), &["no field 'nope' on type 'Cat'"]),
+        r("enum Shape =\n  | Square(x: Int, y: Int)\n\nfun bad() -> Shape =\n  Square(x: 1)\n", &["variant 'Square' missing field 'y'"]),
+        r("enum Shape =\n  | Square(x: Int, y: Int)\n\nfun bad() -> Shape =\n  Square(x: 1, y: 2, z: 3)\n", &["unknown field 'z' on variant 'Square'"]),
+        r("enum Shape =\n  | Circle(radius: Int)\n  | Square(radius: Int)\n\nfun bad() -> Int =\n  r := Circle(radius: 5)\n  return r.radius\n", &["field 'radius' is ambiguous across multiple variants of enum 'Shape'"]),
+        r("enum Maybe =\n  | Just(Int)\n  | Nothing\n\nfun bad() -> Maybe =\n  Just(\"x\")\n", &["variant 'Just' arg 0: type mismatch"]),
+        r("enum Shape =\n  | Rect(Float, Float)\n  | Circle(Float)\n\nfun bad() -> Shape =\n  Rect(1.0)\n", &["variant 'Rect': expected 2 arg(s), got 1"]),
+        // enum discriminants
+        r("enum Step(n: Int) =\n  | ReadMin(0)\n  | ReadMax\n", &["expected 1 discriminant value(s), got 0"]),
+        r("enum Step(n: Int) =\n  | ReadMin(0)\n  | ReadMax(\"x\")\n", &["param 'n': type mismatch: expected Int, found Str"]),
+        r("enum Maybe =\n  | Just(5)\n  | Nothing\n", &["declares no params"]),
+        // variant as a parameter type rejects a different variant
+        r("enum Color =\n  | Red\n  | Blue\n\nfun stringifyColor(v: Red) -> Int =\n  0\n\nfun useIt() -> Int =\n  stringifyColor(Blue)\n", &["expected variant 'Red'"]),
+        // variadics
+        r("fun sumAll(nums: ...Int) -> Int =\n  0\n\nfun useSumAll() -> Int =\n  sumAll(1, \"two\")\n", &["variadic arg 1: type mismatch"]),
+        r("fun bad(a: ...Int, b: ...Int) -> Int =\n  0\n", &["at most one variadic parameter is allowed"]),
+        r("fun bad(a: ...Int, b: Int) -> Int =\n  0\n", &["a variadic parameter must be last"]),
+        // value structs
+        r("struct Named(label: Str, n: Int)\n", &["struct field 'label' must be Int, Float, Bool, Byte or a struct"]),
+        r("struct Ping(b: Pong)\nstruct Pong(a: Ping)\n", &["cannot contain itself"]),
+    ]);
+}
+#[test]
+fn rejects_bad_patterns_and_non_exhaustive_matches() {
+    let color = "enum Color =\n  | Red\n  | Green\n  | Blue\n\nfun pick() -> Color =\n  Red\n\nfun name() -> Str =\n  color := pick()\n  match color\n";
+    let wrap = "enum Inner =\n  | Present(Int)\n  | Absent\n\nenum Outer =\n  | Wrap(Inner)\n  | Empty\n\nfun mk() -> Outer =\n  Empty\n\nfun name() -> Str =\n  o := mk()\n  match o\n";
+    let shape = "enum Shape =\n  | Circle(radius: Int)\n  | Rect(w: Int, h: Int)\n  | Dot\n\n";
+    assertRejected(vec![
+        r(&format!("{color}    Red => \"r\"\n    Green => \"g\"\n"), &["non-exhaustive match on Color: missing Blue"]),
+        r(&format!("{wrap}    Wrap(Present(v)) => \"p\"\n    Empty => \"e\"\n"), &["non-exhaustive match on Inner: missing Absent"]),
+        r(&format!("{wrap}    Wrap(Present(0)) => \"p\"\n    Wrap(Absent) => \"a\"\n    Empty => \"e\"\n"), &["non-exhaustive match on Inner: missing Present"]),
+        r("fun f(b: Bool) -> Int =\n  match b\n    true => 1\n", &["non-exhaustive match on Bool: missing false"]),
+        r("enum Step(n: Int) =\n  | ReadMin(10)\n  | ReadMax(20)\n\nfun f(s: Step) -> Int =\n  match s\n    ReadMin => 1\n", &["non-exhaustive match on Step: missing ReadMax"]),
+        r("fun main(a: Str) -> Int =\n  match a\n    1 =>\n      1\n    _ =>\n      0\n", &["match case: type mismatch: expected Str, found Int"]),
+        r("enum Shape =\n  | Rect(Float, Float)\n  | Circle(Float)\n\nfun bad(s: Shape) -> Float =\n  match s\n    Rect(w) =>\n      w\n    _ =>\n      0.0\n", &["expects 2 field(s), got 1"]),
+        r("enum Point =\n  | Point(x: Int, y: Int)\n\nfun sumPoint(p: Point) -> Int =\n  match p\n    Point(x) => x\n", &["expects 2 field(s), got 1"]),
+        r("fun f(n: Int) -> Int =\n  match n\n    MAX => 1\n    _ => 0\n", &["'MAX' is not a variant of Int"]),
+        r("fun f(n: Int) -> Int =\n  if MAX := n\n    return 1\n  0\n", &["'MAX' is not a variant of Int"]),
+        // pattern-if
+        r(&format!("{shape}fun f(s: Shape) -> Int =\n  if Circle(r) := s\n    return r\n  r\n"), &["undefined name"]),
+        r(&format!("{shape}fun f(s: Shape) -> Int =\n  if Circle(r) := s\n    return r\n  else\n    return r\n  0\n"), &["undefined name"]),
+        r(&format!("{shape}fun f(s: Shape) -> Int =\n  if Rect(w, h) := s, w\n    return w\n  0\n"), &["condition after ',' must be Bool"]),
+        r(&format!("{shape}fun f(s: Shape) -> Int =\n  if Rect(w) := s\n    return w\n  0\n"), &["expects 2 field(s), got 1"]),
+        r("fun f(n: Int) -> Int =\n  if x := n\n    return x\n  0\n", &["needs an optional (T?)"]),
+        r("fun f(a: Int) -> Int =\n  if y := a\n    return y\n  0\n", &["needs an optional (T?)"]),
+        r("fun f(a: Int?) -> Int =\n  if y := a\n    return y\n  y\n", &["undefined name 'y'"]),
+    ]);
+}
+#[test]
+fn rejects_bad_generics_and_duck_typed_calls() {
+    let duck_missing = format!("{DUCK_DEFS}fun main() -> Plain =\n  maxOf(Plain(v: 1), Plain(v: 2))\n");
+    let op_missing = format!("{DUCK_DEFS}fun twice(a: T) -> T =\n  a + a\n\nfun main() -> Plain =\n  twice(Plain(v: 1))\n");
+    let generic = |tail: &str| format!("{GENERIC_DEFS}{tail}");
+    assertRejected(vec![
+        r(&duck_missing, &["called at", "in maxOf[Plain]", "Plain has no method 'lt'"]),
+        r(&op_missing, &["in twice[Plain]", "called at", "Plain has no operator '+' (define add)"]),
+        r("fun maxOf(a: T, b: T) -> T =\n  if a.lt(b) then b else a\n\nfun main() -> Int =\n  maxOf(1, 2)\n", &["in maxOf[Int] (called at ", "Int has no method 'lt'"]),
+        // a generic body inconsistent with its declared return is rejected once instantiated
+        r("fun wrong(x: T) -> Int =\n  \"hello\"\n\nfun useIt() -> Str =\n  wrong(\"s\")\n", &["in wrong[Str]"]),
+        r("fun identity(value: T) -> T =\n  value\n\nfun a() -> Str =\n  identity(5)\n", &["expected Str, found Int"]),
+        r("fun f(x: T) -> Int =\n  x\n\nfun main() -> Int =\n  f(\"s\")\n", &["in f[Str]"]),
+        r("enum Box[T] =\n  | Box(value: T)\n\n  fun get() -> Int =\n    self.value\n\nfun main() -> Int =\n  Box(value: \"s\").get()\n", &["in Box.get[Str]"]),
+        r(&generic("fun f() -> List[Box[Str]] =\n  List(items: Box(value: 1))\n"), &["variant 'Box' field 'value': type mismatch"]),
+        r(&generic("fun f() -> List[Str] =\n  List(items: 1).map(|x| x + 1)\n"), &["method 'List.map' arg 0: type mismatch"]),
+        r(&generic("fun f(xs: List[Int]) -> List[Int] =\n  xs.map(|n| \"{n}\")\n"), &["type mismatch"]),
+        r("enum Parcel[T] =\n  | Delivered(T)\n  | Lost\n\nfun contentsOr(p: Parcel, default: Int) -> Int =\n  match p\n    Delivered(v) => v\n    Lost => default\n", &["generic type 'Parcel' needs type arguments, e.g. Parcel[T]"]),
+        // error sets are covariant in generic arguments, not contravariant
+        r(&generic("fun narrow(b: Box[error{A}!Int]) -> Int =\n  1\n\nfun bad(b: Box[error{A, B}!Int]) -> Int =\n  narrow(b)\n"), &["is not in the pinned error set error{A}"]),
+    ]);
+}
+#[test]
+fn rejects_bad_for_forms_and_fun_stars() {
+    let tw = twice();
+    assertRejected(vec![
+        r("fun* leaky(n: Int) *Int =\n  x := 1 + yield n\n  x\n\nfun main() -> Int =\n  for i := range leaky(3)\n    i\n  0\n", &["yield"]),
+        r("fun* loopy(n: Int) *Int =\n  for i := range loopy(n)\n    yield i\n\nfun main() -> Int =\n  for i := range loopy(3)\n    i\n  0\n", &["fun* 'loopy' can't be recursive"]),
+        r("fun* pingF(n: Int) *Int =\n  for i := range pongF(n)\n    yield i\n\nfun* pongF(n: Int) *Int =\n  for i := range pingF(n)\n    yield i\n\nfun main() -> Int =\n  for i := range pingF(3)\n    i\n  0\n", &["can't be recursive"]),
+        r(&format!("{tw}fun main() -> Int =\n  x := twice(3)\n  0\n"), &["fun* 'twice' can only be used as a for source"]),
+        r(&format!("{tw}fun main() -> Int =\n  for a, b := range twice(3)\n    a\n  0\n"), &["binds 2 names but yields 1", "in for-form 'twice' (used at"]),
+        r("fun* pairs(n: Int) *(Int, Int) =\n  yield n, n\n\nfun main() -> Int =\n  for a := range pairs(3)\n    a\n  0\n", &["binds 1 names but yields 2"]),
+        r("enum Bag =\n  | Bag(n: Int)\n\n  fun* pairs(self) *(Int, Int) =\n    yield self.n, self.n\n\nfun main() -> Int =\n  b := Bag(n: 1)\n  for d := range b.pairs()\n    d\n  0\n", &["binds 1 names but yields 2"]),
+        r("fun f(n: Int) *Int =\n  n\n\nfun main() -> Int =\n  0\n", &["*T is only allowed on fun*"]),
+        r("fun g(n: Int, src: *Int) -> Int =\n  n\n\nfun main() -> Int =\n  0\n", &["*T is only allowed on fun*"]),
+        r("fun* f(n: Int) -> Int =\n  n\n\nfun main() -> Int =\n  0\n", &["fun* 'f' must declare its yield type (*T)"]),
+        r("fun* f(n: Int) *Int =\n  return 1\n\nfun main() -> Int =\n  0\n", &["'return' is not allowed"]),
+        r("fun main() -> Int =\n  yield 1\n  0\n", &["yield is only allowed inside a fun*"]),
+        r("fun* broken(n: Int) *Int =\n  yield n + nope\n\nfun main() -> Int =\n  0\n", &["fun* 'broken'", "nope"]),
+        r(&format!("{tw}fun main() -> Int =\n  for i := range twice(4)\n    undefinedName\n  0\n"), &["undefinedName"]),
+        r("fun* leak(src: *T) *T =\n  saved := src\n  for x := range saved\n    yield x\n\nfun main() -> Int =\n  for i := range leak(List(1))\n    i\n  0\n", &["sequence parameter 'src' can only be used as a for source"]),
+        r("fun* leak(src: *T) *T =\n  for x := range src\n    yield x\n  src\n\nfun main() -> Int =\n  for i := range leak(List(1))\n    i\n  0\n", &["sequence parameter 'src' can only be used as a for source"]),
+    ]);
+}
+#[test]
+fn rejects_bad_optionals_and_error_unions() {
+    let person = PERSON;
+    let base = "fun g(n: Int) -> !Int =\n  if n == 0\n    return error.A\n  if n == 1\n    return error.B\n  n\n\nfun f(n: Int) -> Int =\n  g(n) catch e\n    match e\n";
+    assertRejected(vec![
+        r(&format!("{base}      A => 1\n"), &["non-exhaustive match on error{A, B}: missing B"]),
+        r(&format!("{base}      A => 1\n      C => 3\n      _ => 2\n"), &["'C' is not in the error set [A, B]"]),
+        r("fun f() -> Int =\n  x := null\n  1\n", &["cannot infer the type of null"]),
+        r("fun f() -> Int =\n  return null\n", &["found error{null}"]),
+        r("fun f() -> !Int =\n  return null\n", &["only an optional (T?) can be null"]),
+        r("fun f() -> error{Bad}!Int =\n  return null\n", &["only an optional (T?) can be null"]),
+        r("fun f(a: Int?) -> Int =\n  a catch 0\n", &["catch is for errors; use ?:"]),
+        r("fun g() -> error{Bad}!Int = 1\n\nfun f() -> Int =\n  g() ?: 0\n", &["?: is for optionals; use catch"]),
+        r("fun g() -> Int? = 1\n\nfun f() -> !Int =\n  try g()\n", &["try is for errors; use ?: return null"]),
+        r(&format!("{person}fun a(p: Person?) -> error{{Bad}}!Person =\n  p\n"), &["an optional is handled with"]),
+        r(&format!("{person}fun b(p: error{{Bad}}!Person) -> Person? =\n  p\n"), &["an error union is handled with"]),
+        r(&format!("{person}fun find() -> Person? =\n  return Missing\n"), &["expected Person?, found Missing"]),
+        r("fun f() -> error{Bad}!Int =\n  return Missing\n", &["expected error{Bad}!Int, found Missing"]),
+        r("fun g() -> error{Neg}!Int =\n  \"x\"\n", &["expected error{Neg}!Int, found Str"]),
+    ]);
 }

plum-checker/tests/error_union_tests.rs CHANGED Viewed

@@ -68,147 +68,6 @@ fun low(n: Int) -> !Int =
     assert_eq!(setOf(src, "top"), vec!["Deep"]);
 }
-#[test]
-fn pinned_set_rejects_extra() {
-    let src = "\
-fun a(n: Int) -> !Int =
-  return error.Negative
-fun b(n: Int) -> error{Other}!Int =
-  try a(n)
-";
-    let msg = check(src).unwrap_err();
-    assert!(msg.contains("'Negative' is not in the pinned error set error{Other}"), "{}", msg);
-    let ok = "\
-fun a(n: Int) -> error{Negative}!Int =
-  return error.Negative
-fun b(n: Int) -> error{Negative, Other}!Int =
-  try a(n)
-";
-    assert!(check(ok).is_ok(), "{:?}", check(ok));
-    assert!(check("fun c() -> error{A}!Int =\n  return error.B\n").unwrap_err().contains("'B' is not in the pinned"));
-}
-#[test]
-fn recursive_needs_pinned() {
-    let src = "\
-fun fact(n: Int) -> !Int =
-  if n < 0
-    return error.Negative
-  if n == 0
-    return 1
-  n * {try fact(n - 1)}
-";
-    let msg = check(src).unwrap_err();
-    assert!(msg.contains("fn 'fact' is recursive: pin its error set (-> error{..}!T)"), "{}", msg);
-    let pinned = src.replace("-> !Int", "-> error{Negative}!Int");
-    assert!(check(&pinned).is_ok(), "{:?}", check(&pinned));
-    // Mutual recursion.
-    let mutual = "\
-fun even(n: Int) -> !Bool =
-  if n == 0
-    return true
-  try odd(n - 1)
-fun odd(n: Int) -> !Bool =
-  if n == 0
-    return false
-  try even(n - 1)
-";
-    let msg = check(mutual).unwrap_err();
-    assert!(msg.contains("fn 'even' is recursive") && msg.contains("fn 'odd' is recursive"), "{}", msg);
-}
-#[test]
-fn extern_needs_pinned() {
-    let msg = check("extern fun host(n: Int) -> !Int\n").unwrap_err();
-    assert!(msg.contains("extern fn 'host' must pin its error set"), "{}", msg);
-    assert!(check("extern fun host(n: Int) -> error{HostFailed}!Int\n").is_ok());
-}
-#[test]
-fn catch_default_type() {
-    let ok = "\
-fun f() -> !Int =
-  return error.A
-fun g() -> Int =
-  f() catch 0
-";
-    assert!(check(ok).is_ok(), "{:?}", check(ok));
-    let bad = "\
-fun f() -> !Int =
-  return error.A
-fun g() -> Int =
-  f() catch \"zero\"
-";
-    let msg = check(bad).unwrap_err();
-    assert!(msg.contains("catch default") && msg.contains("mismatch"), "{}", msg);
-    // Not an error union.
-    let msg = check("fun g(n: Int) -> Int =\n  n catch 0\n").unwrap_err();
-    assert!(msg.contains("'catch' requires an error union"), "{}", msg);
-}
-#[test]
-fn unhandled_union_is_a_mismatch() {
-    let src = "\
-fun f() -> !Int =
-  return error.A
-fun g() -> Int =
-  f()
-";
-    let msg = check(src).unwrap_err();
-    assert!(msg.contains("handle it with `try`, `!`, `catch` or `?:`"), "{}", msg);
-}
-#[test]
-fn catch_block_exhaustive_match() {
-    let base = "\
-fun f(n: Int) -> !Int =
-  if n < 0
-    return error.Negative
-  if n > 9
-    return error.TooBig
-  n
-";
-    let ok = format!("{}{}", base, "\
-fun g(n: Int) -> Int =
-  f(n) catch e
-    match e
-      Negative => 0
-      TooBig => 9
-");
-    assert!(check(&ok).is_ok(), "{:?}", check(&ok));
-    let missing = format!("{}{}", base, "\
-fun g(n: Int) -> Int =
-  f(n) catch e
-    match e
-      Negative => 0
-");
-    let msg = check(&missing).unwrap_err();
-    assert!(msg.contains("non-exhaustive") && msg.contains("TooBig"), "{}", msg);
-    // A diverging block, and a non-diverging one that yields no value.
-    let div = format!("{}{}", base, "\
-fun g(n: Int) -> Int =
-  x := f(n) catch e
-    return 0
-  x
-");
-    assert!(check(&div).is_ok(), "{:?}", check(&div));
-    let noval = format!("{}{}", base, "\
-fun g(n: Int) -> Int =
-  x := f(n) catch e
-    y := 1
-  x
-");
-    let msg = check(&noval).unwrap_err();
-    assert!(msg.contains("catch block must end with a value"), "{}", msg);
-}
 #[test]
 fn catch_return_error_maps() {
     let src = "\
@@ -225,35 +84,6 @@ fun f(s: Str) -> !Int =
     assert!(msg.contains("Int"), "{}", msg);
 }
-#[test]
-fn catch_bare_error_value_is_type_error() {
-    // A bare `error.X` default is an ordinary value: it must have the success type.
-    let src = "\
-fun parse(s: Str) -> !Int =
-  return error.BadNum
-fun f(s: Str) -> !Int =
-  x := parse(s) catch error.InvalidFirst
-  x
-";
-    let msg = check(src).unwrap_err();
-    assert!(msg.contains("catch default"), "{}", msg);
-    assert!(msg.contains("Int"), "{}", msg);
-}
-#[test]
-fn catch_crash_default() {
-    let src = "\
-fun parse(s: Str) -> !Int =
-  return error.BadNum
-fun f(s: Str) -> Int =
-  x := parse(s) catch crash \"no\"
-  x + 1
-";
-    check(src).unwrap();
-}
 #[test]
 fn bang_not_in_error_set() {
     let src = "\
@@ -284,85 +114,6 @@ fn no_payload_errors() {
     assert!(rejected, "a payload on an error value must be rejected");
 }
-#[test]
-fn catch_e_name() {
-    let src = "\
-fun f() -> !Int =
-  return error.NotFound
-fun g() -> Str =
-  f() catch e
-    return e.name()
-  \"ok\"
-";
-    assert!(check(src).is_ok(), "{:?}", check(src));
-    let src2 = "\
-fun f() -> !Int =
-  return error.NotFound
-fun g() -> Int =
-  f() catch e
-    e.name()
-";
-    let msg = check(src2).unwrap_err();
-    assert!(msg.contains("mismatch"), "{}", msg);
-}
-#[test]
-fn optional_elvis_and_bang() {
-    let src = String::from("\
-fun find(n: Int) -> Str? =
-  if n > 0
-    return \"found\"
-  return null
-fun a(n: Int) -> Str =
-  find(n) ?: \"none\"
-fun b(n: Int) -> Str =
-  find(n)!
-fun c(n: Int) -> Str? =
-  s := find(n) ?: return null
-  s
-");
-    assert!(check(&src).is_ok(), "{:?}", check(&src));
-    // `try` on an optional is a type error.
-    let src = String::from("\
-fun find(n: Int) -> Str? =
-  return null
-fun d(n: Int) -> !Str =
-  try find(n)
-");
-    assert!(check(&src).unwrap_err().contains("try is for errors"));
-}
-#[test]
-fn safe_nav_on_error_union() {
-    let src = "\
-record User(name: Str)
-fun load(n: Int) -> !User =
-  return error.NoUser
-fun name(n: Int) -> !Str =
-  load(n)?.name
-";
-    // Same set; `?.` flattens.
-    assert!(check(src).is_ok(), "{:?}", check(src));
-    let src2 = "\
-record User(name: Str)
-fun load(n: Int) -> !User =
-  return error.NoUser
-fun name(n: Int) -> Str =
-  load(n)?.name catch \"anon\"
-";
-    assert!(check(src2).is_ok(), "{:?}", check(src2));
-}
 #[test]
 fn pinned_set_vs_generic_unambiguous() {
     // Generics next to a pinned set: the set comes first, in front of the `!`.
@@ -404,27 +155,6 @@ fun f() -> !Int =
     }
 }
-#[test]
-fn null_is_absent_anywhere() {
-    // Constructor argument of type `Int?`: not an early return, and legal in a
-    // fn that returns a plain value.
-    let src = "\
-record Cfg(port: Int?)
-fun mk() -> Cfg =
-  Cfg(port: null)
-";
-    assert_eq!(check(src), Ok(()));
-    // A bare variable holds no type for null.
-    assert!(check("fun f() -> Int =\n  x := null\n  1\n").unwrap_err().contains("cannot infer the type of null"));
-    // But it does not fit an `Int` slot.
-    let bad = "fun f() -> Int =\n  return null\n";
-    assert!(check(bad).unwrap_err().contains("type mismatch"));
-    // Only `null` fits a `T?`.
-    assert!(check("fun f() -> Int? =\n  return error.Other\n").is_err());
-    assert_eq!(check("fun f() -> Int? =\n  return null\n"), Ok(()));
-}
 #[test]
 fn error_value_returns_failure() {
     let src = "\
@@ -445,25 +175,6 @@ fun g() -> !Int =
     assert_eq!(check(via), Ok(()));
 }
-#[test]
-fn fail_removed() {
-    let msg = check("fun f() -> !Int =\n  fail Bad\n  1\n").unwrap_err();
-    assert!(msg.contains("undefined name 'fail'"), "{}", msg);
-}
-#[test]
-fn old_bracket_pin_removed() {
-    // `!Int [A]` is now just `Int[A]` generics, not a pinned set.
-    assert!(check("fun f() -> !Int [A] =\n  return error.A\n").is_err());
-}
-#[test]
-fn inline_set_pins() {
-    assert_eq!(check("fun f() -> error{A, B}!Int =\n  return error.A\n"), Ok(()));
-    let msg = check("fun f() -> error{A}!Int =\n  return error.B\n").unwrap_err();
-    assert!(msg.contains("'B' is not in the pinned error set error{A}"), "{}", msg);
-}
 #[test]
 fn named_set_pins() {
     let src = "\
@@ -506,89 +217,6 @@ fun g() -> (A1 || error{Dd})!Int =
     assert_eq!(setOf(src, "g"), vec!["Aa", "Bb", "Dd"]);
 }
-#[test]
-fn pinned_rejects_extra() {
-    let src = "\
-error Small = Aa
-fun a() -> error{Aa, Bb}!Int =
-  return error.Aa
-fun b() -> Small!Int =
-  try a()
-";
-    let msg = check(src).unwrap_err();
-    assert!(msg.contains("'Bb' is not in the pinned error set"), "{}", msg);
-}
-#[test]
-fn match_bare_names() {
-    let base = "\
-error Two = Aa | Bb
-fun f(e: Two) -> Int =
-  match e
-{}";
-    assert_eq!(check(&base.replace("{}", "    Aa => 1\n    Bb => 2\n")), Ok(()));
-    let msg = check(&base.replace("{}", "    Aa => 1\n")).unwrap_err();
-    assert!(msg.contains("missing Bb"), "{}", msg);
-}
-#[test]
-fn match_error_prefix_accepted() {
-    let base = "\
-error Two = Aa | Bb
-fun f(e: Two) -> Int =
-  match e
-{}";
-    assert_eq!(check(&base.replace("{}", "    error.Aa => 1\n    Bb => 2\n")), Ok(()));
-    let msg = check(&base.replace("{}", "    error.Aa => 1\n    error.Zz => 2\n    _ => 3\n")).unwrap_err();
-    assert!(msg.contains("'Zz' is not in the error set"), "{}", msg);
-}
-#[test]
-fn duplicate_error_set_name() {
-    let msg = check("error Dup = Aa\nerror Dup = Bb\n\nfun f() -> Int =\n  1\n").unwrap_err();
-    assert!(msg.contains("duplicate error set 'Dup'"), "{}", msg);
-}
-#[test]
-fn match_arm_names_must_be_in_the_error_set() {
-    let base = "\
-fun f(n: Int) -> !Int =
-  if n < 0
-    return error.Negative
-  if n > 9
-    return error.TooBig
-  n
-";
-    let bad = format!("{}{}", base, "\
-fun g(n: Int) -> Int =
-  f(n) catch e
-    match e
-      Negative => 0
-      TooBig => 9
-      Bogus => 1
-");
-    let msg = check(&bad).unwrap_err();
-    assert!(msg.contains("'Bogus' is not in the error set [Negative, TooBig]"), "{}", msg);
-    // An empty set (a union that can't fail) accepts no arm names either.
-    let empty = "\
-fun safe(n: Int) -> !Int =
-  n
-fun g(n: Int) -> Int =
-  safe(n) catch e
-    match e
-      Anything => 0
-      _ => 1
-";
-    let msg = check(empty).unwrap_err();
-    assert!(msg.contains("'Anything' is not in the error set []"), "{}", msg);
-}
 #[test]
 fn try_inside_star_fn_has_a_specific_message() {
     let src = "\
@@ -610,15 +238,50 @@ fun* gen(n: Int) *Int =
     assert!(!msg.contains("declare `-> !T`"), "{}", msg);
 }
-#[test]
-fn undefined_pair_hint() {
-    let src = "\
-fun f(a: Int) -> Int =
-  a
-fun main() =
-  x := f(\"a\" => 1)
-";
-    let msg = check(src).unwrap_err();
-    assert!(msg.contains("import std/Map"), "{}", msg);
+/// Rejected programs: every row must fail the checker with each needle in its messages.
+/// (Valid error-union programs are covered by the Plum tests in plum-std.)
+#[test]
+fn rejects_bad_error_unions() {
+    let fneg = "fun f(n: Int) -> !Int =\n  if n < 0\n    return error.Negative\n  if n > 9\n    return error.TooBig\n  n\n\n";
+    let two = "error Two = Aa | Bb\n\nfun f(e: Two) -> Int =\n  match e\n";
+    let rows: Vec<(String, &[&str])> = vec![
+        // pinned sets
+        ("fun a(n: Int) -> !Int =\n  return error.Negative\n\nfun b(n: Int) -> error{Other}!Int =\n  try a(n)\n".into(), &["'Negative' is not in the pinned error set error{Other}"]),
+        ("fun c() -> error{A}!Int =\n  return error.B\n".into(), &["'B' is not in the pinned"]),
+        ("error Small = Aa\n\nfun a() -> error{Aa, Bb}!Int =\n  return error.Aa\n\nfun b() -> Small!Int =\n  try a()\n".into(), &["'Bb' is not in the pinned error set"]),
+        ("fun f() -> Nope!Int =\n  1\n".into(), &["unknown error set 'Nope'"]),
+        ("error Dup = Aa\nerror Dup = Bb\n\nfun f() -> Int =\n  1\n".into(), &["duplicate error set 'Dup'"]),
+        ("extern fun host(n: Int) -> !Int\n".into(), &["extern fn 'host' must pin its error set"]),
+        ("fun fact(n: Int) -> !Int =\n  if n < 0\n    return error.Negative\n  if n == 0\n    return 1\n  n * {try fact(n - 1)}\n".into(), &["fn 'fact' is recursive: pin its error set (-> error{..}!T)"]),
+        ("fun even(n: Int) -> !Bool =\n  if n == 0\n    return true\n  try odd(n - 1)\n\nfun odd(n: Int) -> !Bool =\n  if n == 0\n    return false\n  try even(n - 1)\n".into(), &["fn 'even' is recursive", "fn 'odd' is recursive"]),
+        // catch / try / !
+        ("fun f() -> !Int =\n  return error.A\n\nfun g() -> Int =\n  f() catch \"zero\"\n".into(), &["catch default", "mismatch"]),
+        ("fun g(n: Int) -> Int =\n  n catch 0\n".into(), &["'catch' requires an error union"]),
+        ("fun parse(s: Str) -> !Int =\n  return error.BadNum\n\nfun f(s: Str) -> !Int =\n  x := parse(s) catch error.InvalidFirst\n  x\n".into(), &["catch default", "Int"]),
+        ("fun f() -> !Int =\n  return error.A\n\nfun g() -> Int =\n  f()\n".into(), &["handle it with `try`, `!`, `catch` or `?:`"]),
+        (format!("{fneg}fun g(n: Int) -> Int =\n  f(n) catch e\n    match e\n      Negative => 0\n"), &["non-exhaustive", "TooBig"]),
+        (format!("{fneg}fun g(n: Int) -> Int =\n  x := f(n) catch e\n    y := 1\n  x\n"), &["catch block must end with a value"]),
+        (format!("{fneg}fun g(n: Int) -> Int =\n  f(n) catch e\n    match e\n      Negative => 0\n      TooBig => 9\n      Bogus => 1\n"), &["'Bogus' is not in the error set [Negative, TooBig]"]),
+        ("fun safe(n: Int) -> !Int =\n  n\n\nfun g(n: Int) -> Int =\n  safe(n) catch e\n    match e\n      Anything => 0\n      _ => 1\n".into(), &["'Anything' is not in the error set []"]),
+        ("fun f() -> !Int =\n  return error.NotFound\n\nfun g() -> Int =\n  f() catch e\n    e.name()\n".into(), &["mismatch"]),
+        ("fun g(n: Int) -> Int =\n  n!\n".into(), &["'!' requires an error union"]),
+        // error values and optionals
+        ("fun f() -> Int =\n  return error.X\n".into(), &["found error{X}"]),
+        ("fun f() -> Int =\n  return null\n".into(), &["type mismatch"]),
+        ("fun f() -> Int? =\n  return error.Other\n".into(), &["expected Int?, found error{Other}"]),
+        ("fun f() -> !Int =\n  fail Bad\n  1\n".into(), &["undefined name 'fail'"]),
+        ("fun f() -> !Int [A] =\n  return error.A\n".into(), &["pin an error set in front of the `!`"]),
+        // matching on a named error set
+        (format!("{two}    Aa => 1\n"), &["missing Bb"]),
+        (format!("{two}    error.Aa => 1\n    error.Zz => 2\n    _ => 3\n"), &["'Zz' is not in the error set"]),
+        // misc hints
+        ("fun f(a: Int) -> Int =\n  a\n\nfun main() =\n  x := f(\"a\" => 1)\n".into(), &["import std/Map"]),
+    ];
+    for (src, needles) in rows {
+        let msg = check(&src).expect_err(&format!("expected the checker to reject:\n{src}"));
+        for n in needles {
+            assert!(msg.contains(n), "{src}\nexpected {n:?} in: {msg}");
+        }
+    }
 }

plum-checker/tests/examples_test.rs DELETED Viewed

@@ -1,48 +0,0 @@
-#![allow(non_snake_case)]
-use plum_checker::checkSource;
-fn examplesDir() -> std::path::PathBuf {
-    std::path::Path::new(env!("CARGO_MANIFEST_DIR")).join("../plum-examples")
-}
-fn libPath() -> std::path::PathBuf {
-    std::path::Path::new(env!("CARGO_MANIFEST_DIR")).join("..")
-}
-fn exampleFiles() -> Vec<std::path::PathBuf> {
-    let mut files: Vec<_> = std::fs::read_dir(examplesDir())
-        .expect("plum-examples/ directory should exist")
-        .filter_map(|e| e.ok())
-        .map(|e| e.path())
-        .filter(|p| p.extension().and_then(|e| e.to_str()) == Some("plum"))
-        .collect();
-    files.sort();
-    assert!(
-        !files.is_empty(),
-        "plum-examples/ should contain at least one .plum file"
-    );
-    files
-}
-/// Every example must load (resolving its own `import`s against the repo root,
-/// the real compilation path — several examples now genuinely `import` real
-/// stdlib types like `std/Bool`/`std/Str`, so a bare single-file parse would
-/// leave those names undeclared) and pass `checkSource`. These files exist
-/// specifically to prove each piece of the currently-supported grammar
-/// surface actually works end to end, not just in isolated unit tests.
-#[test]
-fn everyExampleParsesAndTypeChecks() {
-    for path in exampleFiles() {
-        let source = plum_core::loadAndMerge(&path, &libPath())
-            .unwrap_or_else(|e| panic!("failed to load {}: {}", path.display(), e));
-        let result = checkSource(&source);
-        assert!(
-            result.is_ok(),
-            "{} failed type checking: {:?}",
-            path.display(),
-            result
-                .err()
-                .map(|errs| errs.into_iter().map(|e| e.message).collect::<Vec<_>>())
-        );
-    }
-}

plum-checker/tests/primitive_generics_test.rs CHANGED Viewed

@@ -22,17 +22,6 @@ fn primitiveGenericsAreNotPseudoVariants() {
     assert!(bad.is_empty(), "pseudo-entries in enum_variants: {bad:?}");
 }
-#[test]
-fn arrayIntMethodsStillTypeCheck() {
-    let source = load(
-        "b",
-        "import std/Array\nimport std/Int\n\nfun main() -> Int =\n  a := Array[Int]().push(3).push(4)\n  return a.get(1) + a.length()\n",
-    );
-    if let Err(errs) = checkSource(&source) {
-        panic!("{:?}", errs.iter().map(|e| e.message.clone()).collect::<Vec<_>>());
-    }
-}
 #[test]
 fn arrayElementTypeIsEnforced() {
     let source = load(

plum-checker/tests/unions_coerce_test.rs DELETED Viewed

@@ -1,120 +0,0 @@
-#![allow(non_snake_case)]
-use plum_checker::checkSource;
-use plum_core::unions::{beginPlan, resolveMembers, takePlan, UnionPlan};
-use plum_core::AstParser;
-const DEFS: &str = "\
-record Circle(r: Float)
-record Square(s: Float)
-record Oval(a: Float)
-enum Shape = Circle | Square
-enum Round = Circle | Oval
-enum Json = Float | Str
-enum Tree[T] = Node[T] | Leaf
-record Node[T](v: T)
-";
-fn run(body: &str) -> (Result<(), Vec<String>>, UnionPlan) {
-    let src = format!("{DEFS}\n{body}\n");
-    let mut parser = tree_sitter::Parser::new();
-    parser.set_language(&tree_sitter_plum::LANGUAGE.into()).unwrap();
-    let tree = parser.parse(&src, None).unwrap();
-    assert!(!tree.root_node().has_error(), "parse errors:\n{src}");
-    let mut source = AstParser::new(&src).parseSource(tree.root_node());
-    let errs = resolveMembers(&mut source);
-    assert!(errs.is_empty(), "{errs:?}");
-    beginPlan();
-    let r = checkSource(&source).map_err(|e| e.into_iter().map(|x| x.message).collect());
-    (r, takePlan())
-}
-fn wraps(p: &UnionPlan) -> Vec<String> {
-    let mut v: Vec<String> = p.wraps.values().cloned().collect();
-    v.sort();
-    v
-}
-#[test]
-fn literal_into_json() {
-    let (r, p) = run("fun f() -> Json =\n  3.0");
-    r.unwrap();
-    assert_eq!(wraps(&p), vec!["Json__Float"]);
-}
-#[test]
-fn wrap_at_arg_return_push() {
-    let (r, p) = run("fun take(s: Shape) -> Float =\n  1.0\n\nfun go() -> Float =\n  take(Circle(r: 1.0))");
-    r.unwrap();
-    assert_eq!(wraps(&p), vec!["Shape__Circle"]);
-    let (r, p) = run("fun mk() -> Shape =\n  Square(s: 2.0)");
-    r.unwrap();
-    assert_eq!(wraps(&p), vec!["Shape__Square"]);
-    let (r, p) = run("fun many(xs: ...Shape) -> Int =\n  1\n\nfun go() -> Int =\n  many(Circle(r: 1.0), Square(s: 1.0))");
-    r.unwrap();
-    assert_eq!(wraps(&p), vec!["Shape__Circle", "Shape__Square"]);
-}
-#[test]
-fn wrap_reassign_and_generic() {
-    let (r, p) = run("fun pick() -> Shape =\n  Circle(r: 1.0)\n\nfun go() -> Int =\n  s := pick()\n  s = Square(s: 1.0)\n  1");
-    r.unwrap();
-    assert_eq!(wraps(&p), vec!["Shape__Circle", "Shape__Square"]);
-    let (r, p) = run("fun mk() -> Tree[Int] =\n  Node(v: 3)");
-    r.unwrap();
-    assert_eq!(wraps(&p), vec!["Tree__Node"]);
-}
-#[test]
-fn join_if_branches() {
-    let (r, p) = run("fun go(c: Bool) -> Int =\n  x := if c then Circle(r: 1.0) else Square(s: 1.0)\n  1");
-    r.unwrap();
-    assert_eq!(wraps(&p), vec!["Shape__Circle", "Shape__Square"]);
-}
-#[test]
-fn join_ambiguous() {
-    let (r, _) = run("fun go(c: Bool) -> Int =\n  x := if c then Square(s: 1.0) else Oval(a: 1.0)\n  1");
-    assert!(r.unwrap_err().join("|").contains("cannot join Square and Oval: no single enum has both members"));
-}
-#[test]
-fn no_wrap_same_type() {
-    let (r, p) = run("fun take(c: Circle) -> Int =\n  1\n\nfun go() -> Int =\n  take(Circle(r: 1.0))");
-    r.unwrap();
-    assert!(p.wraps.is_empty());
-    let (r, p) = run("fun mk() -> Circle =\n  Circle(r: 1.0)");
-    r.unwrap();
-    assert!(p.wraps.is_empty());
-}
-#[test]
-fn member_alone_is_its_own_type() {
-    let (r, p) = run("fun mk() -> Circle =\n  Circle(r: 1.0)");
-    r.unwrap();
-    assert!(p.wraps.is_empty());
-    let (r, _) = run("fun mk() -> Shape =\n  Oval(a: 1.0)");
-    assert!(r.is_err());
-}
-#[test]
-fn invariant_list_rejected() {
-    let (r, _) = run("fun take(xs: List[Shape]) -> Int =\n  1\n\nfun go(cs: List[Circle]) -> Int =\n  take(cs)");
-    assert!(r.is_err(), "List[Circle] must not pass as List[Shape]");
-}
-#[test]
-fn nonmember_and_other_enum_rejected() {
-    let (r, _) = run("fun take(s: Shape) -> Int =\n  1\n\nfun go() -> Int =\n  take(Oval(a: 1.0))");
-    assert!(r.is_err());
-    let (r, _) = run("fun take(s: Shape) -> Int =\n  1\n\nfun go() -> Int =\n  take(Round(Oval(a: 1.0)))");
-    let _ = r;
-    let (r, _) = run("fun take(s: Shape) -> Int =\n  1\n\nfun go() -> Int =\n  take(\"x\")");
-    assert!(r.is_err());
-}
-#[test]
-fn method_arg_nested_single_wrap() {
-    let (r, p) = run("fun take(s: Shape) -> Shape =\n  s\n\nfun go() -> Shape =\n  take(take(Circle(r: 1.0)))");
-    r.unwrap();
-    assert_eq!(wraps(&p), vec!["Shape__Circle"]);
-}

plum-checker/tests/unions_dispatch_test.rs DELETED Viewed

@@ -1,150 +0,0 @@
-#![allow(non_snake_case)]
-use plum_checker::checkSource;
-use plum_core::unions::{beginPlan, resolveMembers, takePlan, UnionPlan};
-use plum_core::AstParser;
-const DEFS: &str = "\
-record Circle(r: Float) =
-  fun area(self) -> Float = self.r
-  fun toStr(self) -> Str = \"c\"
-record Rectangle(w: Float) =
-  fun area(self) -> Float = self.w
-  fun toStr(self) -> Str = \"r\"
-record Odd(w: Float) =
-  fun area(self) -> Int = 1
-record NoArea(w: Float)
-enum Shape = Circle | Rectangle
-enum Own =
-  | Circle
-  | Rectangle
-  fun area(self) -> Float = 0.0
-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\"
-enum Js = Circle | Wrap[Js]
-";
-fn run(body: &str) -> (Result<(), Vec<String>>, UnionPlan) {
-    let src = format!("{DEFS}\n{body}\n");
-    let mut parser = tree_sitter::Parser::new();
-    parser.set_language(&tree_sitter_plum::LANGUAGE.into()).unwrap();
-    let tree = parser.parse(&src, None).unwrap();
-    assert!(!tree.root_node().has_error(), "parse errors:\n{src}");
-    let mut source = AstParser::new(&src).parseSource(tree.root_node());
-    let errs = resolveMembers(&mut source);
-    assert!(errs.is_empty(), "{errs:?}");
-    beginPlan();
-    let r = checkSource(&source).map_err(|e| e.into_iter().map(|x| x.message).collect());
-    (r, takePlan())
-}
-fn errs(r: Result<(), Vec<String>>) -> String {
-    r.unwrap_err().join(" | ")
-}
-#[test]
-fn dispatch_ok() {
-    let (r, p) = run("fun f(s: Shape) -> Float =\n  s.area()");
-    r.unwrap();
-    assert_eq!(p.dispatches.len(), 1);
-    let v = p.dispatches.values().next().unwrap();
-    assert_eq!(v, &vec!["Shape__Circle".to_string(), "Shape__Rectangle".to_string()]);
-    let (r, _) = run("fun f(s: Shape) -> Int =\n  x := s.area()\n  take(x)\n\nfun take(i: Int) -> Int =\n  i");
-    assert!(r.is_err(), "area() is Float, not Int");
-}
-#[test]
-fn own_method_wins() {
-    let (r, p) = run("fun f(s: Own) -> Float =\n  s.area()");
-    r.unwrap();
-    assert!(p.dispatches.is_empty());
-}
-#[test]
-fn tag_member_error() {
-    let (r, _) = run("fun f(s: WithTag) -> Float =\n  s.area()");
-    assert!(errs(r).contains("WithTag has no method 'area': member Plain is a tag"));
-}
-#[test]
-fn missing_method_error() {
-    let (r, _) = run("fun f(s: Missing) -> Float =\n  s.area()");
-    assert!(errs(r).contains("Missing has no method 'area': member NoArea doesn't define it"));
-}
-#[test]
-fn signature_mismatch_error() {
-    let (r, _) = run("fun f(s: Clash) -> Float =\n  s.area()");
-    let e = errs(r);
-    assert!(e.contains("Clash.area: members disagree: Circle.area is "), "{e}");
-    assert!(e.contains(", Odd.area is "), "{e}");
-}
-#[test]
-fn interpolation_toStr() {
-    let (r, p) = run("fun f(s: Shape) -> Str =\n  \"{s}\"");
-    r.unwrap();
-    assert_eq!(p.dispatches.len(), 1);
-    let (r, p) = run("fun f(s: Missing) -> Str =\n  \"{s}\"");
-    let _ = r;
-    assert!(p.dispatches.is_empty());
-}
-#[test]
-fn generic_member_dispatch() {
-    let (r, p) = run("fun f(j: Js) -> Str =\n  j.toStr()");
-    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-checker/tests/unions_pattern_test.rs DELETED Viewed

@@ -1,138 +0,0 @@
-#![allow(non_snake_case)]
-use plum_checker::checkSource;
-use plum_core::unions::{beginPlan, resolveMembers, takePlan, UnionPlan};
-use plum_core::AstParser;
-const DEFS: &str = "\
-struct Circle(r: Float)
-struct Rectangle(w: Float, h: Float)
-record Pill(len: Float)
-enum Shape = Circle | Rectangle
-enum Cap = Pill | Circle
-enum Jv = JvNull | Float | Int
-";
-fn run(body: &str) -> (Result<(), Vec<String>>, UnionPlan) {
-    let src = format!("{DEFS}\n{body}\n");
-    let mut parser = tree_sitter::Parser::new();
-    parser.set_language(&tree_sitter_plum::LANGUAGE.into()).unwrap();
-    let tree = parser.parse(&src, None).unwrap();
-    assert!(!tree.root_node().has_error(), "parse errors:\n{src}");
-    let mut source = AstParser::new(&src).parseSource(tree.root_node());
-    let errs = resolveMembers(&mut source);
-    assert!(errs.is_empty(), "{errs:?}");
-    beginPlan();
-    let r = checkSource(&source).map_err(|e| e.into_iter().map(|x| x.message).collect());
-    (r, takePlan())
-}
-fn errs(r: Result<(), Vec<String>>) -> String {
-    r.unwrap_err().join(" | ")
-}
-#[test]
-fn destructure_member() {
-    let (r, p) = run("fun f(s: Shape) -> Float =\n  match s\n    Circle(r) => r\n    Rectangle(w, h) => w * h");
-    r.unwrap();
-    let mut v: Vec<_> = p.patterns.values().cloned().collect();
-    v.sort();
-    assert_eq!(v, vec!["Shape__Circle", "Shape__Rectangle"]);
-    assert!(p.narrowings.is_empty());
-    let (r, _) = run("fun take(i: Int) -> Int =\n  i\n\nfun f(s: Shape) -> Int =\n  match s\n    Circle(r) => take(r)\n    Rectangle(w, h) => 1");
-    assert!(r.is_err(), "r is a Float, not an Int");
-}
-#[test]
-fn narrow_match() {
-    let (r, p) = run("fun f(s: Shape) -> Float =\n  match s\n    Circle => s.r\n    Rectangle => s.w");
-    r.unwrap();
-    assert_eq!(p.narrowings.len(), 2);
-    let mut v: Vec<_> = p.narrowings.values().map(|x| x.1.clone()).collect();
-    v.sort();
-    assert_eq!(v, vec!["Shape__Circle", "Shape__Rectangle"]);
-    assert!(p.narrowings.values().all(|x| x.0 == "s"));
-    // after the match, s is a Shape again
-    let (r, _) = run("fun f(s: Shape) -> Float =\n  match s\n    Circle => 1.0\n    Rectangle => 2.0\n  s.r");
-    assert!(r.is_err());
-    // outside its arm s has no w
-    let (r, _) = run("fun f(s: Shape) -> Float =\n  match s\n    Circle => s.w\n    Rectangle => 2.0");
-    assert!(r.is_err());
-}
-#[test]
-fn narrow_struct_write_error() {
-    let (r, _) = run("fun f(s: Shape) -> Int =\n  match s\n    Circle =>\n      s.r = 1.0\n    Rectangle => 0\n  0");
-    assert!(
-        errs(r).contains("s is a copy of the Circle inside Shape; assign it to a local to change it")
-    );
-}
-#[test]
-fn narrow_record_write_ok() {
-    let (r, _) = run("fun f(s: Cap) -> Int =\n  match s\n    Pill =>\n      s.len = 1.0\n    Circle => 0\n  0");
-    r.unwrap();
-}
-#[test]
-fn exhaustive_members() {
-    let (r, _) = run("fun f(s: Shape) -> Float =\n  match s\n    Circle => 1.0\n    Rectangle => 2.0");
-    r.unwrap();
-    let (r, _) = run("fun f(s: Shape) -> Float =\n  match s\n    Circle => 1.0");
-    let e = errs(r);
-    assert!(e.contains("non-exhaustive match on Shape: missing Rectangle"), "{e}");
-    let (r, _) = run("fun f(s: Jv) -> Int =\n  match s\n    JvNull => 0\n    Float => 1\n    Int => 2");
-    r.unwrap();
-}
-#[test]
-fn expr_subject_no_narrow() {
-    let (r, p) = run("fun g() -> Shape =\n  Circle(r: 1.0)\n\nfun f() -> Int =\n  match g()\n    Circle => 1\n    Rectangle => 2");
-    r.unwrap();
-    assert!(p.narrowings.is_empty());
-    assert_eq!(p.patterns.len(), 2);
-}
-#[test]
-fn pattern_if() {
-    let (r, p) = run("fun f(s: Shape) -> Float =\n  if Circle := s\n    return s.r\n  0.0");
-    r.unwrap();
-    assert_eq!(p.narrowings.len(), 1);
-    let (r, _) = run("fun f(s: Shape) -> Float =\n  if Circle := s\n    return 1.0\n  s.r");
-    assert!(r.is_err());
-}
-#[test]
-fn primitive_member_narrows() {
-    let (r, p) = run("fun f(j: Jv) -> Float =\n  match j\n    Float => j + 1.0\n    Int => 0.0\n    JvNull => 0.0");
-    r.unwrap();
-    assert_eq!(p.narrowings.len(), 2);
-}
-const NEST: &str = "\
-enum IntOpt = Present | Absent
-record Present(v: Int)
-enum Nested = Wrap | Empty
-record Wrap(v: IntOpt)
-record Point(x: Int, y: Int)
-enum Geo = Located | Nowhere
-record Located(p: Point)
-";
-#[test]
-fn refutable_member_subpatterns_exhaustive() {
-    let (r, _) = run(&format!("{NEST}\nfun f(n: Nested) -> Int =\n  match n\n    Wrap(Present(v)) => v\n    Wrap(Absent) => -1\n    Empty => 0"));
-    r.unwrap();
-    let (r, _) = run(&format!("{NEST}\nfun f(g: Geo) -> Int =\n  match g\n    Located(Point(x, y)) => x + y\n    Nowhere => 0"));
-    r.unwrap();
-}
-#[test]
-fn refutable_member_subpatterns_missing_case() {
-    let (r, _) = run(&format!("{NEST}\nfun f(n: Nested) -> Int =\n  match n\n    Wrap(Present(v)) => v\n    Empty => 0"));
-    let e = errs(r);
-    assert!(e.contains("non-exhaustive match") && e.contains("Absent"), "{e}");
-    assert!(!e.contains("__"), "{e}");
-    let (r, _) = run(&format!("{NEST}\nfun f(n: Nested) -> Int =\n  match n\n    Wrap(Present(v)) => v\n    Wrap(Absent) => -1"));
-    let e = errs(r);
-    assert!(e.contains("missing Empty") && !e.contains("__"), "{e}");
-}

plum-checker/tests/unions_tests.rs ADDED Viewed

@@ -0,0 +1,330 @@
+#![allow(non_snake_case)]
+//! Union plans recorded by the checker (wraps, narrowings, pattern members, dispatches)
+//! plus the rejected programs of the union features: member coercion, narrowing by
+//! `match` / pattern-if, member-method dispatch and annotated declarations.
+//! Valid-program behavior at runtime is covered by the Plum tests.
+use plum_checker::checkSource;
+use plum_core::unions::{beginPlan, resolveMembers, takePlan, UnionPlan};
+use plum_core::AstParser;
+const COERCE: &str = "\
+record Circle(r: Float)
+record Square(s: Float)
+record Oval(a: Float)
+enum Shape = Circle | Square
+enum Round = Circle | Oval
+enum Json = Float | Str
+enum Tree[T] = Node[T] | Leaf
+record Node[T](v: T)
+";
+const PATTERN: &str = "\
+struct Circle(r: Float)
+struct Rectangle(w: Float, h: Float)
+record Pill(len: Float)
+enum Shape = Circle | Rectangle
+enum Cap = Pill | Circle
+enum Jv = JvNull | Float | Int
+";
+const NEST: &str = "\
+enum IntOpt = Present | Absent
+record Present(v: Int)
+enum Nested = Wrap | Empty
+record Wrap(v: IntOpt)
+";
+const DISPATCH: &str = "\
+record Circle(r: Float) =
+  fun area(self) -> Float = self.r
+  fun toStr(self) -> Str = \"c\"
+record Rectangle(w: Float) =
+  fun area(self) -> Float = self.w
+  fun toStr(self) -> Str = \"r\"
+record Odd(w: Float) =
+  fun area(self) -> Int = 1
+record NoArea(w: Float)
+enum Shape = Circle | Rectangle
+enum Own =
+  | Circle
+  | Rectangle
+  fun area(self) -> Float = 0.0
+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\"
+enum Js = Circle | Wrap[Js]
+";
+fn run(defs: &str, body: &str) -> (Result<(), Vec<String>>, UnionPlan) {
+    let src = format!("{defs}\n{body}\n");
+    let mut parser = tree_sitter::Parser::new();
+    parser.set_language(&tree_sitter_plum::LANGUAGE.into()).unwrap();
+    let tree = parser.parse(&src, None).unwrap();
+    assert!(!tree.root_node().has_error(), "parse errors:\n{src}");
+    let mut source = AstParser::new(&src).parseSource(tree.root_node());
+    let errs = resolveMembers(&mut source);
+    assert!(errs.is_empty(), "{errs:?}");
+    beginPlan();
+    let r = checkSource(&source).map_err(|e| e.into_iter().map(|x| x.message).collect());
+    (r, takePlan())
+}
+fn wraps(p: &UnionPlan) -> Vec<String> {
+    let mut v: Vec<String> = p.wraps.values().cloned().collect();
+    v.sort();
+    v
+}
+/// Each row (defs, body, needles) must be rejected, with every needle in the messages.
+fn assertRejected(rows: &[(&str, &str, &[&str])]) {
+    for (defs, body, needles) in rows {
+        let (r, _) = run(defs, body);
+        let msg = r.expect_err(&format!("expected the checker to reject:\n{body}")).join(" | ");
+        for n in *needles {
+            assert!(msg.contains(*n), "{body}\nexpected {n:?} in: {msg}");
+        }
+    }
+}
+// ---- member coercion: where the checker records a wrap ----
+#[test]
+fn literal_into_json() {
+    let (r, p) = run(COERCE, "fun f() -> Json =\n  3.0");
+    r.unwrap();
+    assert_eq!(wraps(&p), vec!["Json__Float"]);
+}
+#[test]
+fn wrap_at_arg_return_push() {
+    let (r, p) = run(COERCE, "fun take(s: Shape) -> Float =\n  1.0\n\nfun go() -> Float =\n  take(Circle(r: 1.0))");
+    r.unwrap();
+    assert_eq!(wraps(&p), vec!["Shape__Circle"]);
+    let (r, p) = run(COERCE, "fun mk() -> Shape =\n  Square(s: 2.0)");
+    r.unwrap();
+    assert_eq!(wraps(&p), vec!["Shape__Square"]);
+    let (r, p) = run(COERCE, "fun many(xs: ...Shape) -> Int =\n  1\n\nfun go() -> Int =\n  many(Circle(r: 1.0), Square(s: 1.0))");
+    r.unwrap();
+    assert_eq!(wraps(&p), vec!["Shape__Circle", "Shape__Square"]);
+}
+#[test]
+fn wrap_reassign_and_generic() {
+    let (r, p) = run(COERCE, "fun pick() -> Shape =\n  Circle(r: 1.0)\n\nfun go() -> Int =\n  s := pick()\n  s = Square(s: 1.0)\n  1");
+    r.unwrap();
+    assert_eq!(wraps(&p), vec!["Shape__Circle", "Shape__Square"]);
+    let (r, p) = run(COERCE, "fun mk() -> Tree[Int] =\n  Node(v: 3)");
+    r.unwrap();
+    assert_eq!(wraps(&p), vec!["Tree__Node"]);
+}
+#[test]
+fn join_if_branches() {
+    let (r, p) = run(COERCE, "fun go(c: Bool) -> Int =\n  x := if c then Circle(r: 1.0) else Square(s: 1.0)\n  1");
+    r.unwrap();
+    assert_eq!(wraps(&p), vec!["Shape__Circle", "Shape__Square"]);
+}
+#[test]
+fn no_wrap_when_the_type_already_matches() {
+    let (r, p) = run(COERCE, "fun take(c: Circle) -> Int =\n  1\n\nfun go() -> Int =\n  take(Circle(r: 1.0))");
+    r.unwrap();
+    assert!(p.wraps.is_empty());
+    let (r, p) = run(COERCE, "fun mk() -> Circle =\n  Circle(r: 1.0)");
+    r.unwrap();
+    assert!(p.wraps.is_empty());
+    // a nested call wraps once, not twice
+    let (r, p) = run(COERCE, "fun take(s: Shape) -> Shape =\n  s\n\nfun go() -> Shape =\n  take(take(Circle(r: 1.0)))");
+    r.unwrap();
+    assert_eq!(wraps(&p), vec!["Shape__Circle"]);
+}
+// ---- annotated declarations ----
+#[test]
+fn annotated_local_has_the_annotation_type() {
+    // `s` is a `Shape`, so passing it where a `Shape` is expected needs no second wrap.
+    let (r, p) = run(COERCE, "fun take(s: Shape) -> Int =\n  1\n\nfun go() -> Int =\n  s: Shape := Circle(r: 2.0)\n  take(s)");
+    r.unwrap();
+    assert_eq!(wraps(&p), vec!["Shape__Circle"]);
+    let (r, p) = run(COERCE, "fun go() -> Int =\n  s: Shape := Circle(r: 2.0)\n  s = Square(s: 1.0)\n  1");
+    r.unwrap();
+    assert_eq!(wraps(&p), vec!["Shape__Circle", "Shape__Square"]);
+}
+// ---- narrowing and patterns ----
+#[test]
+fn destructure_member() {
+    let (r, p) = run(PATTERN, "fun f(s: Shape) -> Float =\n  match s\n    Circle(r) => r\n    Rectangle(w, h) => w * h");
+    r.unwrap();
+    let mut v: Vec<_> = p.patterns.values().cloned().collect();
+    v.sort();
+    assert_eq!(v, vec!["Shape__Circle", "Shape__Rectangle"]);
+    assert!(p.narrowings.is_empty());
+}
+#[test]
+fn narrow_match() {
+    let (r, p) = run(PATTERN, "fun f(s: Shape) -> Float =\n  match s\n    Circle => s.r\n    Rectangle => s.w");
+    r.unwrap();
+    assert_eq!(p.narrowings.len(), 2);
+    let mut v: Vec<_> = p.narrowings.values().map(|x| x.1.clone()).collect();
+    v.sort();
+    assert_eq!(v, vec!["Shape__Circle", "Shape__Rectangle"]);
+    assert!(p.narrowings.values().all(|x| x.0 == "s"));
+}
+#[test]
+fn expr_subject_no_narrow() {
+    let (r, p) = run(PATTERN, "fun g() -> Shape =\n  Circle(r: 1.0)\n\nfun f() -> Int =\n  match g()\n    Circle => 1\n    Rectangle => 2");
+    r.unwrap();
+    assert!(p.narrowings.is_empty());
+    assert_eq!(p.patterns.len(), 2);
+}
+#[test]
+fn pattern_if_and_primitive_members_narrow() {
+    let (r, p) = run(PATTERN, "fun f(s: Shape) -> Float =\n  if Circle := s\n    return s.r\n  0.0");
+    r.unwrap();
+    assert_eq!(p.narrowings.len(), 1);
+    let (r, p) = run(PATTERN, "fun f(j: Jv) -> Float =\n  match j\n    Float => j + 1.0\n    Int => 0.0\n    JvNull => 0.0");
+    r.unwrap();
+    assert_eq!(p.narrowings.len(), 2);
+}
+#[test]
+fn narrowed_record_member_can_be_written_but_a_struct_copy_cannot() {
+    let (r, _) = run(PATTERN, "fun f(s: Cap) -> Int =\n  match s\n    Pill =>\n      s.len = 1.0\n    Circle => 0\n  0");
+    r.unwrap();
+    let (r, _) = run(PATTERN, "fun f(s: Shape) -> Int =\n  match s\n    Circle =>\n      s.r = 1.0\n    Rectangle => 0\n  0");
+    assert!(r
+        .unwrap_err()
+        .join("|")
+        .contains("s is a copy of the Circle inside Shape; assign it to a local to change it"));
+}
+// ---- member-method dispatch ----
+#[test]
+fn dispatch_over_members() {
+    let (r, p) = run(DISPATCH, "fun f(s: Shape) -> Float =\n  s.area()");
+    r.unwrap();
+    assert_eq!(p.dispatches.len(), 1);
+    let v = p.dispatches.values().next().unwrap();
+    assert_eq!(v, &vec!["Shape__Circle".to_string(), "Shape__Rectangle".to_string()]);
+    let (r, p) = run(DISPATCH, "fun f(j: Js) -> Str =\n  j.toStr()");
+    r.unwrap();
+    assert_eq!(p.dispatches.values().next().unwrap().len(), 2);
+    let (r, p) = run(DISPATCH, "fun f(s: Shape) -> Str =\n  \"{s}\"");
+    r.unwrap();
+    assert_eq!(p.dispatches.len(), 1);
+}
+#[test]
+fn own_method_wins_over_member_dispatch() {
+    let (r, p) = run(DISPATCH, "fun f(s: Own) -> Float =\n  s.area()");
+    r.unwrap();
+    assert!(p.dispatches.is_empty());
+    let (r, p) = run(DISPATCH, "fun f() -> Float =\n  Circle(r: 1.5).area()");
+    r.unwrap();
+    assert!(p.wraps.is_empty() && p.dispatches.is_empty());
+}
+#[test]
+fn member_falls_back_to_its_enum() {
+    let (r, p) = run(DISPATCH, "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 no_dispatch_recorded_when_a_member_lacks_toStr() {
+    let (_, p) = run(DISPATCH, "fun f(s: Missing) -> Str =\n  \"{s}\"");
+    assert!(p.dispatches.is_empty());
+}
+// ---- rejected programs ----
+#[test]
+fn rejects_bad_member_coercions() {
+    assertRejected(&[
+        (COERCE, "fun go(c: Bool) -> Int =\n  x := if c then Square(s: 1.0) else Oval(a: 1.0)\n  1", &["cannot join Square and Oval: no single enum has both members"]),
+        (COERCE, "fun mk() -> Shape =\n  Oval(a: 1.0)", &["expected Shape, found Oval"]),
+        (COERCE, "fun take(s: Shape) -> Int =\n  1\n\nfun go() -> Int =\n  take(Oval(a: 1.0))", &["expected Shape, found Oval"]),
+        (COERCE, "fun take(s: Shape) -> Int =\n  1\n\nfun go() -> Int =\n  take(\"x\")", &["expected Shape, found Str"]),
+        (COERCE, "fun take(xs: List[Shape]) -> Int =\n  1\n\nfun go(cs: List[Circle]) -> Int =\n  take(cs)", &["expected List[Shape], found List[Circle]"]),
+        // annotated declarations
+        (COERCE, "fun go() -> Int =\n  s: Int := \"x\"\n  1", &["assign 's'", "mismatch"]),
+        (COERCE, "fun go() -> Int =\n  s: Shape = Circle(r: 1.0)\n  1", &["annotated declarations use :="]),
+        (COERCE, "fun go() -> Int =\n  total: Float\n  1", &["needs a value"]),
+        (COERCE, "fun go() -> Int =\n  s := 1\n  s: Int := 2\n  s", &["already declared"]),
+        // an Int does not convert to a Float, as a param or as an annotated declaration
+        (COERCE, "fun take(x: Float) -> Float =\n  x\n\nfun go() -> Float =\n  take(3)", &["expected Float, found Int"]),
+        (COERCE, "fun go() -> Float =\n  n: Float := 3\n  n", &["expected Float, found Int"]),
+    ]);
+}
+#[test]
+fn rejects_bad_narrowing_and_non_exhaustive_member_matches() {
+    assertRejected(&[
+        (PATTERN, "fun take(i: Int) -> Int =\n  i\n\nfun f(s: Shape) -> Int =\n  match s\n    Circle(r) => take(r)\n    Rectangle(w, h) => 1", &["expected Int, found Float"]),
+        // after the match, and outside its arm, `s` is the whole Shape again
+        (PATTERN, "fun f(s: Shape) -> Float =\n  match s\n    Circle => 1.0\n    Rectangle => 2.0\n  s.r", &["no field 'r' on type 'Shape'"]),
+        (PATTERN, "fun f(s: Shape) -> Float =\n  match s\n    Circle => s.w\n    Rectangle => 2.0", &["no field 'w' on type 'Circle'"]),
+        (PATTERN, "fun f(s: Shape) -> Float =\n  if Circle := s\n    return 1.0\n  s.r", &["no field 'r' on type 'Shape'"]),
+        (PATTERN, "fun f(s: Shape) -> Float =\n  match s\n    Circle => 1.0", &["non-exhaustive match on Shape: missing Rectangle"]),
+    ]);
+    for (body, needles) in [
+        ("fun f(n: Nested) -> Int =\n  match n\n    Wrap(Present(v)) => v\n    Empty => 0", &["non-exhaustive match", "Absent"][..]),
+        ("fun f(n: Nested) -> Int =\n  match n\n    Wrap(Present(v)) => v\n    Wrap(Absent) => -1", &["missing Empty"][..]),
+    ] {
+        let (r, _) = run(NEST, body);
+        let msg = r.unwrap_err().join(" | ");
+        for n in needles {
+            assert!(msg.contains(n), "{body}\nexpected {n:?} in: {msg}");
+        }
+        assert!(!msg.contains("__"), "internal member names must not leak: {msg}");
+    }
+}
+#[test]
+fn rejects_bad_member_dispatch() {
+    assertRejected(&[
+        (DISPATCH, "fun f(s: WithTag) -> Float =\n  s.area()", &["WithTag has no method 'area': member Plain is a tag"]),
+        (DISPATCH, "fun f(s: Missing) -> Float =\n  s.area()", &["Missing has no method 'area': member NoArea doesn't define it"]),
+        (DISPATCH, "fun f(s: Clash) -> Float =\n  s.area()", &["Clash.area: members disagree: Circle.area is ", ", Odd.area is "]),
+        (DISPATCH, "fun f(s: Shape) -> Int =\n  x := s.area()\n  take(x)\n\nfun take(i: Int) -> Int =\n  i", &["expected Int, found Float"]),
+        (DISPATCH, "fun f() -> Float =\n  Bare(x: 1.0).area()", &["Bare has no method 'area' (it is a member of Boxed and Round, which both define it — convert first)"]),
+    ]);
+}