3910d54 | plum | pyrossh

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

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

3910d54 — Peter John 2026-11-01T23:19:05+05:30

test: restore coverage for 8 behaviors found uncovered after dedupe

Files changed (6) hide show

plum-checker/tests/checker_tests.rs +9 -0
plum-examples/constants.plum +15 -0
plum-examples/error_propagation.plum +38 -0
plum-examples/functions.plum +10 -0
plum-examples/match.plum +20 -0
plum-examples/structs_records.plum +14 -0

plum-checker/tests/checker_tests.rs CHANGED Viewed

@@ -600,3 +600,12 @@ fn rejects_bad_optionals_and_error_unions() {
         r("fun g() -> error{Neg}!Int =\n  \"x\"\n", &["expected error{Neg}!Int, found Str"]),
     ]);
 }
+// A bare generic name as a return annotation inside the type's own methods means the same
+// instantiation. (Codegen does not support it yet: `-> Box` fails with a GC registry error.)
+#[test]
+fn bare_generic_type_allowed_inside_its_own_methods() {
+    let src = "record Box[T](value: T) =\n\n  fun same(self) -> Box =\n    self\n";
+    let r = checkSource(&parseClean(src));
+    assert!(r.is_ok(), "got {:?}", r.err());
+}

plum-examples/constants.plum CHANGED Viewed

@@ -2,6 +2,7 @@ module constants
 import std/Int
 import std/Float
 import std/Str
+import std/List
 # Constants and static functions live inside a type's body or a `primitive`
 # namespace — there are no top-level constants. `NAME = expr` declares an
@@ -39,6 +40,16 @@ struct Vec2(x: Float, y: Float) =
 fun scaled(n: Float) -> Float = n * Grid.CELL_SCALE
+primitive Shelf =
+  SIDES = 4
+  NAMES = List("a", "b", "c")
+  fun sidesTwice() -> Int =
+    twice(SIDES)
+  fun twice(n: Int) -> Int =
+    n * 2
 test "consts are usable in fns, methods, generics and derived consts"
   assert Grid.H == 16
   assert Grid.cells() == 128
@@ -55,3 +66,7 @@ test "the same const name can live on two types"
 test "a struct can hold a constant instance of itself"
   assert Vec2.ZERO.x == 0.0
   assert Tile.origin().x == 0
+test "a primitive holds a list constant and a static fn reading a sibling const"
+  assert Shelf.NAMES.length() == 3
+  assert Shelf.sidesTwice() == 8

plum-examples/error_propagation.plum CHANGED Viewed

@@ -2,6 +2,7 @@ import std/Int
 import std/Float
 import std/Str
 import std/List
+import std/Map
 # `!T` is "a `T` or an error". An error is a value written `error.Name` (for
 # example `return error.NegativeNum`): it needs no declaration and carries no
@@ -120,6 +121,26 @@ fun errorText(s: Str) -> Str =
     return e.name()
   "none"
+fun checkNonNeg(n: Int) -> error{Neg}!Unit =
+  if n < 0
+    return error.Neg
+fun passCheck(n: Int) -> error{Neg}!Unit =
+  try checkNonNeg(n)
+fun runChecked(n: Int) -> error{Neg}!Int =
+  try checkNonNeg(n)
+  n
+fun negOrSeven(n: Int) -> error{Neg}!Int =
+  if n < 0
+    return error.Neg
+  n
+fun lookup(m: Map[Int, error{Neg}!Int]) -> Int =
+  v := m.get(1) catch negOrSeven(-1)
+  v catch 0
 test "try operator unwraps the value and propagates it through two calls"
   assert sumTwo("2", "3")! == 5
@@ -189,3 +210,20 @@ test "a list of error unions nests one level per access"
   assert {second catch 0} == 0
   fallback := {results.get(9) catch parsePositive("5")}
   assert {fallback catch 0} == 5
+test "a Unit error union propagates with try and is handled with catch"
+  assert {runChecked(4) catch 0} == 4
+  assert {runChecked(-1) catch 5} == 5
+  hits := 0
+  passCheck(1) catch e
+    hits = hits + 1
+  passCheck(-1) catch e
+    hits = hits + 10
+  assert hits == 10
+test "a Map can hold error unions as values"
+  m := Map[Int, error{Neg}!Int]()
+  m.set(1, negOrSeven(7))
+  assert lookup(m) == 7
+  m.set(1, negOrSeven(-2))
+  assert lookup(m) == 0

plum-examples/functions.plum CHANGED Viewed

@@ -48,6 +48,12 @@ fun double(n: Int) -> Int =
 fun combineVariadic(prefix: Int, rest: ...Int) -> Int =
   prefix
+fun weighted(nums: ...Int) -> Int =
+  total := 0
+  for i, v := range nums
+    total = total + i * v
+  total
 test "factorial runs correctly"
   assert factorial(5) == 120
@@ -65,3 +71,7 @@ test "sum all variadic int runs correctly"
 test "sum all variadic int with zero args runs correctly"
   assert sumAll() == 0
+test "for over a variadic binds index and element"
+  assert weighted() == 0
+  assert weighted(5, 10, 20) == 50

plum-examples/match.plum CHANGED Viewed

@@ -264,6 +264,20 @@ fun bookInfo(book: Book) -> Str =
         Good(name1), Good(name2) => "Non-fiction book \"{title}\" praised by {name1} and {name2}"
         _, _ => "Non-fiction book \"{title}\" has mixed reviews"
+record Full(n: Int)
+enum Slot =
+  | Full
+  | Vacant
+fun isVacant(s: Slot) -> Bool =
+  s == Vacant
+fun slotKind(s: Slot) -> Str =
+  match s
+    Vacant => "vacant"
+    other => "full"
 test "nested constructor pattern matches and binds runs correctly"
   assert unwrapNested(Wrap(Present(5))) == 5
@@ -402,3 +416,9 @@ test "nested constructor patterns and a nested multi-subject match"
   mixed := NonFictionBook(title: "Shaky Claims", pages: 80, rating1: Good(name: "Alice"), rating2: Bad(name: "Carol"))
   assert bookInfo(good) == "Non-fiction book \"Hidden Facts\" praised by Alice and Bob"
   assert bookInfo(mixed) == "Non-fiction book \"Shaky Claims\" has mixed reviews"
+test "a bare tag equals a member-enum value and a binding arm catches the rest"
+  assert isVacant(Vacant)
+  assert !isVacant(Full(n: 3))
+  assert slotKind(Vacant) == "vacant"
+  assert slotKind(Full(n: 1)) == "full"

plum-examples/structs_records.plum CHANGED Viewed

@@ -111,6 +111,8 @@ fun methodsTotal() -> Int =
   w := Wrapper(inner: c, tag: 1)
   c.getAge() + c.birthday() + w.innerAge()
+record Slab(bounds: Rect, id: Int)
 test "struct assignment copies"
   a := Vec2(x: 1.0, y: 2.0)
   b := a
@@ -239,3 +241,15 @@ test "records built in a loop do not alias"
   # compile-time-fixed address; otherwise every iteration's `LoopBox(...)`
   # would alias the same memory and this would sum to 20 instead of 10.
   assert sumLoopBoxes() == 10
+test "struct sub-fields assign in place through a record field"
+  p := Player(pos: Vec2(x: 1.0, y: 2.0), hp: 5)
+  p.pos.x = 8.0
+  assert p.pos.x == 8.0
+  assert p.pos.y == 2.0
+  assert p.hp == 5
+  s := Slab(bounds: Rect(pos: Vec2(x: 1.0, y: 2.0), size: Vec2(x: 3.0, y: 4.0)), id: 1)
+  s.bounds.size.y = 6.0
+  assert s.bounds.size.y == 6.0
+  assert s.bounds.size.x == 3.0
+  assert s.bounds.pos.y == 2.0