e91520f | plum | pyrossh

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

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

e91520f — Peter John 2026-11-01T23:09:45+05:30

test: dedupe codegen Rust tests (152 -> 82); drop unused greetForInterpolationTest

Files changed (4) hide show

plum-std/Str.plum +0 -3
plum-wasm-codegen/tests/codegen_tests.rs +2 -920
plum-wasm-codegen/tests/examples_test.rs +6 -91
plum-wasm-codegen/tests/unions_e2e_test.rs +0 -79

plum-std/Str.plum CHANGED Viewed

@@ -635,9 +635,6 @@ fun deburrLatinExtA() -> Str =
 # `"{expr}"` interpolation is a compiler/codegen feature (not a Str method
 # above), but Str is what it produces, so its regression coverage lives here.
-fun greetForInterpolationTest(name: Str) -> Str =
-  "Hello, {name}!"
 fun bigAscii(n: Int, b: Int) -> Str =
   buf := Buffer()
   i := 0

plum-wasm-codegen/tests/codegen_tests.rs CHANGED Viewed

@@ -26,16 +26,6 @@ fn gcEngine() -> wasmtime::Engine {
     wasmtime::Engine::new(&config).expect("engine with GC config should construct")
 }
-#[test]
-fn compilesToValidWasm() {
-    let src = "fun add(a: Int, b: Int) -> Int =\n  a + b\n";
-    let source = parse(src);
-    let bytes = compileSource(&source).expect("compile failed");
-    // Valid WASM starts with the magic number
-    assert_eq!(&bytes[0..4], b"\0asm");
-    assert_eq!(&bytes[4..8], &[1, 0, 0, 0]); // version 1
-}
 #[test]
 fn outputValidates() {
     let src = "fun add(a: Int, b: Int) -> Int =\n  a + b\n";
@@ -46,31 +36,6 @@ fn outputValidates() {
     assert!(result.is_ok(), "wasm validation failed: {:?}", result.err());
 }
-#[test]
-fn factorialCompiles() {
-    let src = "\
-fun factorial(x: Int) -> Int =
-  if x < 2
-    return 1
-  return x * factorial(x - 1)
-";
-    let source = parse(src);
-    let bytes = compileSource(&source).expect("factorial should compile");
-    assert_eq!(&bytes[0..4], b"\0asm");
-    let result = wasmparser::validate(&bytes);
-    assert!(result.is_ok(), "wasm validation failed: {:?}", result.err());
-}
-#[test]
-fn give42CompilesAndExports() {
-    let src = "fun give42() -> Int =\n  42\n";
-    let source = parse(src);
-    let bytes = compileSource(&source).expect("compile failed");
-    assert_eq!(&bytes[0..4], b"\0asm");
-    let result = wasmparser::validate(&bytes);
-    assert!(result.is_ok(), "wasm validation failed: {:?}", result.err());
-}
 /// Reads a `Str` (wasm-gc `array<i8>`) result value's bytes into a Rust
 /// `String` — a test-only counterpart to `plum-cli`'s own `readStrResult`,
 /// since each `test#<name>` export now returns a `Str` report (empty = every
@@ -271,23 +236,6 @@ fn assertValid(src: &str) -> Vec<u8> {
     bytes
 }
-#[test]
-fn boolLiteralsCompile() {
-    let boolDecl = "";
-    assertValid(&format!("{}fun main() -> Bool =\n  true\n", boolDecl));
-    assertValid(&format!("{}fun main() -> Bool =\n  false\n", boolDecl));
-}
-#[test]
-fn stringLiteralCompiles() {
-    assertValid("fun main() -> Str =\n  \"hello\"\n");
-}
-#[test]
-fn emptyStringLiteralCompiles() {
-    assertValid("fun main() -> Str =\n  \"\"\n");
-}
 #[test]
 fn stringInterpolationOfAFloatIsAClearError() {
     // Float-to-decimal-string formatting is a substantial separate undertaking
@@ -299,65 +247,6 @@ fn stringInterpolationOfAFloatIsAClearError() {
     assert!(err.contains("Float"), "got: {}", err);
 }
-#[test]
-fn floatArithmeticAndNegationCompile() {
-    assertValid("fun main(x: Float) -> Float =\n  y = -x\n  y + 1.5\n");
-}
-#[test]
-fn classFieldAndMethodCompile() {
-    let src = "\
-record Cat(name: Str, age: Int) =
-  fun getAge() -> Int =
-    self.age
-fun makeCat() -> Int =
-  c = Cat(name: \"x\", age: 3)
-  c.getAge()
-";
-    assertValid(src);
-}
-#[test]
-fn nestedClassCallCompiles() {
-    let src = "\
-record Pair(a: Int, b: Int)
-record Wrapper(inner: Pair, tag: Int)
-fun make() -> Int =
-  w = Wrapper(inner: Pair(a: 1, b: 2), tag: 9)
-  w.tag
-";
-    assertValid(src);
-}
-#[test]
-fn matchWithIntAndWildcardCompiles() {
-    let src = "fun main(a: Int) -> Int =\n  match a\n    1 =>\n      return 10\n    _ =>\n      return 0\n";
-    assertValid(src);
-}
-#[test]
-fn matchBindingPatternCompiles() {
-    let src = "fun main(a: Int) -> Int =\n  match a\n    x =>\n      return x\n";
-    assertValid(src);
-}
-#[test]
-fn matchInlineCaseBodyCompiles() {
-    // Case bodies can be a single inline expression, not just an indented block.
-    let src = "fun main(a: Int) =\n  match a\n    1 => 10\n    _ => 0\n";
-    assertValid(src);
-}
-#[test]
-fn matchBoolVariantPatternCompiles() {
-    let src = "fun main(a: Bool) -> Int =\n  match a\n    true =>\n      return 1\n    false =>\n      return 0\n";
-    assertValid(src);
-}
 #[test]
 fn matchStringPatternIsAClearError() {
     let src = "fun main(a: Str) -> Int =\n  match a\n    \"x\" =>\n      1\n    _ =>\n      0\n";
@@ -429,18 +318,6 @@ fun main() -> Int =
     );
 }
-#[test]
-fn payloadFreeVariantConstructionCompiles() {
-    let src = "\
-enum Color =
-  | Red
-  | Green
-  | Blue
-fun main() -> Int =\n  x = Green\n  0\n";
-    assertValid(src);
-}
 #[test]
 fn tailIfWithoutElseIsAClearError() {
     let src = "\
@@ -1182,84 +1059,8 @@ fn runMerged<R: wasmtime::WasmResults>(name: &str, src: &str) -> R {
     r
 }
-#[test]
-fn heterogeneous_list_dispatch() {
-    let src = "\
-import std/Str
-import std/Int
-import std/Float
-import std/List
-enum Shape =
-  | Circle
-  | Square
-  fun area(self) -> Float =
-    match self
-      Circle(r) => r * r * 3.0
-      Square(s) => s * s
-record Circle(r: Float)
-record Square(s: Float)
-fun total(xs: List[Shape]) -> Float =
-  sum := 0.0
-  for x := range xs
-    sum = sum + x.area()
-  sum
-fun main() -> Float =
-  xs := List[Shape]()
-  xs.add(Circle(r: 1.5))
-  xs.add(Square(s: 1.5))
-  xs.add(Circle(r: 0.5))
-  total(xs)
-";
-    // 6.75 + 2.25 + 0.75, exact in binary floating point.
-    assert_eq!(runMerged::<f64>("hetero", src), 9.75);
-}
 // ---- erased generics (T4) ----
-#[test]
-fn boxed_i64_extremes_through_generic() {
-    let src = "\
-import std/Str
-import std/Int
-import std/Float
-fun identity(x: T) -> T =
-  x
-fun main() -> Int =
-  lo := 0 - 9223372036854775807 - 1
-  big := 9007199254740993
-  nz := identity(-0.0)
-  ok := identity(lo) == lo && identity(big) == big && identity(big + 0) - big == 0
-  neg := 1.0 / nz < 0.0
-  if ok && neg && identity(0 - 5) == 0 - 5
-    return 1
-  return 0
-";
-    assert_eq!(runMerged::<i64>("extremes", src), 1);
-}
-#[test]
-fn generic_closure_thunk() {
-    let src = "\
-import std/Str
-import std/Int
-import std/Float
-import std/List
-fun main() -> Int =
-  xs := mapList(List(1, 2, 3), |n| n * 2)
-  reduceList(xs, 0, |acc, x| acc + x)
-";
-    let src = format!("{src}\n{LIST_FNS}");
-    assert_eq!(runMerged::<i64>("thunk", &src), 12);
-}
 /// Compiles `src` (merged with the real std) and returns every compiled function key/name.
 fn compiledKeys(name: &str, src: &str) -> (Vec<u8>, Vec<String>) {
@@ -1488,31 +1289,6 @@ fun main() -> Int =
 // ---- built-in Bool (i32; no `import std/Bool`) ----
-#[test]
-fn builtin_bool_without_import() {
-    let src = "\
-import std/Str
-import std/Int
-import std/Float
-fun flip(b: Bool) -> Bool =
-  !b
-fun name(b: Bool) -> Str =
-  match b
-    true => \"yes\"
-    false => \"no\"
-fun main() -> Int =
-  x := true
-  if flip(false) && x == true && !false || false
-    if name(x) == \"yes\" && name(false) == \"no\" && \"{x}\" == \"true\"
-      return 1
-  return 0
-";
-    assert_eq!(runMerged::<i64>("bool_noimport", src), 1);
-}
 #[test]
 fn builtin_bool_list_round_trip() {
     let src = "\
@@ -1638,57 +1414,6 @@ fn extern_int_overflow_traps() {
     assert!(externEcho("0 - 2147483649").1.is_err(), "Int < i32::MIN must trap");
 }
-#[test]
-fn bool_tostr_intrinsic() {
-    let src = "\
-import std/Int
-import std/Float
-import std/Str
-import std/Bool
-fun main() -> Int =
-  t := true
-  if t.toStr() == \"true\" && false.toStr() == \"false\" && \"{t}\" == \"true\"
-    return 1
-  return 0
-";
-    assert_eq!(runMerged::<i64>("bool_tostr_intrinsic", src), 1);
-}
-#[test]
-fn bool_tostr_lowercase() {
-    let src = "\
-import std/Int
-import std/Float
-import std/Str
-import std/Bool
-fun main() -> Int =
-  t := true
-  f := t && false
-  if t.toStr() == \"true\" && f.toStr() == \"false\" && \"{t}-{f}\" == \"true-false\"
-    return 1
-  return 0
-";
-    assert_eq!(runMerged::<i64>("bool_tostr_lowercase", src), 1);
-}
-#[test]
-fn bool_interpolation_with_import() {
-    let src = "\
-import std/Int
-import std/Float
-import std/Str
-import std/Bool
-fun main() -> Int =
-  if \"{true}\" == \"true\" && \"{1 > 2}\" == \"false\"
-    return 1
-  return 0
-";
-    assert_eq!(runMerged::<i64>("bool_interp_import", src), 1);
-}
 #[test]
 fn bool_tostr_without_import_is_rejected() {
     let src = "\
@@ -1730,25 +1455,6 @@ fun main() -> Str =
     );
 }
-#[test]
-fn parse_bool() {
-    let src = "\
-import std/Int
-import std/Float
-import std/Str
-import std/Bool
-fun main() -> Int =
-  a := Bool.parse(\"true\") catch false
-  b := Bool.parse(\"false\") catch true
-  c := Bool.parse(\"nope\") catch false
-  if a && !b && !c
-    return 1
-  return 0
-";
-    assert_eq!(runMerged::<i64>("parse_bool", src), 1);
-}
 // ---- fn-typed fields ("record of functions") + closures calling fn params ----
 #[test]
@@ -1850,57 +1556,6 @@ fn nullable_ref_no_alloc() {
     assert!(!ops.iter().any(|o| o.starts_with("StructNew")), "{ops:?}");
 }
-#[test]
-fn nullable_runs() {
-    let src = format!("{}{}", STD_HEAD, NULLABLE_SRC);
-    assert_eq!(runMerged::<i64>("nullrun", &src), 5 + 100 + 7);
-}
-#[test]
-fn nullable_primitive_keeps_struct_layout() {
-    let src = format!("{}\
-fun half(n: Int) -> Int? =
-  if n % 2 != 0
-    return null
-  n / 2
-fun main() -> Int =
-  {{half(8) ?: 0}} + {{half(3) ?: 100}}
-", STD_HEAD);
-    assert_eq!(runMerged::<i64>("nullprim", &src), 104);
-}
-#[test]
-fn nullable_turns_into_an_error_with_elvis() {
-    let src = format!("{}{}", STD_HEAD, "\
-record Person(name: Str, age: Int)
-fun findIt(n: Int) -> Person? =
-  if n < 0
-    return null
-  Person(name: \"p\", age: n)
-fun viaElvis(n: Int) -> error{Absent, Bad}!Person =
-  p := findIt(n) ?: return error.Absent
-  if p.age > 50
-    return error.Bad
-  p
-fun code(n: Int) -> Int =
-  p := viaElvis(n) catch e
-    match e
-      Absent =>
-        return 1000
-      Bad =>
-        return 2000
-  p.age
-fun main() -> Int =
-  code(3) + code(-1) + code(99)
-");
-    assert_eq!(runMerged::<i64>("nullwide", &src), 3 + 1000 + 2000);
-}
 // ---- L2: structs (flattened, copy semantics) ----
 const VEC2: &str = "\
@@ -1934,14 +1589,6 @@ fn funcTypes(bytes: &[u8]) -> Vec<(Vec<wasmparser::ValType>, Vec<wasmparser::Val
     out
 }
-#[test]
-fn value_copy_semantics() {
-    let src = format!(
-        "{VEC2}fun main() -> Int =\n  a := Vec2(x: 1.0, y: 2.0)\n  b := a\n  b.x = 9.0\n  if a.x == 1.0 && b.x == 9.0 && b.y == 2.0\n    return 1\n  return 0\n"
-    );
-    assert_eq!(runMerged::<i64>("value_copy_semantics", &src), 1);
-}
 #[test]
 fn value_multi_value_return() {
     use wasmparser::ValType::F64;
@@ -1956,22 +1603,6 @@ fn value_multi_value_return() {
     assert_eq!(runMerged::<i64>("value_multi_value_return", &src), 1);
 }
-#[test]
-fn value_in_list_roundtrip() {
-    let src = format!(
-        "import std/List\n{VEC2}fun main() -> Int =\n  l := List[Vec2]()\n  l.push(Vec2(x: 1.0, y: 2.0))\n  l.push(Vec2(x: 3.0, y: 4.0))\n  b := l.get(1)!\n  if l.length() == 2 && b.x == 3.0 && b.y == 4.0 && l.get(0)!.y == 2.0\n    return 1\n  return 0\n"
-    );
-    assert_eq!(runMerged::<i64>("value_in_list_roundtrip", &src), 1);
-}
-#[test]
-fn value_eq_fieldwise() {
-    let src = format!(
-        "{VEC2}fun main() -> Int =\n  a := Vec2(x: 1.0, y: 2.0)\n  if a == Vec2(x: 1.0, y: 2.0) && a != Vec2(x: 1.0, y: 3.0)\n    return 1\n  return 0\n"
-    );
-    assert_eq!(runMerged::<i64>("value_eq_fieldwise", &src), 1);
-}
 #[test]
 fn value_nested_flatten() {
     use wasmparser::ValType::F64;
@@ -1986,14 +1617,6 @@ fn value_nested_flatten() {
     assert_eq!(runMerged::<i64>("value_nested_flatten", &src), 1);
 }
-#[test]
-fn value_operator_add_mul() {
-    let src = format!(
-        "{VEC2}fun main() -> Int =\n  a := Vec2(x: 1.0, y: 2.0)\n  b := Vec2(x: 3.0, y: 4.0)\n  r := a + b * 2.0\n  if r.x == 7.0 && r.y == 10.0\n    return 1\n  return 0\n"
-    );
-    assert_eq!(runMerged::<i64>("value_operator_add_mul", &src), 1);
-}
 #[test]
 fn extern_value_multi_value() {
     let src = format!(
@@ -2073,22 +1696,6 @@ fn value_nested_pattern() {
     assert_eq!(runMerged::<i64>("value_nested_pattern", &src), 1);
 }
-#[test]
-fn local_value_subfield_assign() {
-    let src = format!(
-        "{VEC2}struct Rect(pos: Vec2, size: Vec2)\n\nfun main() -> Int =\n  r := Rect(pos: Vec2(x: 1.0, y: 2.0), size: Vec2(x: 3.0, y: 4.0))\n  r.pos.x = 7.0\n  r.size.y = 9.0\n  if r.pos.x == 7.0 && r.pos.y == 2.0 && r.size.x == 3.0 && r.size.y == 9.0\n    return 1\n  return 0\n"
-    );
-    assert_eq!(runMerged::<i64>("local_value_subfield_assign", &src), 1);
-}
-#[test]
-fn heap_field_value_subfield_assign() {
-    let src = format!(
-        "{VEC2}record Player(pos: Vec2, hp: Int)\n\nstruct Rect(pos: Vec2, size: Vec2)\n\nrecord Body(bounds: Rect, id: Int)\n\nfun main() -> Int =\n  p := Player(pos: Vec2(x: 1.0, y: 2.0), hp: 5)\n  p.pos.x = 8.0\n  b := Body(bounds: Rect(pos: Vec2(x: 1.0, y: 2.0), size: Vec2(x: 3.0, y: 4.0)), id: 1)\n  b.bounds.size.y = 6.0\n  if p.pos.x == 8.0 && p.pos.y == 2.0 && p.hp == 5 && b.bounds.size.y == 6.0 && b.bounds.size.x == 3.0 && b.bounds.pos.y == 2.0\n    return 1\n  return 0\n"
-    );
-    assert_eq!(runMerged::<i64>("heap_field_value_subfield_assign", &src), 1);
-}
 #[test]
 fn value_nested_pattern_mixed() {
     // Whole-value binding next to a nested destructure, and a heap container
@@ -2184,48 +1791,6 @@ fun main() -> Int =
     assert_eq!(runMerged::<i64>("rangeinttight_run", &src), 45);
 }
-#[test]
-fn until_to_downTo_bounds() {
-    // Each loop sums its values and counts iterations; empty ranges iterate nothing.
-    let src = format!("{}\
-fun main() -> Int =
-  a := 0
-  for i := range 2.until(6)
-    a = a + i
-  b := 0
-  for i := range 1.to(4)
-    b = b + i
-  c := 0
-  for i := range 4.downTo(1)
-    c = c * 10 + i
-  n := 0
-  for _ := range 5.until(5)
-    n = n + 1
-  for _ := range 1.downTo(2)
-    n = n + 1
-  for _ := range 0
-    n = n + 1
-  for _ := range 3.to(2)
-    n = n + 1
-  a * 1000000 + b * 100000 + c + n * 100000000
-", iterHead());
-    assert_eq!(runMerged::<i64>("untilbounds", &src), 14 * 1000000 + 10 * 100000 + 4321);
-}
-#[test]
-fn stepBy_on_until() {
-    let src = format!("{}\
-fun main() -> Int =
-  total := 0
-  for i := range 0.until(10).stepBy(3)
-    total = total + i
-  for i := range 1.to(10).stepBy(4)
-    total = total + 100 * i
-  total
-", iterHead());
-    assert_eq!(runMerged::<i64>("untilstep", &src), 0 + 3 + 6 + 9 + 100 * (1 + 5 + 9));
-}
 #[test]
 fn no_closure_in_expansion() {
     let src = format!("{}\
@@ -2260,55 +1825,8 @@ fun main() -> Int =
 }
 #[test]
-fn nested_adapters_skip_take() {
-    let src = format!("{}\
-fun main() -> Int =
-  xs := List(5, 6, 7, 8, 9)
-  total := 0
-  for x := range xs.take(4).skip(1)
-    total = total * 10 + x
-  total
-", iterHead());
-    // skip(1, take(4, xs)) = 6, 7, 8
-    assert_eq!(runMerged::<i64>("nestedskiptake", &src), 678);
-}
-#[test]
-fn zip_two_lists() {
-    let src = format!("{}\
-fun main() -> Int =
-  xs := List(1, 2, 3)
-  ys := List(10, 20, 30, 40)
-  dot := 0
-  for a, b := range xs.zip(ys)
-    dot = dot + a * b
-  dot
-", iterHead());
-    assert_eq!(runMerged::<i64>("ziplists", &src), 140);
-}
-#[test]
-fn chunks_and_stepBy() {
-    let src = format!("{}\
-fun main() -> Int =
-  xs := List(1, 2, 3, 4, 5, 6, 7)
-  pieces := 0
-  last := 0
-  for c := range xs.chunks(3)
-    pieces = pieces + 1
-    last = c.length()
-  stepped := 0
-  for x := range xs.stepBy(3)
-    stepped = stepped + x
-  pieces * 1000 + last * 100 + stepped
-", iterHead());
-    // chunks: [1 2 3] [4 5 6] [7] -> 3 pieces, last has 1; stepBy 3: 1 + 4 + 7 = 12
-    assert_eq!(runMerged::<i64>("chunksstep", &src), 3000 + 100 + 12);
-}
-#[test]
-fn pack_binder_passes_through_map() {
+fn pack_binder_passes_through_map() {
-    // map over a two-value source: map's single name `x` holds both values and is passed to yield
+    // map over a two-value source: map's single name `x` holds both values and is passed to yield
     let src = format!("{}\
 fun* pairs(src: List[Int]) *(Int, Int) =
   for i, x := range src
@@ -2348,21 +1866,6 @@ fun main() -> Int =
     assert_eq!(runMerged::<i64>("starmethod_run", &src), 12);
 }
-#[test]
-fn underscore_binder_skips_binding() {
-    let src = format!("{}\
-fun main() -> Int =
-  xs := List(5, 6, 7)
-  total := 0
-  for _, x := range xs
-    total = total + x
-  for _ := range 4
-    total = total + 1
-  total
-", iterHead());
-    assert_eq!(runMerged::<i64>("underscore", &src), 18 + 4);
-}
 /// The checker's error messages for `src` compiled as a real file ("" when it checks).
 fn checkErrorsMerged(name: &str, src: &str) -> String {
     let dir = std::env::temp_dir().join(format!("plum_seq_{}_{}", name, std::process::id()));
@@ -2509,62 +2012,6 @@ fn error_union_multi_value() {
     assert!(found, "no (i64)->(i64,i32) function type");
 }
-#[test]
-fn fail_and_question_propagate() {
-    let src = "\
-fun a(n: Int) -> !Int =
-  if n < 0
-    return error.Negative
-  n * 2
-fun b(n: Int) -> !Int =
-  x := try a(n)
-  x + 1
-fun main() -> Int =
-  p := b(5) catch 100
-  q := b(-5) catch 200
-  p * 1000 + q
-";
-    assert_eq!(runInt(src), 11 * 1000 + 200);
-}
-#[test]
-fn catch_default_runtime() {
-    let src = "\
-fun f(n: Int) -> !Int =
-  if n == 0
-    return error.Zero
-  n
-fun main() -> Int =
-  {f(7) catch 1} * 10 + {f(0) catch 3}
-";
-    assert_eq!(runInt(src), 73);
-}
-#[test]
-fn catch_return_error_maps() {
-    let src = "\
-fun inner(n: Int) -> !Int =
-  if n == 0
-    return error.Zero
-  n
-fun outer(n: Int) -> !Int =
-  x := inner(n) catch return error.Mapped
-  x + 1
-fun main() -> Int =
-  a := outer(0) catch e
-    match e
-      Mapped => 40
-  b := outer(1) catch 99
-  a + b
-";
-    assert_eq!(runInt(src), 42);
-}
 #[test]
 fn catch_crash_default() {
     let src = "\
@@ -2612,53 +2059,6 @@ fun main() -> Int =
     assert_eq!(runInt(src), 30 + 2 + 6);
 }
-#[test]
-fn catch_block_binds_error() {
-    let src = "\
-fun f(n: Int) -> !Int =
-  if n == 1
-    return error.One
-  if n == 2
-    return error.Two
-  n
-fun main() -> Int =
-  a := f(1) catch e
-    match e
-      One => 10
-      Two => 20
-  b := f(2) catch e
-    match e
-      One => 10
-      Two => 20
-  c := f(3) catch e
-    return 0
-  a * 100 + b * 10 + c
-";
-    assert_eq!(runInt(src), 10 * 100 + 20 * 10 + 3);
-}
-#[test]
-fn e_name_runtime() {
-    let src = "\
-import std/Str
-import std/Int
-import std/Float
-fun f() -> !Int =
-  return error.NotFound
-fun main() -> Int =
-  s := f() catch e
-    e.name()
-  s.length()
-";
-    // the catch block must yield Int, so name() is used for its length instead
-    let src = src.replace("  s := f() catch e\n    e.name()\n  s.length()", "  n := f() catch e\n    e.name().length()\n  n");
-    let (r, _) = runWithCrash("ename", &src);
-    assert_eq!(r.unwrap(), 8);
-}
 #[test]
 fn bang_crashes_with_message() {
     let src = "\
@@ -2683,47 +2083,6 @@ fun main() -> Int =
     assert_eq!(runWithCrash("bangok", ok).0.unwrap(), 7);
 }
-#[test]
-fn unit_error_union() {
-    let src = "\
-fun check(n: Int) -> !Unit =
-  if n < 0
-    return error.Neg
-fun run(n: Int) -> !Int =
-  try check(n)
-  n
-fun main() -> Int =
-  {run(4) catch 0} + {run(-1) catch 5}
-";
-    assert_eq!(runInt(src), 9);
-}
-#[test]
-fn error_union_boxed_in_list() {
-    let src = "\
-import std/Str
-import std/Int
-import std/Float
-import std/List
-fun f(n: Int) -> !Int =
-  if n < 0
-    return error.Neg
-  n
-fun main() -> Int =
-  xs := List[!Int]()
-  xs.push(f(4))
-  xs.push(f(-1))
-  a := xs.at(0) catch 0
-  b := xs.at(1) catch 100
-  a + b
-";
-    assert_eq!(runWithCrash("boxlist", src).0.unwrap(), 104);
-}
 #[test]
 fn error_union_in_class_field() {
     let src = "\
@@ -2761,28 +2120,6 @@ fun main() -> Int =
     assert_eq!(runInt(src), 31);
 }
-#[test]
-fn nullable_ref_still_null() {
-    let src = "\
-import std/Str
-import std/Int
-import std/Float
-record Item(v: Int)
-fun find(n: Int) -> Item? =
-  if n < 0
-    return null
-  Item(v: n)
-fun main() -> Int =
-  a := find(3) ?: Item(v: 0)
-  b := find(-3) ?: Item(v: 5)
-  a.v * 10 + b.v
-";
-    assert_eq!(runWithCrash("nullable", src).0.unwrap(), 35);
-}
 #[test]
 fn no_alloc_on_error_path() {
     let src = "\
@@ -2826,55 +2163,6 @@ fun main() -> Int =
     assert!(msgs[0].contains("main.plum:"), "{}", msgs[0]);
 }
-#[test]
-fn nullable_safe_navigation_keeps_the_reference_layout() {
-    let src = "\
-import std/Str
-import std/Int
-import std/Float
-record Person(name: Str, age: Int)
-fun nameOf(p: Person?) -> Str? =
-  p?.name
-fun ageOf(p: Person?) -> Int? =
-  p?.age
-fun none() -> Person? =
-  return null
-fun main() -> Int =
-  a := nameOf(Person(name: \"abc\", age: 4)) ?: \"\"
-  b := nameOf(none()) ?: \"zz\"
-  c := ageOf(Person(name: \"x\", age: 40)) ?: 0
-  d := ageOf(none()) ?: 7
-  a.length() * 1000 + b.length() * 100 + c + d
-";
-    assert_eq!(runWithCrash("nullnav", src).0.unwrap(), 3000 + 200 + 40 + 7);
-}
-#[test]
-fn expression_bodied_unit_error_union() {
-    let src = "\
-fun check(n: Int) -> error{Neg}!Unit =
-  if n < 0
-    return error.Neg
-fun passthrough(n: Int) -> error{Neg}!Unit =
-  try check(n)
-fun main() -> Int =
-  a := 0
-  passthrough(1) catch e
-    a = a + 1
-  passthrough(-1) catch e
-    a = a + 10
-  a
-";
-    assert_eq!(runInt(src), 10);
-}
 #[test]
 fn open_error_set_name_through_a_parameter() {
     let src = "\
@@ -2930,76 +2218,6 @@ fun main() -> Int =
     assert!(msgs[0].contains("main.plum:"), "{}", msgs[0]);
 }
-#[test]
-fn null_comparisons_and_bindings_run() {
-    let src = "\
-import std/Str
-import std/Int
-import std/Float
-record Item(v: Int)
-fun mi(n: Int) -> Int? =
-  if n > 0
-    return n
-  null
-fun mr(n: Int) -> Item? =
-  if n > 0
-    return Item(v: n)
-  null
-fun nested(n: Int) -> error{Bad}!Int? =
-  if n < 0
-    return error.Bad
-  if n == 0
-    return null
-  n
-fun main() -> Int =
-  score := 0
-  if mi(1) != null
-    score = score + 1
-  if null == mi(0)
-    score = score + 10
-  if mr(0) == null
-    score = score + 100
-  if x := mi(5)
-    score = score + x * 1000
-  if it := mr(2)
-    score = score + it.v * 10000
-  k := 3
-  while y := mi(k)
-    score = score + 100000
-    k = k - 1
-  n := nested(0) catch 0
-  score + {if n == null then 1000000 else 0}
-";
-    assert_eq!(runWithCrash("nullbind", src).0.unwrap(), 1 + 10 + 100 + 5000 + 20000 + 300000 + 1000000);
-}
-#[test]
-fn nullable_value_enum_uses_the_code_word() {
-    let src = "\
-import std/Str
-import std/Int
-import std/Float
-struct Pair(x: Int, y: Int)
-fun make(n: Int) -> Pair? =
-  if n < 0
-    return null
-  Pair(x: n, y: n + 1)
-fun main() -> Int =
-  p := make(4)!
-  q := make(-1) ?: Pair(x: 0, y: 9)
-  p.x * 100 + p.y * 10 + q.y
-";
-    assert_eq!(runWithCrash("nullvalue", src).0.unwrap(), 400 + 50 + 9);
-}
 #[test]
 fn list_of_error_unions_across_sets_valid_wasm() {
     let src = "\
@@ -3026,31 +2244,6 @@ fun main() -> Int =
     assert_eq!(runWithCrash("listsets", src).0.unwrap(), 104);
 }
-#[test]
-fn map_value_error_union_across_sets() {
-    let src = "\
-import std/Str
-import std/Int
-import std/Float
-import std/Map
-fun chk(n: Int) -> !Int =
-  if n < 0
-    return error.Neg
-  n
-fun look(m: Map[Int, error{Neg}!Int]) -> Int =
-  v := m.get(1) catch chk(-1)
-  v catch 0
-fun main() -> Int =
-  m := Map[Int, !Int]()
-  m.set(1, chk(7))
-  look(m)
-";
-    assert_eq!(runWithCrash("mapsets", src).0.unwrap(), 7);
-}
 #[test]
 fn error_value_runtime_in_slots() {
     let src = "\
@@ -3101,27 +2294,6 @@ fun main() -> Int =
 // ---- associated consts, statics and `primitive` ----
-#[test]
-fn primitive_consts_and_statics() {
-    let src = format!("{}\
-primitive Geo =
-  SIDES = 4
-  AREA = SIDES * SIDES
-  NAMES = List(\"a\", \"b\", \"c\")
-  fun twice(n: Int) -> Int =
-    n * 2
-  fun sidesTwice() -> Int =
-    twice(SIDES)
-fun main() -> Int =
-  Geo.SIDES + Geo.AREA + Geo.twice(5) + Geo.sidesTwice() + Geo.NAMES.length()
-", STD_HEAD);
-    // 4 + 16 + 10 + 8 + 3
-    assert_eq!(runMerged::<i64>("prim_consts", &src), 41);
-}
 #[test]
 fn enum_assoc_const() {
     let src = format!("{}\
@@ -3140,58 +2312,8 @@ fun main() -> Int =
     assert_eq!(runMerged::<i64>("enum_const", &src), 23);
 }
-#[test]
-fn value_enum_assoc_const() {
-    let src = format!("{}\
-struct Vec2(x: Float, y: Float) =
-  ZERO = Vec2(x: 0.0, y: 0.0)
-  UNIT = Vec2(x: 1.0, y: 1.0)
-fun main() -> Int =
-  z := Vec2.ZERO
-  u := Vec2.UNIT
-  if z.x == 0.0 && u.y == 1.0
-    return 1
-  return 0
-", STD_HEAD);
-    assert_eq!(runMerged::<i64>("value_enum_const", &src), 1);
-}
-#[test]
-fn extend_float_consts() {
-    let src = format!("{}\
-fun main() -> Int =
-  if Float.PI > 3.14 && Float.PI < 3.15 && Float.TAU == Float.PI * 2.0 && Int.MAX > 0
-    return 1
-  return 0
-", STD_HEAD);
-    assert_eq!(runMerged::<i64>("float_consts", &src), 1);
-}
-#[test]
-fn int_parse_static() {
-    let src = format!("{}\
-fun main() -> Int =
-  a := Int.parse(\"42\") catch -1
-  b := Int.parse(\"x\") catch -1
-  c := Float.parse(\"2.5\") catch -1.0
-  a + b + Int(c * 2.0)
-", STD_HEAD);
-    assert_eq!(runMerged::<i64>("int_parse", &src), 46);
-}
 #[test]
 fn number_enum_removed() {
-    let src = format!("{}\
-fun main() -> Int =
-  x := -7
-  f := 9.0
-  if x.abs() == 7 && f.sqrt() == 3.0 && 3.min(4) == 3 && 2.5.max(1.5) == 2.5
-    return 1
-  return 0
-", STD_HEAD);
-    assert_eq!(runMerged::<i64>("number_removed", &src), 1);
     // `Number` is no longer a type.
     let msg = checkErrorsMerged("number_type", &format!("{}\
 fun f(n: Number) -> Int =
@@ -3203,40 +2325,6 @@ fun main() -> Int =
     assert!(!msg.is_empty(), "Number must not resolve as a type");
 }
-#[test]
-fn assoc_const_names_per_type() {
-    let src = format!("{}\
-primitive Alpha =
-  X = 1
-primitive Beta =
-  X = 20
-record Gamma(n: Int) =
-  X = 300
-  fun sum(self) -> Int =
-    X + Alpha.X + Beta.X
-fun main() -> Int =
-  g := Gamma(n: 0)
-  Alpha.X + Beta.X + Gamma.X + g.sum()
-", STD_HEAD);
-    assert_eq!(runMerged::<i64>("const_names", &src), 1 + 20 + 300 + 321);
-}
-#[test]
-fn primitive_builtin_declares_methods() {
-    // `x.abs()` resolves through `primitive Int` in plum-std/Int.plum.
-    let text = std::fs::read_to_string(repoRoot().join("plum-std/Int.plum")).unwrap();
-    assert!(text.contains("primitive Int ="));
-    let src = format!("{}\
-fun main() -> Int =
-  {{-5}}.abs() + 3.max(9)
-", STD_HEAD);
-    assert_eq!(runMerged::<i64>("prim_builtin", &src), 14);
-}
 #[test]
 fn primitive_not_a_type() {
     let head = STD_HEAD;
@@ -3328,12 +2416,6 @@ fn strIsOneStructWithOneByteArrayField() {
     assert_eq!(runWithCrash("strshape", src).0.unwrap(), 5);
 }
-#[test]
-fn bufferToStrLengthExactAfterDoubling() {
-    let src = "import std/Str\nimport std/Buffer\nimport std/Int\nimport std/Float\n\nfun main() -> Int =\n  b := Buffer()\n  i := 0\n  while i < 37\n    b.write(\"abc\")\n    i = i + 1\n  b.toStr().length() * 1000 + b.length()\n";
-    assert_eq!(runWithCrash("bufexact", src).0.unwrap(), 111111);
-}
 // ---- struct-of-arrays layout for Array[struct] ----
 #[test]

plum-wasm-codegen/tests/examples_test.rs CHANGED Viewed

@@ -43,63 +43,6 @@ fn assertCompiles(name: &str) -> Vec<u8> {
     bytes
 }
-/// Examples that stick to currently-supported codegen features (primitives, control
-/// flow, classes/methods) must actually compile to valid wasm — not just parse and
-/// type-check.
-#[test]
-fn basicsCompiles() {
-    assertCompiles("basics.plum");
-}
-#[test]
-fn controlFlowCompiles() {
-    assertCompiles("control_flow.plum");
-}
-#[test]
-fn functionsCompiles() {
-    assertCompiles("functions.plum");
-}
-#[test]
-fn structsRecordsCompiles() {
-    assertCompiles("structs_records.plum");
-}
-// unions.plum/match.plum/closures.plum's actual runtime-correctness checks
-// now live as native `test`/`expect` blocks inside those example files
-// themselves (run via `plum test plum-examples/<name>.plum`, see
-// scripts/test-plum.sh) — `assertCompiles` below still exercises that each
-// still compiles to valid wasm via this crate's direct (non-CLI) path.
-#[test]
-fn unionsCompiles() {
-    assertCompiles("unions.plum");
-}
-#[test]
-fn gameLoopCompiles() {
-    assertCompiles("game_loop.plum");
-}
-#[test]
-fn matchExampleCompiles() {
-    assertCompiles("match.plum");
-}
-#[test]
-fn closuresExampleCompiles() {
-    assertCompiles("closures.plum");
-}
-/// strings.plum exercises string interpolation (plain literals, `Str`/`Int`
-/// interpolation, and escape sequences) — it has no `main` to execute, so (matching
-/// `basicsCompiles`/`controlFlowCompiles`/etc. above for other main-less examples)
-/// this only checks that it compiles to a valid module.
-#[test]
-fn stringsExampleCompiles() {
-    assertCompiles("strings.plum");
-}
 /// io.plum exercises `extern fun` (see `Fn.is_extern`/`FnBody::Extern` in
 /// plum-core/src/ast.rs and their handling in plum-wasm-codegen/src/lib.rs) — it
 /// declares its own `extern fun printLn(s: Str)` (redeclared locally rather than a
@@ -211,9 +154,10 @@ fn ioExampleCompilesAndRunsCorrectly() {
 /// not the boxed `array (mut anyref)`.
 #[test]
 fn array_int_native() {
-    use wasmparser::{CompositeInnerType, Parser, Payload, StorageType, ValType};
+    use wasmparser::{CompositeInnerType, HeapType, Parser, Payload, StorageType, ValType};
     let bytes = assertCompiles("typed_arrays.plum");
     let mut elems: Vec<ValType> = Vec::new();
+    let mut erased = false;
     for payload in Parser::new(0).parse_all(&bytes) {
         if let Payload::TypeSection(reader) = payload.unwrap() {
             for rec in reader {
@@ -221,6 +165,9 @@ fn array_int_native() {
                     if let CompositeInnerType::Array(a) = &sub.composite_type.inner {
                         if a.0.mutable {
                             if let StorageType::Val(v) = a.0.element_type {
+                                if let ValType::Ref(r) = v {
+                                    erased |= matches!(r.heap_type(), HeapType::Abstract { .. });
+                                }
                                 elems.push(v);
                             }
                         }
@@ -229,44 +176,12 @@ fn array_int_native() {
             }
         }
     }
+    assert!(!erased, "mutable array of erased abstract ref: {:?}", elems);
     assert!(elems.contains(&ValType::I64), "no (mut i64) array in {:?}", elems);
     assert!(elems.contains(&ValType::F64), "no (mut f64) array in {:?}", elems);
     assert!(elems.contains(&ValType::I32), "no (mut i32) array in {:?}", elems);
 }
-/// Game-perf 1: no mutable array is an erased abstract-ref array, and
-/// `Array[Int]`/`Array[Float]` element storage is exactly i64/f64.
-#[test]
-fn array_elements_are_never_erased_anyref() {
-    use wasmparser::{CompositeInnerType, HeapType, Parser, Payload, StorageType, ValType};
-    let bytes = assertCompiles("typed_arrays.plum");
-    let mut mut_elems: Vec<StorageType> = Vec::new();
-    for payload in Parser::new(0).parse_all(&bytes) {
-        if let Payload::TypeSection(reader) = payload.unwrap() {
-            for rec in reader {
-                for sub in rec.unwrap().into_types() {
-                    if let CompositeInnerType::Array(a) = &sub.composite_type.inner {
-                        if a.0.mutable {
-                            mut_elems.push(a.0.element_type);
-                        }
-                    }
-                }
-            }
-        }
-    }
-    for e in &mut_elems {
-        if let StorageType::Val(ValType::Ref(r)) = e {
-            assert!(
-                !matches!(r.heap_type(), HeapType::Abstract { .. }),
-                "mutable array of erased abstract ref: {:?}",
-                mut_elems
-            );
-        }
-    }
-    assert!(mut_elems.contains(&StorageType::Val(ValType::I64)));
-    assert!(mut_elems.contains(&StorageType::Val(ValType::F64)));
-}
 /// L1 `const_table_1000_entries`: 1000 associated consts (spread over two
 /// bodies, before and between other decls) plus a 1000-element list literal
 /// parse, type-check and are usable inside methods.

plum-wasm-codegen/tests/unions_e2e_test.rs CHANGED Viewed

@@ -65,66 +65,6 @@ fn withDefs(body: &str) -> String {
     format!("{DEFS}{body}")
 }
-#[test]
-fn list_of_shapes() {
-    let src = withDefs(
-        "\
-fun main() -> Int =
-  xs := List[Shape]()
-  xs.push(Circle(r: 1.0))
-  xs.push(Rectangle(w: 2.0, h: 3.0))
-  sum := 0.0
-  for x := range xs
-    sum = sum + x.area()
-  Int(sum)
-",
-    );
-    assert_eq!(runInt("list", &src), 9);
-}
-#[test]
-fn struct_member_copy() {
-    let src = withDefs(
-        "\
-fun make() -> Shape = Circle(r: 1.0)
-fun main() -> Int =
-  s := make()
-  r := 0.0
-  if Circle := s
-    c := s
-    c.r = 5.0
-    r = c.r + s.r
-  Int(r)
-",
-    );
-    assert_eq!(runInt("copy", &src), 6);
-}
-#[test]
-fn narrow_and_dispatch() {
-    let src = withDefs(
-        "\
-fun pick(big: Bool) -> Shape =
-  if big
-    Rectangle(w: 10.0, h: 10.0)
-  else
-    Circle(r: 1.0)
-fun wide(s: Shape) -> Float =
-  match s
-    Circle => 0.0
-    Rectangle => s.w
-fun main() -> Int =
-  a := pick(true)
-  b := pick(false)
-  Int(a.area() + b.area() + wide(a))
-",
-    );
-    assert_eq!(runInt("narrow", &src), 113);
-}
 #[test]
 fn member_into_optional_and_error_unions() {
     let src = withDefs(
@@ -187,22 +127,3 @@ fun go(p: Pair) -> Int =
         "{errs:?}"
     );
 }
-#[test]
-fn bool_is_a_member() {
-    let src = withDefs(
-        "\
-enum Jb = BNull | Bool | Float
-fun code(j: Jb) -> Int =
-  match j
-    BNull => 0
-    Bool => if j then 1 else 2
-    Float => 3
-fun main() -> Int =
-  code(true) * 100 + code(false) * 10 + code(1.5)
-",
-    );
-    assert_eq!(runInt("boolmember", &src), 123);
-}