f822aa8 | plum | pyrossh

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

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

f822aa8 — Peter John 2026-11-05T23:28:10+05:30

Compiler cleanup phase 6: tests in Plum

Files changed (132) hide show

compiler/core/tests/core/for_next_test.rs +0 -98
compiler/core/tests/core/fused_closure_generic_test.rs +0 -28
compiler/core/tests/core/main.rs +0 -2
compiler/tests/core/for_next.plum +68 -0
compiler/tests/core/fused_closure_generic.plum +23 -0
compiler/tests/tail_calls.plum +23 -0
compiler/tests/wasm_codegen/e2e_mem/match_arm_rename_still_valid_wasm.plum +22 -0
compiler/tests/wasm_codegen/e2e_mem/plain_spread_still_copies.plum +15 -0
compiler/tests/wasm_codegen/e2e_mem/unique_self_field_write.plum +18 -0
compiler/tests/wasm_codegen/e2e_mem/unique_self_spread_return.plum +15 -0
compiler/tests/wasm_codegen/e2e_mem/unique_spread_hazard_falls_back_to_copy_1.plum +18 -0
compiler/tests/wasm_codegen/e2e_mem/unique_spread_hazard_falls_back_to_copy_2.plum +17 -0
compiler/tests/wasm_codegen/e2e_mem/unique_spread_reassign_local.plum +16 -0
compiler/tests/wasm_codegen/e2e_mem/unique_spread_sets_fields.plum +15 -0
compiler/tests/wasm_codegen/e2e_mem/unique_spread_swap_reads_old_values.plum +16 -0
compiler/tests/wasm_codegen/e2e_records/base_through_embedded_struct.plum +22 -0
compiler/tests/wasm_codegen/e2e_records/cons_list_length_map_sum.plum +29 -0
compiler/tests/wasm_codegen/e2e_records/deep_nested_variant_match.plum +20 -0
compiler/tests/wasm_codegen/e2e_records/embedded_record_standalone_and_unselected_set_by_init.plum +21 -0
compiler/tests/wasm_codegen/e2e_records/empty_init_with_annotation.plum +24 -0
compiler/tests/wasm_codegen/e2e_records/enum_init_versus_variant_name.plum +25 -0
compiler/tests/wasm_codegen/e2e_records/equality_is_identity_of_the_variant_value.plum +17 -0
compiler/{wasm-codegen/tests/wasm_codegen/e2e_records/empty_record_embed.rs → tests/wasm_codegen/e2e_records/field_less_struct_embedding_field_less_base_dispatches_in_a_slice.plum} +10 -13
compiler/tests/wasm_codegen/e2e_records/fixed_param_init.plum +19 -0
compiler/tests/wasm_codegen/e2e_records/fresh_list_per_construction.plum +27 -0
compiler/tests/wasm_codegen/e2e_records/generic_inferred_from_args.plum +25 -0
compiler/tests/wasm_codegen/e2e_records/inherited_fields_methods_and_init_order.plum +26 -0
compiler/tests/wasm_codegen/e2e_records/match_variant_fields.plum +17 -0
compiler/tests/wasm_codegen/e2e_records/million_cells_built_and_mapped_in_constant_stack.plum +24 -0
compiler/tests/wasm_codegen/e2e_records/nested_enum_match.plum +23 -0
compiler/tests/wasm_codegen/e2e_records/nested_literal_construction.plum +28 -0
compiler/tests/wasm_codegen/e2e_records/override_calls_original.plum +24 -0
compiler/tests/wasm_codegen/e2e_records/reassign_enum_local_across_variants.plum +33 -0
compiler/tests/wasm_codegen/e2e_records/rest_runs_after_build_and_nested_construction.plum +22 -0
compiler/tests/wasm_codegen/e2e_records/ship_example_values.plum +26 -0
compiler/tests/wasm_codegen/e2e_records/through_a_base_value.plum +24 -0
compiler/tests/wasm_codegen/e2e_records/tree_insert_and_size.plum +20 -0
compiler/tests/wasm_codegen/e2e_records/variant_name_wins.plum +24 -0
compiler/tests/wasm_codegen/e2e_tail/big_link_built_and_summed.plum +17 -0
compiler/tests/wasm_codegen/e2e_tail/break_in_else_if_chain_in_while.plum +20 -0
compiler/tests/wasm_codegen/e2e_tail/break_in_if_in_match_arm_in_while.plum +30 -0
compiler/tests/wasm_codegen/e2e_tail/break_in_match_arm_direct.plum +37 -0
compiler/tests/wasm_codegen/e2e_tail/closure_body_tail_call_million.plum +12 -0
compiler/tests/wasm_codegen/e2e_tail/closure_captures_iteration_value.plum +14 -0
compiler/tests/wasm_codegen/e2e_tail/closure_not_recursive_unchanged.plum +10 -0
compiler/tests/wasm_codegen/e2e_tail/closure_tail_call_runs.plum +14 -0
compiler/tests/wasm_codegen/e2e_tail/continue_in_if_in_match_arm_in_while.plum +33 -0
compiler/tests/wasm_codegen/e2e_tail/method_self_tail.plum +14 -0
compiler/tests/wasm_codegen/e2e_tail/mutual_tail_million.plum +14 -0
compiler/tests/wasm_codegen/e2e_tail/nested_loops_with_match_in_inner.plum +39 -0
compiler/tests/wasm_codegen/e2e_tail/non_tail_union_wrap_not_tail.plum +17 -0
compiler/tests/wasm_codegen/e2e_tail/param_self_tail.plum +17 -0
compiler/tests/wasm_codegen/e2e_tail/question_in_tail_not_tail_call.plum +16 -0
compiler/tests/wasm_codegen/e2e_tail/recursive_closure_captures_outer.plum +10 -0
compiler/tests/wasm_codegen/e2e_tail/recursive_local_closure_million.plum +9 -0
compiler/tests/wasm_codegen/e2e_tail/result_mutual_million.plum +20 -0
compiler/tests/wasm_codegen/e2e_tail/result_self_loop_million.plum +17 -0
compiler/tests/wasm_codegen/e2e_tail/result_self_loop_returns_err.plum +15 -0
compiler/tests/wasm_codegen/e2e_tail/self_calling_closure_typed_params_runs.plum +9 -0
compiler/tests/wasm_codegen/e2e_tail/self_calling_closure_untyped_params_runs.plum +9 -0
compiler/tests/wasm_codegen/e2e_tail/self_tail_args_swap.plum +16 -0
compiler/tests/wasm_codegen/e2e_tail/self_tail_million.plum +20 -0
compiler/tests/wasm_codegen/e2e_tail/self_tail_through_nested_branches.plum +21 -0
compiler/tests/wasm_codegen/e2e_tail/tail_call_in_match_arm.plum +15 -0
compiler/tests/wasm_codegen/e2e_tail/trmc_link_map_100k.plum +25 -0
compiler/tests/wasm_codegen/e2e_types/adder_two_levels.plum +14 -0
compiler/tests/wasm_codegen/e2e_types/bang_unwraps_and_chains.plum +17 -0
compiler/tests/wasm_codegen/e2e_types/bare_tag_fixed_by_later_arg.plum +17 -0
compiler/tests/wasm_codegen/e2e_types/bare_tag_fixed_by_other_link_arg.plum +18 -0
compiler/tests/wasm_codegen/e2e_types/bare_variants_in_if_branches_take_fn_return_type.plum +26 -0
compiler/tests/wasm_codegen/e2e_types/bare_variants_in_match_arms_take_fn_return_type.plum +18 -0
compiler/tests/wasm_codegen/e2e_types/chained_err_value_is_first.plum +25 -0
compiler/tests/wasm_codegen/e2e_types/chained_question_returns_first_err.plum +26 -0
compiler/tests/wasm_codegen/e2e_types/closure_coerced_into_optional_return.plum +12 -0
compiler/tests/wasm_codegen/e2e_types/closure_into_ref_option_and_result.plum +23 -0
compiler/tests/wasm_codegen/e2e_types/closure_passes_none_to_an_option_param.plum +18 -0
compiler/tests/wasm_codegen/e2e_types/closure_returning_none_into_optional.plum +12 -0
compiler/tests/wasm_codegen/e2e_types/curried_closure_runs.plum +13 -0
compiler/tests/wasm_codegen/e2e_types/err_field_is_error.plum +15 -0
compiler/tests/wasm_codegen/e2e_types/field_less_variant_called_like_a_constructor.plum +23 -0
compiler/tests/wasm_codegen/e2e_types/field_less_variant_of_a_generic_enum_called_like_a_constructor.plum +22 -0
compiler/tests/wasm_codegen/e2e_types/fn_field_returning_optional.plum +15 -0
compiler/tests/wasm_codegen/e2e_types/g1_typed_param.plum +13 -0
compiler/tests/wasm_codegen/e2e_types/g2_local_closure_inferred_from_first_call.plum +12 -0
compiler/tests/wasm_codegen/e2e_types/g5_returned_closure.plum +12 -0
compiler/tests/wasm_codegen/e2e_types/inline_if_joins_bare_variant_instantiations.plum +19 -0
compiler/tests/wasm_codegen/e2e_types/inlined_constant_call_keeps_return_type.plum +18 -0
compiler/tests/wasm_codegen/e2e_types/list_literal_element_pinned_by_a_later_element.plum +37 -0
compiler/tests/wasm_codegen/e2e_types/map_err_closure_param_shadows_top_level_fn.plum +17 -0
compiler/tests/wasm_codegen/e2e_types/map_err_on_call_result.plum +18 -0
compiler/tests/wasm_codegen/e2e_types/map_err_then_unwrap_or_fuses.plum +16 -0
compiler/tests/wasm_codegen/e2e_types/nested_generic.plum +21 -0
compiler/tests/wasm_codegen/e2e_types/none_as_generic_param_default.plum +16 -0
compiler/tests/wasm_codegen/e2e_types/none_as_param_default.plum +16 -0
compiler/tests/wasm_codegen/e2e_types/ok_unit_and_expression_position.plum +24 -0
compiler/tests/wasm_codegen/e2e_types/option_question_returns_none.plum +18 -0
compiler/tests/wasm_codegen/e2e_types/reused_cell_is_read_through_its_local.plum +23 -0
compiler/tests/wasm_codegen/e2e_types/seq_with_optional_next.plum +19 -0
compiler/tests/wasm_codegen/e2e_types/single_letter_types_and_variants.plum +24 -0
compiler/tests/wasm_codegen/e2e_types/specialised_arm_keeps_result_type.plum +26 -0
compiler/tests/wasm_codegen/e2e_types/static_method_of_generic_type_not_pinning_t.plum +12 -0
compiler/tests/wasm_codegen/e2e_types/static_on_builtin.plum +11 -0
compiler/tests/wasm_codegen/e2e_types/static_on_builtin_method_and_json_cycle.plum +17 -0
compiler/tests/wasm_codegen/e2e_types/static_on_type_param.plum +14 -0
compiler/tests/wasm_codegen/e2e_types/struct_payload_in_some.plum +18 -0
compiler/tests/wasm_codegen/e2e_types/unannotated_local_of_list_pinned_by_a_later_element.plum +39 -0
compiler/tests/wasm_codegen/e2e_types/unit_closure_local_called_as_a_statement.plum +15 -0
compiler/tests/wasm_codegen/e2e_types/untyped_closure_passes_none_to_an_option_param.plum +18 -0
compiler/tests/wasm_codegen/e2e_types/user_type_shadows_std_pair_imported_by_std.plum +14 -0
compiler/wasm-codegen/tests/wasm_codegen/e2e_mem/unique_inplace.rs +0 -119
compiler/wasm-codegen/tests/wasm_codegen/e2e_records/enum_init.rs +1 -68
compiler/wasm-codegen/tests/wasm_codegen/e2e_records/inline_variants.rs +1 -73
compiler/wasm-codegen/tests/wasm_codegen/e2e_records/mod.rs +0 -2
compiler/wasm-codegen/tests/wasm_codegen/e2e_records/record_embed.rs +0 -79
compiler/wasm-codegen/tests/wasm_codegen/e2e_records/record_init.rs +1 -74
compiler/wasm-codegen/tests/wasm_codegen/e2e_records/unboxed_variants.rs +1 -167
compiler/wasm-codegen/tests/wasm_codegen/e2e_tail/closure_tail.rs +1 -37
compiler/wasm-codegen/tests/wasm_codegen/e2e_tail/error_tail.rs +0 -27
compiler/wasm-codegen/tests/wasm_codegen/e2e_tail/loop_break.rs +0 -148
compiler/wasm-codegen/tests/wasm_codegen/e2e_tail/mod.rs +0 -2
compiler/wasm-codegen/tests/wasm_codegen/e2e_tail/tail.rs +1 -150
compiler/wasm-codegen/tests/wasm_codegen/e2e_types/closure_optional.rs +0 -39
compiler/wasm-codegen/tests/wasm_codegen/e2e_types/closure_types.rs +0 -50
compiler/wasm-codegen/tests/wasm_codegen/e2e_types/list_and_shadow.rs +0 -81
compiler/wasm-codegen/tests/wasm_codegen/e2e_types/mod.rs +0 -3
compiler/wasm-codegen/tests/wasm_codegen/e2e_types/question.rs +0 -144
compiler/wasm-codegen/tests/wasm_codegen/e2e_types/synthetic_sites.rs +1 -108
compiler/wasm-codegen/tests/wasm_codegen/e2e_types/type_param_static.rs +0 -83
docs/backlog.md +1 -1
docs/plans/2026-11-05-compiler-cleanup-phase5-6.md +1 -1
docs/plans/2026-11-05-compiler-cleanup-phase5-6.progress.md +26 -0
docs/plans/2026-11-05-compiler-cleanup-phase5-6.results.md +36 -0

compiler/core/tests/core/for_next_test.rs DELETED Viewed

@@ -1,98 +0,0 @@
-#![allow(non_snake_case)]
-//! The one loop form `for x := range v`: `v: Int` counts 0..v; any other `v`
-//! whose type has `next(self) -> Option[Pair[T, Self]]` iterates (None = done, else
-//! `Some(Pair(value, rest))`, the iterator rebound to `rest` each step).
-use plum_test_support::runInt;
-#[test]
-fn range_int_counts_from_zero() {
-    let src = "\
-import std/Int
-fun main() -> Int =
-  acc := 0
-  for i := range 3
-    acc = acc * 10 + i + 1
-  acc
-";
-    // binds 0, 1, 2
-    assert_eq!(runInt("for_next_int", src), 123);
-}
-#[test]
-fn range_list_binds_elements() {
-    let src = "\
-import std/Int
-import std/List
-fun main() -> Int =
-  acc := 0
-  for x := range [5, 6]
-    acc = acc * 10 + x
-  acc
-";
-    assert_eq!(runInt("for_next_list", src), 56);
-}
-#[test]
-fn list_next_steps() {
-    let src = "\
-import std/Int
-import std/List
-import std/Pair
-import std/Option
-fun main() -> Int =
-  xs := [5, 6]
-  p := xs.next()!
-  q := p.second.next()!
-  r := q.second.next()
-  p.first * 100 + q.first * 10 + {if r.isNone() then 1 else 0}
-";
-    assert_eq!(runInt("for_next_list_next", src), 561);
-}
-#[test]
-fn range_user_struct_with_next() {
-    let src = "\
-import std/Int
-import std/Pair
-import std/Option
-struct Countdown(n: Int) =
-  fun next(self) -> Option[Pair[Int, Countdown]] =
-    if self.n == 0 then None else Some(Pair(first: self.n, second: Countdown(n: self.n - 1)))
-fun main() -> Int =
-  acc := 0
-  for x := range Countdown(n: 3)
-    acc = acc * 10 + x
-  acc
-";
-    assert_eq!(runInt("for_next_user", src), 321);
-}
-#[test]
-fn range_next_supports_continue_and_break() {
-    let src = "\
-import std/Int
-import std/Pair
-import std/Option
-struct Up(i: Int, n: Int) =
-  fun next(self) -> Option[Pair[Int, Up]] =
-    if self.i >= self.n then None else Some(Pair(first: self.i, second: Up(i: self.i + 1, n: self.n)))
-fun main() -> Int =
-  acc := 0
-  for x := range Up(i: 0, n: 10)
-    if x == 1
-      continue
-    if x == 4
-      break
-    acc = acc * 10 + x
-  acc
-";
-    // 0, (skip 1), 2, 3, stop at 4
-    assert_eq!(runInt("for_next_ctl", src), 23);
-}

compiler/core/tests/core/fused_closure_generic_test.rs DELETED Viewed

@@ -1,28 +0,0 @@
-#![allow(non_snake_case)]
-//! A fused fn keeps a specialised-away closure parameter when it is the only thing that
-//! fixes a generic another kept closure parameter takes as its input: `map(andThen(..))`
-//! on `Option` fuses to `map$c0$andThen$c0$0(|t| t.name, u)`, whose `|t| ..` needs the
-//! `B` that only `andThen`'s closure binds. Dropping it left the fused fn uninstantiable
-//! ("unknown function" at codegen).
-use plum_test_support::runInt;
-#[test]
-fn option_and_then_then_map_compiles_and_runs() {
-    let src = "\
-import std/Str
-import std/Int
-import std/Option
-struct Target(size: Int)
-struct User(name: Str, target: Option[Target])
-fun targetSize(u: Option[User]) -> Option[Int] =
-  u.andThen(|v| v.target).map(|t| t.size)
-fun main() -> Int =
-  full := User(name: \"u\", target: Some(Target(size: 40)))
-  none: Option[User] := None
-  targetSize(Some(full)).unwrapOr(0) + targetSize(none).unwrapOr(2)
-";
-    assert_eq!(runInt("fused_closure_generic", src), 42);
-}

compiler/core/tests/core/main.rs CHANGED Viewed

@@ -3,10 +3,8 @@ mod closure_spec_test;
 mod closure_types_parse_test;
 mod diag_test;
 mod drive_test;
-mod for_next_test;
 mod formatter_test;
 mod forms_list_range_test;
-mod fused_closure_generic_test;
 mod generics_test;
 mod ids_spans_test;
 mod inline_variants_test;

compiler/tests/core/for_next.plum ADDED Viewed

@@ -0,0 +1,68 @@
+import std/Int
+import std/List
+import std/Pair
+import std/Option
+# The one loop form `for x := range v`: `v: Int` counts 0..v; any other `v`
+# whose type has `next(self) -> Option[Pair[T, Self]]` iterates (None = done, else
+# `Some(Pair(value, rest))`, the iterator rebound to `rest` each step).
+struct Countdown(n: Int) =
+  fun next(self) -> Option[Pair[Int, Countdown]] =
+    if self.n == 0 then None else Some(Pair(first: self.n, second: Countdown(n: self.n - 1)))
+struct Up(i: Int, n: Int) =
+  fun next(self) -> Option[Pair[Int, Up]] =
+    if self.i >= self.n then None else Some(Pair(first: self.i, second: Up(i: self.i + 1, n: self.n)))
+fun rangeInt() -> Int =
+  acc := 0
+  for i := range 3
+    acc = acc * 10 + i + 1
+  acc
+fun rangeList() -> Int =
+  acc := 0
+  for x := range [5, 6]
+    acc = acc * 10 + x
+  acc
+fun listNext() -> Int =
+  xs := [5, 6]
+  p := xs.next()!
+  q := p.second.next()!
+  r := q.second.next()
+  p.first * 100 + q.first * 10 + {if r.isNone() then 1 else 0}
+fun rangeUser() -> Int =
+  acc := 0
+  for x := range Countdown(n: 3)
+    acc = acc * 10 + x
+  acc
+fun rangeCtl() -> Int =
+  acc := 0
+  for x := range Up(i: 0, n: 10)
+    if x == 1
+      continue
+    if x == 4
+      break
+    acc = acc * 10 + x
+  acc
+# binds 0, 1, 2
+test "range_int_counts_from_zero"
+  assert rangeInt() == 123
+test "range_list_binds_elements"
+  assert rangeList() == 56
+test "list_next_steps"
+  assert listNext() == 561
+test "range_user_struct_with_next"
+  assert rangeUser() == 321
+# 0, (skip 1), 2, 3, stop at 4
+test "range_next_supports_continue_and_break"
+  assert rangeCtl() == 23

compiler/tests/core/fused_closure_generic.plum ADDED Viewed

@@ -0,0 +1,23 @@
+import std/Str
+import std/Int
+import std/Option
+# A fused fn keeps a specialised-away closure parameter when it is the only thing that
+# fixes a generic another kept closure parameter takes as its input: `map(andThen(..))`
+# on `Option` fuses to `map$c0$andThen$c0$0(|t| t.name, u)`, whose `|t| ..` needs the
+# `B` that only `andThen`'s closure binds. Dropping it left the fused fn uninstantiable
+# ("unknown function" at codegen).
+struct Target(size: Int)
+struct User(name: Str, target: Option[Target])
+fun targetSize(u: Option[User]) -> Option[Int] =
+  u.andThen(|v| v.target).map(|t| t.size)
+fun fusedSum() -> Int =
+  full := User(name: "u", target: Some(Target(size: 40)))
+  none: Option[User] := None
+  targetSize(Some(full)).unwrapOr(0) + targetSize(none).unwrapOr(2)
+test "option_and_then_then_map_compiles_and_runs"
+  assert fusedSum() == 42

compiler/tests/tail_calls.plum ADDED Viewed

@@ -0,0 +1,23 @@
+import std/Int
+# `plum test` must run tail calls like a compiled program: each loop below is
+# 1000000 deep (a non-tail loop of that depth traps), which overflows the stack unless the calls are real tail calls.
+fun count(n: Int, acc: Int) -> Int = if n == 0 then acc else count(n - 1, acc + 1)
+struct Counter(step: Int) =
+  fun count(self, n: Int, acc: Int) -> Int =
+    if n == 0 then acc else self.count(n - 1, acc + self.step)
+fun viaClosure(n: Int, k: fn(Int) -> Int) -> Int = if n == 0 then 7 else k(n - 1)
+fun goClosure(n: Int) -> Int = viaClosure(n, goClosure)
+test "a self tail call 1000000 deep does not overflow the stack"
+  assert count(1000000, 0) == 1000000
+test "a method tail call 1000000 deep does not overflow the stack"
+  assert Counter(step: 3).count(1000000, 0) == 3000000
+test "a closure tail call 1000000 deep does not overflow the stack"
+  assert goClosure(1000000) == 7

compiler/tests/wasm_codegen/e2e_mem/match_arm_rename_still_valid_wasm.plum ADDED Viewed

@@ -0,0 +1,22 @@
+import std/Str
+import std/Int
+import std/Float
+import std/Slice
+struct Pa(x: Int)
+struct Pb(y: Int, z: Int)
+enum Pick = Wa(v: Pa) | Wb(v: Pb)
+fun go(p: Pick) -> Int =
+  match p
+    Wa(a) => a.x
+    Wb(b) => b.y * 10 + b.z
+fun runMain() -> Int =
+  go(Wa(v: Pa(x: 4))) * 100 + go(Wb(v: Pb(y: 5, z: 6)))
+# moved from e2e_mem::unique_inplace::match_arm_rename_still_valid_wasm
+# R5: arms binding differently named locals of different record types.
+test "match arm rename still valid wasm"
+  assert runMain() == 456

compiler/tests/wasm_codegen/e2e_mem/plain_spread_still_copies.plum ADDED Viewed

@@ -0,0 +1,15 @@
+import std/Str
+import std/Int
+import std/Float
+import std/Slice
+struct Cell(x: Int, y: Int)
+fun runMain() -> Int =
+  s := Cell(x: 1, y: 7)
+  t := Cell(..s, x: 5)
+  s.x * 1000 + t.x * 100 + t.y
+# moved from e2e_mem::unique_inplace::plain_spread_still_copies
+test "plain spread still copies"
+  assert runMain() == 1507

compiler/tests/wasm_codegen/e2e_mem/unique_self_field_write.plum ADDED Viewed

@@ -0,0 +1,18 @@
+import std/Str
+import std/Int
+import std/Float
+import std/Slice
+struct Cell(mut x: Int) =
+  fun bump(self) -> Cell =
+    self.x = self.x + 1
+    self
+fun runMain() -> Int =
+  s := Cell(x: 41)
+  t := s.bump()
+  t.x
+# moved from e2e_mem::unique_inplace::unique_self_field_write
+test "unique self field write"
+  assert runMain() == 42

compiler/tests/wasm_codegen/e2e_mem/unique_self_spread_return.plum ADDED Viewed

@@ -0,0 +1,15 @@
+import std/Str
+import std/Int
+import std/Float
+import std/Slice
+struct Cell(x: Int, y: Int) =
+  fun step(self) -> Cell = Cell(..self, x: self.x + 1)
+fun runMain() -> Int =
+  t := Cell(x: 1, y: 7).step().step()
+  t.x * 100 + t.y
+# moved from e2e_mem::unique_inplace::unique_self_spread_return
+test "unique self spread return"
+  assert runMain() == 307

compiler/tests/wasm_codegen/e2e_mem/unique_spread_hazard_falls_back_to_copy_1.plum ADDED Viewed

@@ -0,0 +1,18 @@
+import std/Str
+import std/Int
+import std/Float
+import std/Slice
+struct Cell(x: Int, y: Int) =
+  fun sum(self) -> Int = self.x + self.y
+fun runMain() -> Int =
+  s := Cell(x: 1, y: 2)
+  t := Cell(..s, x: 10, y: s.sum())
+  t.x * 100 + t.y
+# moved from e2e_mem::unique_inplace::unique_spread_hazard_falls_back_to_copy
+# A later value that reads a field an earlier one overwrote, or uses the source
+# any other way (here a method call), must still run (copy fallback).
+test "unique spread hazard falls back to copy"
+  assert runMain() == 1003

compiler/tests/wasm_codegen/e2e_mem/unique_spread_hazard_falls_back_to_copy_2.plum ADDED Viewed

@@ -0,0 +1,17 @@
+import std/Str
+import std/Int
+import std/Float
+import std/Slice
+struct Cell(x: Int, y: Int, z: Int)
+fun runMain() -> Int =
+  s := Cell(x: 1, y: 2, z: 3)
+  t := Cell(..s, x: 10, z: s.y + s.z)
+  t.x * 100 + t.y * 10 + t.z
+# moved from e2e_mem::unique_inplace::unique_spread_hazard_falls_back_to_copy
+# A later value that reads a field an earlier one overwrote, or uses the source
+# any other way (here a method call), must still run (copy fallback).
+test "unique spread hazard falls back to copy"
+  assert runMain() == 1025

compiler/tests/wasm_codegen/e2e_mem/unique_spread_reassign_local.plum ADDED Viewed

@@ -0,0 +1,16 @@
+import std/Str
+import std/Int
+import std/Float
+import std/Slice
+struct Cell(x: Int, y: Int)
+fun runMain() -> Int =
+  s := Cell(x: 1, y: 7)
+  s = Cell(..s, x: s.x + 1)
+  s = Cell(..s, y: s.y + s.x)
+  s.x * 100 + s.y
+# moved from e2e_mem::unique_inplace::unique_spread_reassign_local
+test "unique spread reassign local"
+  assert runMain() == 209

compiler/tests/wasm_codegen/e2e_mem/unique_spread_sets_fields.plum ADDED Viewed

@@ -0,0 +1,15 @@
+import std/Str
+import std/Int
+import std/Float
+import std/Slice
+struct Cell(x: Int, y: Int, z: Int)
+fun runMain() -> Int =
+  s := Cell(x: 1, y: 2, z: 3)
+  t := Cell(..s, z: 30, x: 10)
+  t.x * 10000 + t.y * 100 + t.z
+# moved from e2e_mem::unique_inplace::unique_spread_sets_fields
+test "unique spread sets fields"
+  assert runMain() == 100230

compiler/tests/wasm_codegen/e2e_mem/unique_spread_swap_reads_old_values.plum ADDED Viewed

@@ -0,0 +1,16 @@
+import std/Str
+import std/Int
+import std/Float
+import std/Slice
+struct Cell(x: Int, y: Int)
+fun runMain() -> Int =
+  s := Cell(x: 1, y: 2)
+  t := Cell(..s, x: s.y, y: s.x)
+  t.x * 10 + t.y
+# moved from e2e_mem::unique_inplace::unique_spread_swap_reads_old_values
+# A value reading an already-overwritten field must still see the OLD value.
+test "unique spread swap reads old values"
+  assert runMain() == 21

compiler/tests/wasm_codegen/e2e_records/base_through_embedded_struct.plum ADDED Viewed

@@ -0,0 +1,22 @@
+import std/Str
+import std/Int
+import std/Float
+import std/Slice
+struct Actor(x: Int) =
+  fun go(self) -> Int = 1
+struct Mid(Actor(x), m: Int) =
+  override fun go(self) -> Int = 2 + self.Actor.go()
+struct Top(Mid(x, m), t: Int)
+fun run(a: Actor) -> Int = a.go()
+fun runMain() -> Int =
+  t := Top(x: 1, m: 2, t: 3)
+  run(t) * 10 + t.x
+# moved from e2e_records::record_embed::base_through_embedded_struct
+test "base through embedded struct"
+  assert runMain() == 31

compiler/tests/wasm_codegen/e2e_records/cons_list_length_map_sum.plum ADDED Viewed

@@ -0,0 +1,29 @@
+import std/Str
+import std/Int
+import std/Slice
+enum Link[T] = Nil | Cons(head: T, tail: Link[T])
+fun length[T](xs: Link[T]) -> Int = match xs
+  Nil => 0
+  Cons(_, t) => 1 + length(t)
+fun sum(xs: Link[Int]) -> Int = match xs
+  Nil => 0
+  Cons(h, t) => h + sum(t)
+fun cons[T](h: T, t: Link[T]) -> Link[T] =
+  Cons(head: h, tail: t)
+fun map(xs: Link[Int], f: fn(Int) -> Int) -> Link[Int] = match xs
+  Nil => Nil
+  Cons(h, t) => Cons(head: f(h), tail: map(t, f))
+fun runMain() -> Int =
+  xs := cons(1, cons(2, cons(3, Nil)))
+  ys := map(xs, |n| n * 2)
+  sum(xs) * 100 + sum(ys) + length(ys) * 10000
+# moved from e2e_records::inline_variants::cons_list_length_map_sum
+test "cons list length map sum"
+  assert runMain() == 30612

compiler/tests/wasm_codegen/e2e_records/deep_nested_variant_match.plum ADDED Viewed

@@ -0,0 +1,20 @@
+import std/Str
+import std/Int
+import std/Float
+enum Tree = Leaf(v: Int) | Node(l: Tree, r: Tree)
+fun depthSum(t: Tree, d: Int) -> Int =
+  match t
+    Leaf(v) => v * d
+    Node(l, r) => depthSum(l, d + 1) + depthSum(r, d + 1)
+fun build(n: Int) -> Tree =
+  if n == 0 then Leaf(v: 1) else Node(l: build(n - 1), r: Leaf(v: n))
+fun runMain() -> Int = depthSum(build(5), 1)
+# moved from e2e_records::unboxed_variants::deep_nested_variant_match
+# Leaves: 1 at depth 6, then Leaf(n) at depth 7 - n for n = 1..5.
+test "deep nested variant match"
+  assert runMain() == 56

compiler/tests/wasm_codegen/e2e_records/embedded_record_standalone_and_unselected_set_by_init.plum ADDED Viewed

@@ -0,0 +1,21 @@
+import std/Str
+import std/Int
+import std/Float
+import std/Slice
+struct Stage(camScale: Int, tag: Int) =
+  fun init(self) =
+    self.camX: Int = 6
+struct World(Stage(tag), score: Int) =
+  fun init(self) =
+    self.camScale = 5
+fun runMain() -> Int =
+  s := Stage(camScale: 2, tag: 1)
+  w := World(tag: 3, score: 1)
+  s.camScale * 100 + w.camScale * 10 + w.camX + w.tag + s.camX
+# moved from e2e_records::record_embed::embedded_record_standalone_and_unselected_set_by_init
+test "embedded record standalone and unselected set by init"
+  assert runMain() == 265

compiler/tests/wasm_codegen/e2e_records/empty_init_with_annotation.plum ADDED Viewed

@@ -0,0 +1,24 @@
+import std/Str
+import std/Int
+enum Link[T] =
+  | Nil
+  | Cons(head: T, tail: Link[T])
+  fun init() -> Link[T] = Nil
+  fun length(self) -> Int = match self
+    Nil => 0
+    Cons(_, t) => 1 + t.length()
+  fun sum(self) -> Int = match self
+    Nil => 0
+    Cons(h, t) => h + t.sum()
+fun runMain() -> Int =
+  xs: Link[Int] := Link()
+  xs.length() + 7
+# moved from e2e_records::enum_init::empty_init_with_annotation
+test "empty init with annotation"
+  assert runMain() == 7

compiler/tests/wasm_codegen/e2e_records/enum_init_versus_variant_name.plum ADDED Viewed

@@ -0,0 +1,25 @@
+import std/Str
+import std/Int
+import std/Float
+enum Cell =
+  | Empty
+  | Full(count: Int, label: Str)
+  fun init(n: Int) -> Cell = if n <= 0 then Empty else Full(count: n, label: "n{n}")
+  fun size(self) -> Int =
+    match self
+      Empty => 0
+      Full(c, _) => c
+fun runMain() -> Int =
+  a := Cell(5)
+  b := Cell(0)
+  c := Full(count: 9, label: "nine")
+  d := Full(label: "swapped", count: 2)
+  a.size() * 1000 + b.size() * 100 + c.size() * 10 + d.size()
+# moved from e2e_records::unboxed_variants::enum_init_versus_variant_name
+test "enum init versus variant name"
+  assert runMain() == 5092

compiler/tests/wasm_codegen/e2e_records/equality_is_identity_of_the_variant_value.plum ADDED Viewed

@@ -0,0 +1,17 @@
+import std/Str
+import std/Int
+import std/Float
+enum Shape = Circle(r: Int) | Rect(w: Int, h: Int)
+fun runMain() -> Int =
+  a: Shape := Circle(r: 2)
+  b: Shape := a
+  c: Shape := Rect(w: 1, h: 2)
+  x := if a == b then 1 else 0
+  y := if a != c then 10 else 0
+  x + y
+# moved from e2e_records::unboxed_variants::equality_is_identity_of_the_variant_value
+test "equality is identity of the variant value"
+  assert runMain() == 11

compiler/{wasm-codegen/tests/wasm_codegen/e2e_records/empty_record_embed.rs → tests/wasm_codegen/e2e_records/field_less_struct_embedding_field_less_base_dispatches_in_a_slice.plum} RENAMED Viewed

@@ -1,12 +1,8 @@
+import std/Str
-use plum_test_support::{runInt, PRE};
+import std/Int
+import std/Float
+import std/Slice
-fn prog(body: &str) -> String {
-    format!("{PRE}{body}")
-}
-#[test]
-fn field_less_struct_embedding_field_less_base_dispatches_in_a_slice() {
-    let src = prog("\
 struct Actor() =
   fun act(self, n: Int) -> Int = n
   fun draw(self) -> Int = 1
@@ -18,7 +14,7 @@ struct Ship(Actor, speed: Int) =
   override fun act(self, n: Int) -> Int = n + self.speed
   override fun draw(self) -> Int = 100
-fun main() -> Int =
+fun runMain() -> Int =
   xs: Slice[Actor] := Slice[Actor]()
   xs.push(Panel())
   xs.push(Ship(speed: 5))
@@ -26,7 +22,8 @@ fun main() -> Int =
   for i := range 2
     total = total + xs.at(i).draw() + xs.at(i).act(1000)
   total
-");
+# moved from e2e_records::empty_record_embed::field_less_struct_embedding_field_less_base_dispatches_in_a_slice
-    // Panel: draw 10 + act 1000; Ship: draw 100 + act 1005.
+# Panel: draw 10 + act 1000; Ship: draw 100 + act 1005.
+test "field less struct embedding field less base dispatches in a slice"
-    assert_eq!(runInt("slice", &src), 2115);
+  assert runMain() == 2115
-}

compiler/tests/wasm_codegen/e2e_records/fixed_param_init.plum ADDED Viewed

@@ -0,0 +1,19 @@
+import std/Str
+import std/Int
+enum Pair2 =
+  | Zero
+  | Two(a: Int, b: Int)
+  fun init(a: Int, b: Int) -> Pair2 = Two(a: a, b: b)
+  fun total(self) -> Int = match self
+    Zero => 0
+    Two(a, b) => a + b
+fun runMain() -> Int =
+  Pair2(3, 4).total()
+# moved from e2e_records::enum_init::fixed_param_init
+test "fixed param init"
+  assert runMain() == 7

compiler/tests/wasm_codegen/e2e_records/fresh_list_per_construction.plum ADDED Viewed

@@ -0,0 +1,27 @@
+import std/Str
+import std/Int
+import std/Float
+import std/Slice
+struct Actor(px: Int, py: Int) =
+  fun init(self) =
+    self.width: Int = 10
+    self.height: Int = self.width * 2
+    self.kids: Slice[Int] = Slice[Int]()
+  fun area(self) -> Int = self.width * self.height
+struct Ship(Actor(px, py)) =
+  fun init(self) =
+    self.vx = 0
+fun runMain() -> Int =
+  a := Ship(px: 0, py: 0)
+  b := Ship(px: 0, py: 0)
+  a.kids.push(1)
+  a.kids.push(2)
+  b.kids.push(9)
+  a.kids.length() * 10 + b.kids.length()
+# moved from e2e_records::record_init::fresh_list_per_construction
+test "fresh list per construction"
+  assert runMain() == 21

compiler/tests/wasm_codegen/e2e_records/generic_inferred_from_args.plum ADDED Viewed

@@ -0,0 +1,25 @@
+import std/Str
+import std/Int
+enum Link[T] =
+  | Nil
+  | Cons(head: T, tail: Link[T])
+  fun init(a: T, b: T) -> Link[T] = Cons(head: a, tail: Cons(head: b, tail: Nil))
+  fun length(self) -> Int = match self
+    Nil => 0
+    Cons(_, t) => 1 + t.length()
+  fun sum(self) -> Int = match self
+    Nil => 0
+    Cons(h, t) => h + t.sum()
+fun total(xs: Link[Int]) -> Int = xs.sum()
+fun runMain() -> Int =
+  total(Link(5, 6)) + Link("a", "b").length()
+# moved from e2e_records::enum_init::generic_inferred_from_args
+test "generic inferred from args"
+  assert runMain() == 13

compiler/tests/wasm_codegen/e2e_records/inherited_fields_methods_and_init_order.plum ADDED Viewed

@@ -0,0 +1,26 @@
+import std/Str
+import std/Int
+import std/Float
+import std/Slice
+struct Stage(camScale: Int) =
+  fun init(self) =
+    self.root: Int = 10
+    self.camX: Int = self.camScale * 2
+  fun act(self, dt: Int) -> Int = self.root + dt
+  fun draw(self) -> Int = 100
+struct World(Stage(camScale), score: Int) =
+  fun init(self) =
+    self.best: Int = self.root + self.camX + 1
+fun runMain() -> Int =
+  w := World(camScale: 3, score: 4)
+  w.camScale + w.root * 10 + w.camX * 100 + w.score * 1000 + w.best * 10000 + w.act(5) * 100000
+# moved from e2e_records::record_embed::inherited_fields_methods_and_init_order
+# camScale 3, root 10, camX 6, score 4, best 17, act(5) = 15
+test "inherited fields methods and init order"
+  assert runMain() == 1674703

compiler/tests/wasm_codegen/e2e_records/match_variant_fields.plum ADDED Viewed

@@ -0,0 +1,17 @@
+import std/Str
+import std/Int
+import std/Float
+enum Shape = Circle(r: Int) | Rect(w: Int, h: Int)
+fun area(s: Shape) -> Int =
+  match s
+    Circle(r) => r * r
+    Rect(w, h) => w * h
+fun runMain() -> Int =
+  area(Circle(r: 3)) * 100 + area(Rect(w: 2, h: 5))
+# moved from e2e_records::unboxed_variants::match_variant_fields
+test "match variant fields"
+  assert runMain() == 910

compiler/tests/wasm_codegen/e2e_records/million_cells_built_and_mapped_in_constant_stack.plum ADDED Viewed

@@ -0,0 +1,24 @@
+import std/Str
+import std/Int
+import std/Float
+enum Link = End | Duo(head: Int, tail: Link)
+fun upTo(n: Int) -> Link =
+  if n == 0 then End else Duo(head: n, tail: upTo(n - 1))
+fun inc(xs: Link) -> Link =
+  match xs
+    End => End
+    Duo(h, t) => Duo(head: h + 1, tail: inc(t))
+fun sum(xs: Link, acc: Int) -> Int =
+  match xs
+    End => acc
+    Duo(h, t) => sum(t, acc + h)
+fun runMain() -> Int = sum(inc(upTo(1000000)), 0)
+# moved from e2e_records::unboxed_variants::million_cells_built_and_mapped_in_constant_stack
+test "million cells built and mapped in constant stack"
+  assert runMain() == 500001500000

compiler/tests/wasm_codegen/e2e_records/nested_enum_match.plum ADDED Viewed

@@ -0,0 +1,23 @@
+import std/Str
+import std/Int
+import std/Float
+enum Link[T] = End | Duo(head: T, tail: Link[T])
+fun sum(l: Link[Int]) -> Int =
+  match l
+    End => 0
+    Duo(head, tail) => head + sum(tail)
+fun second(l: Link[Int]) -> Int =
+  match l
+    Duo(_, Duo(h, _)) => h
+    _ => -1
+fun runMain() -> Int =
+  l: Link[Int] := Duo(head: 1, tail: Duo(head: 20, tail: Duo(head: 300, tail: End)))
+  sum(l) * 1000 + second(l)
+# moved from e2e_records::unboxed_variants::nested_enum_match
+test "nested enum match"
+  assert runMain() == 321020

compiler/tests/wasm_codegen/e2e_records/nested_literal_construction.plum ADDED Viewed

@@ -0,0 +1,28 @@
+import std/Str
+import std/Int
+import std/Slice
+enum Link[T] = Nil | Cons(head: T, tail: Link[T])
+fun length[T](xs: Link[T]) -> Int = match xs
+  Nil => 0
+  Cons(_, t) => 1 + length(t)
+fun sum(xs: Link[Int]) -> Int = match xs
+  Nil => 0
+  Cons(h, t) => h + sum(t)
+fun cons[T](h: T, t: Link[T]) -> Link[T] =
+  Cons(head: h, tail: t)
+fun map(xs: Link[Int], f: fn(Int) -> Int) -> Link[Int] = match xs
+  Nil => Nil
+  Cons(h, t) => Cons(head: f(h), tail: map(t, f))
+fun runMain() -> Int =
+  xs := Cons(head: 1, tail: Cons(head: 2, tail: Cons(head: 3, tail: Nil)))
+  sum(xs)
+# moved from e2e_records::inline_variants::nested_literal_construction
+test "nested literal construction"
+  assert runMain() == 6

compiler/tests/wasm_codegen/e2e_records/override_calls_original.plum ADDED Viewed

@@ -0,0 +1,24 @@
+import std/Str
+import std/Int
+import std/Float
+import std/Slice
+struct Stage(camScale: Int) =
+  fun init(self) =
+    self.root: Int = 10
+    self.camX: Int = self.camScale * 2
+  fun act(self, dt: Int) -> Int = self.root + dt
+  fun draw(self) -> Int = 100
+struct World(Stage(camScale), score: Int) =
+  override fun draw(self) -> Int = self.Stage.draw() + self.score
+fun runMain() -> Int =
+  w := World(camScale: 1, score: 7)
+  w.draw() * 10 + w.act(1)
+# moved from e2e_records::record_embed::override_calls_original
+test "override calls original"
+  assert runMain() == 1081

compiler/tests/wasm_codegen/e2e_records/reassign_enum_local_across_variants.plum ADDED Viewed

@@ -0,0 +1,33 @@
+import std/Str
+import std/Int
+import std/Float
+enum Shape = Circle(r: Int) | Rect(w: Int, h: Int)
+fun area(s: Shape) -> Int =
+  match s
+    Circle(r) => r * 3
+    Rect(w, h) => w * h
+fun kind(s: Shape) -> Int =
+  match s
+    Circle(_) => 1
+    Rect(_, _) => 10
+fun runMain() -> Int =
+  s: Shape := Circle(r: 1)
+  n := area(s)
+  s = Rect(w: 2, h: 5)
+  n = n * 100 + area(s)
+  k := 0
+  for i := range 4
+    if i % 2 == 0
+      s = Rect(w: 1, h: 1)
+    else
+      s = Circle(r: 1)
+    k = k + kind(s)
+  n * 100 + k
+# moved from e2e_records::unboxed_variants::reassign_enum_local_across_variants
+test "reassign enum local across variants"
+  assert runMain() == 31022

compiler/tests/wasm_codegen/e2e_records/rest_runs_after_build_and_nested_construction.plum ADDED Viewed

@@ -0,0 +1,22 @@
+import std/Str
+import std/Int
+import std/Float
+import std/Slice
+struct Inner(mut n: Int)
+struct Outer(a: Int) =
+  fun init(self) =
+    self.inner = Inner(n: self.a + 1)
+    self.total = 0
+    self.bump()
+  fun bump(self) =
+    self.inner.n = self.inner.n * 10
+fun runMain() -> Int =
+  o := Outer(a: 4)
+  o.inner.n + o.a
+# moved from e2e_records::record_init::rest_runs_after_build_and_nested_construction
+test "rest runs after build and nested construction"
+  assert runMain() == 54

compiler/tests/wasm_codegen/e2e_records/ship_example_values.plum ADDED Viewed

@@ -0,0 +1,26 @@
+import std/Str
+import std/Int
+import std/Float
+import std/Slice
+struct Actor(px: Int, py: Int) =
+  fun init(self) =
+    self.width: Int = 10
+    self.height: Int = self.width * 2
+    self.kids: Slice[Int] = Slice[Int]()
+  fun area(self) -> Int = self.width * self.height
+struct Ship(Actor(px, py), tex: Int) =
+  fun init(self) =
+    self.height = self.width + 1
+    self.vx = 7
+  override fun area(self) -> Int = self.width * self.height + self.vx
+fun runMain() -> Int =
+  s := Ship(px: 1, py: 2, tex: 3)
+  s.px + s.py * 10 + s.tex * 100 + s.area() * 1000
+# moved from e2e_records::record_init::ship_example_values
+# px 1 + py 20 + tex 300 + (10*11+7)*1000
+test "ship example values"
+  assert runMain() == 117321

compiler/tests/wasm_codegen/e2e_records/through_a_base_value.plum ADDED Viewed

@@ -0,0 +1,24 @@
+import std/Str
+import std/Int
+import std/Float
+import std/Slice
+struct Actor(px: Int, width: Int) =
+  fun init(self) =
+    self.width = 10
+  fun area(self) -> Int = self.width * 2
+struct Ship(Actor(px), tex: Int) =
+  override fun area(self) -> Int = self.width * 20
+struct Rock(Actor(px))
+fun total(a: Actor) -> Int = a.area() + a.px
+fun runMain() -> Int =
+  total(Ship(px: 1, tex: 0)) * 1000 + total(Rock(px: 2))
+# moved from e2e_records::record_init::through_a_base_value
+# Ship: 10*20 + 1 = 201 ; Rock: 20 + 2 = 22
+test "through a base value"
+  assert runMain() == 201022

compiler/tests/wasm_codegen/e2e_records/tree_insert_and_size.plum ADDED Viewed

@@ -0,0 +1,20 @@
+import std/Str
+import std/Int
+enum Tree[T] = Empty | Leaf(v: Int) | Node(l: Tree[T], r: Tree[T])
+fun size[T](t: Tree[T]) -> Int = match t
+  Empty => 0
+  Leaf(_) => 1
+  Node(l, r) => size(l) + size(r)
+fun lf() -> Tree[Str] =
+  Leaf(v: 3)
+fun runMain() -> Int =
+  t := Node(l: lf(), r: Node(l: lf(), r: Empty))
+  size(t)
+# moved from e2e_records::inline_variants::tree_insert_and_size
+test "tree insert and size"
+  assert runMain() == 2

compiler/tests/wasm_codegen/e2e_records/variant_name_wins.plum ADDED Viewed

@@ -0,0 +1,24 @@
+import std/Str
+import std/Int
+enum Link[T] =
+  | Nil
+  | Cons(head: T, tail: Link[T])
+  fun init(a: T, b: T) -> Link[T] = Cons(head: a, tail: Cons(head: b, tail: Nil))
+  fun length(self) -> Int = match self
+    Nil => 0
+    Cons(_, t) => 1 + t.length()
+  fun sum(self) -> Int = match self
+    Nil => 0
+    Cons(h, t) => h + t.sum()
+fun runMain() -> Int =
+  xs := Cons(head: 5, tail: Link(1, 2))
+  xs.sum() * 10 + xs.length()
+# moved from e2e_records::enum_init::variant_name_wins
+test "variant name wins"
+  assert runMain() == 83

compiler/tests/wasm_codegen/e2e_tail/big_link_built_and_summed.plum ADDED Viewed

@@ -0,0 +1,17 @@
+import std/Int
+enum Link =
+  | Nil
+  | Cons(head: Int, tail: Link)
+fun build(n: Int, acc: Link) -> Link = if n == 0 then acc else build(n - 1, Cons(n, acc))
+fun sum(l: Link, acc: Int) -> Int = match l
+  Nil => acc
+  Cons(h, t) => sum(t, acc + h)
+fun runMain() -> Int = sum(build(200000, Nil), 0)
+# moved from e2e_tail::tail::big_link_built_and_summed
+test "big link built and summed"
+  assert runMain() == 20000100000

compiler/tests/wasm_codegen/e2e_tail/break_in_else_if_chain_in_while.plum ADDED Viewed

@@ -0,0 +1,20 @@
+import std/Str
+import std/Int
+import std/Float
+import std/Slice
+fun runMain() -> Int =
+  i := 0
+  while i < 50
+    if i == 100
+      i = i + 1000
+    else if i == 100
+      i = i + 2000
+    else if i == 7
+      break
+    i = i + 1
+  return i
+# moved from e2e_tail::loop_break::break_in_else_if_chain_in_while
+test "break in else if chain in while"
+  assert runMain() == 7

compiler/tests/wasm_codegen/e2e_tail/break_in_if_in_match_arm_in_while.plum ADDED Viewed

@@ -0,0 +1,30 @@
+import std/Str
+import std/Int
+import std/Float
+import std/Slice
+enum Lst = Nil | Cons(head: Int, tail: Lst)
+fun build(n: Int, acc: Lst) -> Lst =
+  if n == 0 then acc else build(n - 1, Cons(head: n, tail: acc))
+fun find(xs: Lst, target: Int) -> Int =
+  i := 0
+  cur := xs
+  while i < 50
+    match cur
+      Cons(h, t) =>
+        if h == target
+          break
+        cur = t
+      Nil =>
+        break
+    i = i + 1
+  return i
+fun runMain() -> Int = find(build(10, Nil), 4) * 100 + find(build(10, Nil), 99)
+# moved from e2e_tail::loop_break::break_in_if_in_match_arm_in_while
+test "break in if in match arm in while"
+  assert runMain() == 310

compiler/tests/wasm_codegen/e2e_tail/break_in_match_arm_direct.plum ADDED Viewed

@@ -0,0 +1,37 @@
+import std/Str
+import std/Int
+import std/Float
+import std/Slice
+enum Lst = Nil | Cons(head: Int, tail: Lst)
+fun build(n: Int, acc: Lst) -> Lst =
+  if n == 0 then acc else build(n - 1, Cons(head: n, tail: acc))
+fun count(xs: Lst) -> Int =
+  i := 0
+  cur := xs
+  while i < 50
+    match cur
+      Nil =>
+        break
+      Cons(h, t) =>
+        cur = t
+    i = i + 1
+  return i
+fun wild(n: Int) -> Int =
+  i := 0
+  while i < 50
+    match i
+      _ =>
+        break
+    i = i + 1
+  return i + n
+fun runMain() -> Int = count(build(5, Nil)) * 100 + wild(7)
+# moved from e2e_tail::loop_break::break_in_match_arm_direct
+test "break in match arm direct"
+  assert runMain() == 507

compiler/tests/wasm_codegen/e2e_tail/closure_body_tail_call_million.plum ADDED Viewed

@@ -0,0 +1,12 @@
+import std/Int
+fun countDown(n: Int) -> Int = if n == 0 then 0 else countDown(n - 1)
+fun runMain() -> Int =
+  dec := |n: Int| if n == 0 then 7 else countDown(n - 1) + 0
+  fin := |n: Int| countDown(n)
+  fin(1000000) + dec(0)
+# moved from e2e_tail::closure_tail::closure_body_tail_call_million
+test "closure body tail call million"
+  assert runMain() == 7

compiler/tests/wasm_codegen/e2e_tail/closure_captures_iteration_value.plum ADDED Viewed

@@ -0,0 +1,14 @@
+import std/Str
+import std/Int
+import std/Float
+import std/Slice
+fun go(i: Int, f: fn(Int) -> Int) -> Int =
+  if i == 3 then f(100) else go(i + 1, |x| x + i)
+fun runMain() -> Int = go(0, |x| x)
+# moved from e2e_tail::tail::closure_captures_iteration_value
+# R3: a closure made in one iteration keeps that iteration's parameter value.
+test "closure captures iteration value"
+  assert runMain() == 102

compiler/tests/wasm_codegen/e2e_tail/closure_not_recursive_unchanged.plum ADDED Viewed

@@ -0,0 +1,10 @@
+import std/Int
+fun runMain() -> Int =
+  k := 10
+  f := |x| x + k
+  f(5)
+# moved from e2e_tail::closure_tail::closure_not_recursive_unchanged
+test "closure not recursive unchanged"
+  assert runMain() == 15

compiler/tests/wasm_codegen/e2e_tail/closure_tail_call_runs.plum ADDED Viewed

@@ -0,0 +1,14 @@
+import std/Str
+import std/Int
+import std/Float
+import std/Slice
+fun run(n: Int, k: fn(Int) -> Int) -> Int = if n == 0 then 7 else k(n - 1)
+fun go(n: Int) -> Int = run(n, go)
+fun runMain() -> Int = go(1000000)
+# moved from e2e_tail::tail::closure_tail_call_runs
+test "closure tail call runs"
+  assert runMain() == 7

compiler/tests/wasm_codegen/e2e_tail/continue_in_if_in_match_arm_in_while.plum ADDED Viewed

@@ -0,0 +1,33 @@
+import std/Str
+import std/Int
+import std/Float
+import std/Slice
+enum Lst = Nil | Cons(head: Int, tail: Lst)
+fun build(n: Int, acc: Lst) -> Lst =
+  if n == 0 then acc else build(n - 1, Cons(head: n, tail: acc))
+fun sumOdd(xs: Lst) -> Int =
+  total := 0
+  i := 0
+  cur := xs
+  while i < 50
+    i = i + 1
+    match cur
+      Cons(h, t) =>
+        cur = t
+        if h % 2 == 0
+          continue
+        total = total + h
+      Nil =>
+        break
+  return total * 100 + i
+fun runMain() -> Int = sumOdd(build(6, Nil))
+# moved from e2e_tail::loop_break::continue_in_if_in_match_arm_in_while
+# 1 + 3 + 5 = 9; seven iterations (six cons cells then Nil).
+test "continue in if in match arm in while"
+  assert runMain() == 907

compiler/tests/wasm_codegen/e2e_tail/method_self_tail.plum ADDED Viewed

@@ -0,0 +1,14 @@
+import std/Str
+import std/Int
+import std/Float
+import std/Slice
+struct Counter(step: Int) =
+  fun count(self, n: Int, acc: Int) -> Int =
+    if n == 0 then acc else self.count(n - 1, acc + self.step)
+fun runMain() -> Int = Counter(step: 3).count(1000000, 0)
+# moved from e2e_tail::tail::method_self_tail
+test "method self tail"
+  assert runMain() == 3000000

compiler/tests/wasm_codegen/e2e_tail/mutual_tail_million.plum ADDED Viewed

@@ -0,0 +1,14 @@
+import std/Str
+import std/Int
+import std/Float
+import std/Slice
+fun isEven(n: Int) -> Int = if n == 0 then 1 else isOdd(n - 1)
+fun isOdd(n: Int) -> Int = if n == 0 then 0 else isEven(n - 1)
+fun runMain() -> Int = isEven(1000001) * 10 + isOdd(1000001)
+# moved from e2e_tail::tail::mutual_tail_million
+test "mutual tail million"
+  assert runMain() == 1

compiler/tests/wasm_codegen/e2e_tail/nested_loops_with_match_in_inner.plum ADDED Viewed

@@ -0,0 +1,39 @@
+import std/Str
+import std/Int
+import std/Float
+import std/Slice
+enum Lst = Nil | Cons(head: Int, tail: Lst)
+fun build(n: Int, acc: Lst) -> Lst =
+  if n == 0 then acc else build(n - 1, Cons(head: n, tail: acc))
+fun runMain() -> Int =
+  outer := 0
+  hits := 0
+  while outer < 50
+    if outer == 3
+      break
+    cur := build(5, Nil)
+    j := 0
+    while j < 50
+      match cur
+        Cons(h, t) =>
+          cur = t
+          if h == 2
+            j = j + 1
+            continue
+          if h == 4
+            break
+          hits = hits + 1
+        Nil =>
+          break
+      j = j + 1
+    outer = outer + 1
+  return outer * 100 + hits
+# moved from e2e_tail::loop_break::nested_loops_with_match_in_inner
+# inner: h=1 hit, h=2 skipped, h=3 hit, h=4 break => 2 hits per outer pass, 3 passes.
+test "nested loops with match in inner"
+  assert runMain() == 306

compiler/tests/wasm_codegen/e2e_tail/non_tail_union_wrap_not_tail.plum ADDED Viewed

@@ -0,0 +1,17 @@
+import std/Int
+import std/Option
+fun inner(n: Int) -> Int = n + 1
+fun outer(n: Int) -> Option[Int] = Some(inner(n))
+fun runMain() -> Int =
+  v := outer(41)
+  v.unwrapOr(0)
+# moved from e2e_tail::tail::non_tail_union_wrap_not_tail
+# The callee returns Int but the fn returns Option[Int]: the call is wrapped on the way
+# out, so it must stay a normal call and still produce the right value.
+test "non tail union wrap not tail"
+  assert runMain() == 42

compiler/tests/wasm_codegen/e2e_tail/param_self_tail.plum ADDED Viewed

@@ -0,0 +1,17 @@
+import std/Str
+import std/Int
+import std/Float
+import std/Slice
+struct Cell(x: Int, y: Int)
+fun bump(c: Cell, n: Int) -> Cell =
+  if n == 0 then c else bump(Cell(..c, x: c.x + 1), n - 1)
+fun runMain() -> Int =
+  c := bump(Cell(x: 0, y: 5), 100000)
+  c.x * 10 + c.y
+# moved from e2e_tail::tail::param_self_tail
+test "param self tail"
+  assert runMain() == 1000005

compiler/tests/wasm_codegen/e2e_tail/question_in_tail_not_tail_call.plum ADDED Viewed

@@ -0,0 +1,16 @@
+import std/Int
+import std/Result
+enum NegError = Neg | Other
+fun down(n: Int) -> Result[Int, NegError] =
+  if n == 0
+    return Ok(5)
+  v := down(n - 1)?
+  Ok(v)
+fun runMain() -> Int = down(100).unwrapOr(99)
+# moved from e2e_tail::error_tail::question_in_tail_not_tail_call
+test "question in tail not tail call"
+  assert runMain() == 5

compiler/tests/wasm_codegen/e2e_tail/recursive_closure_captures_outer.plum ADDED Viewed

@@ -0,0 +1,10 @@
+import std/Int
+fun runMain() -> Int =
+  k := 3
+  go := |n, acc| if n == 0 then acc else go(n - 1, acc + k)
+  go(1000000, 0)
+# moved from e2e_tail::closure_tail::recursive_closure_captures_outer
+test "recursive closure captures outer"
+  assert runMain() == 3000000

compiler/tests/wasm_codegen/e2e_tail/recursive_local_closure_million.plum ADDED Viewed

@@ -0,0 +1,9 @@
+import std/Int
+fun runMain() -> Int =
+  go := |n, acc| if n == 0 then acc else go(n - 1, acc + n)
+  go(1000000, 0)
+# moved from e2e_tail::closure_tail::recursive_local_closure_million
+test "recursive local closure million"
+  assert runMain() == 500000500000

compiler/tests/wasm_codegen/e2e_tail/result_mutual_million.plum ADDED Viewed

@@ -0,0 +1,20 @@
+import std/Int
+import std/Result
+enum NegError = Neg | Other
+fun ping(n: Int) -> Result[Int, NegError] =
+  if n == 0
+    return Ok(1)
+  pong(n - 1)
+fun pong(n: Int) -> Result[Int, NegError] =
+  if n == 0
+    return Ok(2)
+  ping(n - 1)
+fun runMain() -> Int = ping(1000000).unwrapOr(99)
+# moved from e2e_tail::error_tail::result_mutual_million
+test "result mutual million"
+  assert runMain() == 1

compiler/tests/wasm_codegen/e2e_tail/result_self_loop_million.plum ADDED Viewed

@@ -0,0 +1,17 @@
+import std/Int
+import std/Result
+enum NegError = Neg | Other
+fun down(n: Int) -> Result[Int, NegError] =
+  if n < 0
+    return Err(Neg)
+  if n == 0
+    return Ok(5)
+  down(n - 1)
+fun runMain() -> Int = down(1000000).unwrapOr(99)
+# moved from e2e_tail::error_tail::result_self_loop_million
+test "result self loop million"
+  assert runMain() == 5

compiler/tests/wasm_codegen/e2e_tail/result_self_loop_returns_err.plum ADDED Viewed

@@ -0,0 +1,15 @@
+import std/Int
+import std/Result
+enum NegError = Neg | Other
+fun down(n: Int) -> Result[Int, NegError] =
+  if n == 0
+    return Err(Neg)
+  down(n - 1)
+fun runMain() -> Int = down(1000000).unwrapOr(42)
+# moved from e2e_tail::error_tail::result_self_loop_returns_err
+test "result self loop returns err"
+  assert runMain() == 42

compiler/tests/wasm_codegen/e2e_tail/self_calling_closure_typed_params_runs.plum ADDED Viewed

@@ -0,0 +1,9 @@
+import std/Int
+fun runMain() -> Int =
+  fact := |n: Int| if n <= 1 then 1 else n * fact(n - 1)
+  fact(5)
+# moved from e2e_tail::closure_tail::self_calling_closure_typed_params_runs
+test "self calling closure typed params runs"
+  assert runMain() == 120

compiler/tests/wasm_codegen/e2e_tail/self_calling_closure_untyped_params_runs.plum ADDED Viewed

@@ -0,0 +1,9 @@
+import std/Int
+fun runMain() -> Int =
+  fact := |n| if n <= 1 then 1 else n * fact(n - 1)
+  fact(5)
+# moved from e2e_tail::closure_tail::self_calling_closure_untyped_params_runs
+test "self calling closure untyped params runs"
+  assert runMain() == 120

compiler/tests/wasm_codegen/e2e_tail/self_tail_args_swap.plum ADDED Viewed

@@ -0,0 +1,16 @@
+import std/Str
+import std/Int
+import std/Float
+import std/Slice
+fun gcd(a: Int, b: Int) -> Int = if b == 0 then a else gcd(b, a % b)
+fun swapN(a: Int, b: Int, n: Int) -> Int =
+  if n == 0 then a * 1000 + b else swapN(b, a, n - 1)
+fun runMain() -> Int = gcd(1071, 462) * 1000000 + swapN(1, 2, 999999)
+# moved from e2e_tail::tail::self_tail_args_swap
+# gcd = 21; odd swap count leaves (2, 1).
+test "self tail args swap"
+  assert runMain() == 21002001

compiler/tests/wasm_codegen/e2e_tail/self_tail_million.plum ADDED Viewed

@@ -0,0 +1,20 @@
+import std/Str
+import std/Int
+import std/Float
+import std/Slice
+enum Link[T] = Nil | Cons(head: T, tail: Link[T])
+fun build(n: Int, acc: Link[Int]) -> Link[Int] =
+  if n == 0 then acc else build(n - 1, Cons(head: n, tail: acc))
+fun sumAcc(xs: Link[Int], acc: Int) -> Int = match xs
+  Nil => acc
+  Cons(h, t) => sumAcc(t, acc + h)
+fun runMain() -> Int = sumAcc(build(1000000, Nil), 0)
+# moved from e2e_tail::tail::self_tail_million
+test "self tail million"
+  assert runMain() == 500000500000

compiler/tests/wasm_codegen/e2e_tail/self_tail_through_nested_branches.plum ADDED Viewed

@@ -0,0 +1,21 @@
+import std/Str
+import std/Int
+import std/Float
+import std/Slice
+fun f(n: Int, acc: Int) -> Int =
+  if n == 0 then acc
+  else if n % 3 == 0 then f(n - 1, acc + 1)
+  else if n % 3 == 1 then f(n - 1, acc + 10)
+  else f(n - 1, acc + 100)
+fun g(n: Int, acc: Int) -> Int = match n
+  0 => acc
+  k => if k % 2 == 0 then g(k - 1, acc + 2) else g(k - 1, acc + 1)
+fun runMain() -> Int = f(30, 0) * 1000 + g(10, 0)
+# moved from e2e_tail::tail::self_tail_through_nested_branches
+# Match arms and else-if chains nest wasm blocks between the call and the loop.
+test "self tail through nested branches"
+  assert runMain() == 1110015

compiler/tests/wasm_codegen/e2e_tail/tail_call_in_match_arm.plum ADDED Viewed

@@ -0,0 +1,15 @@
+import std/Int
+enum Step =
+  | Go(n: Int)
+  | Stop
+fun run(s: Step, acc: Int) -> Int = match s
+  Go(n) => run(if n == 0 then Stop else Go(n - 1), acc + 1)
+  Stop => acc
+fun runMain() -> Int = run(Go(1000000), 0)
+# moved from e2e_tail::tail::tail_call_in_match_arm
+test "tail call in match arm"
+  assert runMain() == 1000001

compiler/tests/wasm_codegen/e2e_tail/trmc_link_map_100k.plum ADDED Viewed

@@ -0,0 +1,25 @@
+import std/Str
+import std/Int
+import std/Float
+import std/Slice
+enum Link[T] = Nil | Cons(head: T, tail: Link[T])
+fun build(n: Int, acc: Link[Int]) -> Link[Int] =
+  if n == 0 then acc else build(n - 1, Cons(head: n, tail: acc))
+fun sumAcc(xs: Link[Int], acc: Int) -> Int = match xs
+  Nil => acc
+  Cons(h, t) => sumAcc(t, acc + h)
+fun mapInc(xs: Link[Int]) -> Link[Int] = match xs
+  Nil => Nil
+  Cons(h, t) => Cons(head: h + 1, tail: mapInc(t))
+fun runMain() -> Int = sumAcc(mapInc(build(100000, Nil)), 0)
+# moved from e2e_tail::tail::trmc_link_map_100k
+# TRMC: a map over a native-variant list of 100k elements builds without stack growth.
+test "trmc link map 100k"
+  assert runMain() == 5000150000

compiler/tests/wasm_codegen/e2e_types/adder_two_levels.plum ADDED Viewed

@@ -0,0 +1,14 @@
+import std/Int
+fun adder(n: Int) -> fn(Int) -> fn(Int) -> Int =
+  |x| |y| x + y + n
+fun runMain() -> Int =
+  f := adder(1)
+  g := f(2)
+  g(3)
+# moved from e2e_types::closure_types::adder_two_levels
+# `adder(1)(2)` (call on a call result) does not parse: the grammar has no call-on-call form.
+test "adder two levels"
+  assert runMain() == 6

compiler/tests/wasm_codegen/e2e_types/bang_unwraps_and_chains.plum ADDED Viewed

@@ -0,0 +1,17 @@
+import std/Int
+import std/Option
+import std/Result
+struct Pt(first: Int, second: Int)
+fun g(n: Int) -> Option[Pt] = Some(Pt(first: n, second: 2))
+fun runMain() -> Int =
+  x := Some(3)!
+  y := g(4)!.first
+  r: Result[Int, Int] := Ok(5)
+  x + y * 10 + r! * 100
+# moved from e2e_types::question::bang_unwraps_and_chains
+test "bang unwraps and chains"
+  assert runMain() == 543

compiler/tests/wasm_codegen/e2e_types/bare_tag_fixed_by_later_arg.plum ADDED Viewed

@@ -0,0 +1,17 @@
+import std/Int
+enum Link[T] = Nil | Cons(head: T, tail: Link[T])
+fun len[T](xs: Link[T]) -> Int = match xs
+  Nil => 0
+  Cons(_, t) => 1 + len(t)
+fun push[T](xs: Link[T], x: T) -> Link[T] = Cons(head: x, tail: xs)
+fun runMain() -> Int =
+  len(push(push(Nil, 1), 2))
+# moved from e2e_types::closure_types::bare_tag_fixed_by_later_arg
+# A bare `Nil` whose `T` is fixed by a LATER argument gets the call's `Link[Int]`.
+test "bare tag fixed by later arg"
+  assert runMain() == 2

compiler/tests/wasm_codegen/e2e_types/bare_tag_fixed_by_other_link_arg.plum ADDED Viewed

@@ -0,0 +1,18 @@
+import std/Int
+enum Link[T] = Nil | Cons(head: T, tail: Link[T])
+fun len[T](xs: Link[T]) -> Int = match xs
+  Nil => 0
+  Cons(_, t) => 1 + len(t)
+fun two[T](a: Link[T], b: Link[T]) -> Int = len(a) + len(b)
+fun mk(n: Int) -> Link[Int] = Cons(head: n, tail: Nil)
+fun runMain() -> Int =
+  two(Nil, mk(2)) * 10 + two(mk(1), Nil)
+# moved from e2e_types::closure_types::bare_tag_fixed_by_other_link_arg
+test "bare tag fixed by other link arg"
+  assert runMain() == 11

compiler/tests/wasm_codegen/e2e_types/bare_variants_in_if_branches_take_fn_return_type.plum ADDED Viewed

@@ -0,0 +1,26 @@
+import std/Int
+import std/Option
+import std/Result
+struct Pt(first: Int, second: Int)
+fun pickInline(flag: Bool, n: Int) -> Result[Int, Int] = if flag then Ok(n) else Err(100 + n)
+fun pickBlock(flag: Bool, n: Int) -> Result[Int, Int] =
+  if flag
+    Ok(n)
+  else
+    Err(100 + n)
+fun maybe(flag: Bool, n: Int) -> Option[Int] = if flag then None else Some(n)
+fun runMain() -> Int =
+  a := pickInline(false, 1).isErr()
+  b := pickBlock(true, 2).unwrapOr(0)
+  c := maybe(false, 3).unwrapOr(0)
+  d := maybe(true, 3).isNone()
+  if a && d then b * 10 + c else -1
+# moved from e2e_types::question::bare_variants_in_if_branches_take_fn_return_type
+test "bare variants in if branches take fn return type"
+  assert runMain() == 23

compiler/tests/wasm_codegen/e2e_types/bare_variants_in_match_arms_take_fn_return_type.plum ADDED Viewed

@@ -0,0 +1,18 @@
+import std/Int
+import std/Option
+import std/Result
+struct Pt(first: Int, second: Int)
+fun pick(n: Int) -> Result[Int, Int] = match n
+  0 => Err(100)
+  _ => Ok(n)
+fun runMain() -> Int =
+  match pick(0)
+    Ok(v) => v
+    Err(e) => e + pick(4).unwrapOr(0)
+# moved from e2e_types::question::bare_variants_in_match_arms_take_fn_return_type
+test "bare variants in match arms take fn return type"
+  assert runMain() == 104

compiler/tests/wasm_codegen/e2e_types/chained_err_value_is_first.plum ADDED Viewed

@@ -0,0 +1,25 @@
+import std/Int
+import std/Option
+import std/Result
+struct Pt(first: Int, second: Int)
+fun pick(n: Int) -> Result[Int, Int] =
+  if n > 0
+    return Ok(n)
+  Err(100 + n)
+fun f(x: Int, y: Int, z: Int) -> Result[Int, Int] =
+  p := pick(x)?
+  q := pick(y)?
+  r := pick(z)?
+  Ok(p + q + r)
+fun runMain() -> Int =
+  match f(1, -5, -7)
+    Ok(v) => v
+    Err(e) => e
+# moved from e2e_types::question::chained_err_value_is_first
+test "chained err value is first"
+  assert runMain() == 95

compiler/tests/wasm_codegen/e2e_types/chained_question_returns_first_err.plum ADDED Viewed

@@ -0,0 +1,26 @@
+import std/Int
+import std/Option
+import std/Result
+struct Pt(first: Int, second: Int)
+fun pick(n: Int) -> Result[Int, Int] =
+  if n > 0
+    return Ok(n)
+  Err(100 + n)
+fun f(x: Int, y: Int, z: Int) -> Result[Int, Int] =
+  p := pick(x)?
+  q := pick(y)?
+  r := pick(z)?
+  Ok(p + q + r)
+fun runMain() -> Int =
+  s := f(1, 2, 3).unwrapOr(0)
+  t := f(1, 0, 0)
+  bad := t.isErr()
+  if bad then s * 1000 + 1 else 0
+# moved from e2e_types::question::chained_question_returns_first_err
+test "chained question returns first err"
+  assert runMain() == 6001

compiler/tests/wasm_codegen/e2e_types/closure_coerced_into_optional_return.plum ADDED Viewed

@@ -0,0 +1,12 @@
+import std/Int
+import std/Option
+fun ap(f: fn() -> Option[Int]) -> Int =
+  f().unwrapOr(0)
+fun runMain() -> Int =
+  ap(|| Some(3))
+# moved from e2e_types::closure_optional::closure_coerced_into_optional_return
+test "closure coerced into optional return"
+  assert runMain() == 3

compiler/tests/wasm_codegen/e2e_types/closure_into_ref_option_and_result.plum ADDED Viewed

@@ -0,0 +1,23 @@
+import std/Int
+import std/Str
+import std/Option
+import std/Result
+enum BadError = Bad | Worse
+fun s(f: fn(Int) -> Option[Str]) -> Str =
+  f(1).unwrapOr("none")
+fun e(f: fn(Int) -> Result[Int, BadError]) -> Int =
+  f(1).unwrapOr(9)
+fun runMain() -> Int =
+  b := s(|x| {if x > 0 then Some("yes") else None}).length()
+  b2 := s(|x| Some("ab")).length()
+  c := e(|x| Ok(x + 1))
+  d := e(|x| Err(Bad))
+  b * 1000 + b2 * 100 + c * 10 + d
+# moved from e2e_types::closure_optional::closure_into_ref_option_and_result
+test "closure into ref option and result"
+  assert runMain() == 3229

compiler/tests/wasm_codegen/e2e_types/closure_passes_none_to_an_option_param.plum ADDED Viewed

@@ -0,0 +1,18 @@
+import std/Str
+import std/Int
+import std/Float
+import std/Slice
+import std/Option
+fun runMain() -> Int =
+  rec := |o: Option[Int], acc: Int, n: Int|
+    if n <= 0 then acc else rec(None, acc + 1, n - 1)
+  rec(None, 0, 3)
+# moved from e2e_types::synthetic_sites::closure_passes_none_to_an_option_param
+# F-T9-2: a closure calling itself with `None` for an `Option[Int]` param. The checker
+# types that `None` as `Option[Unit]`; the param's declared type picks the singleton, so the
+# wasm is valid and the value right.
+test "closure passes none to an option param"
+  assert runMain() == 3

compiler/tests/wasm_codegen/e2e_types/closure_returning_none_into_optional.plum ADDED Viewed

@@ -0,0 +1,12 @@
+import std/Int
+import std/Option
+fun ap(f: fn() -> Option[Int]) -> Int =
+  f().unwrapOr(7)
+fun runMain() -> Int =
+  ap(|| None)
+# moved from e2e_types::closure_optional::closure_returning_none_into_optional
+test "closure returning none into optional"
+  assert runMain() == 7

compiler/tests/wasm_codegen/e2e_types/curried_closure_runs.plum ADDED Viewed

@@ -0,0 +1,13 @@
+import std/Int
+fun curry() -> fn(Int) -> fn(Int) -> Int =
+  |x| |y| x + y
+fun runMain() -> Int =
+  add2 := curry()
+  f := add2(2)
+  f(3)
+# moved from e2e_types::closure_types::curried_closure_runs
+test "curried closure runs"
+  assert runMain() == 5

compiler/tests/wasm_codegen/e2e_types/err_field_is_error.plum ADDED Viewed

@@ -0,0 +1,15 @@
+import std/Int
+import std/Option
+import std/Result
+struct Pt(first: Int, second: Int)
+fun runMain() -> Int =
+  r: Result[Int, Int] := Err(error: 5)
+  match r
+    Ok(v) => v
+    Err(e) => e
+# moved from e2e_types::question::err_field_is_error
+test "err field is error"
+  assert runMain() == 5

compiler/tests/wasm_codegen/e2e_types/field_less_variant_called_like_a_constructor.plum ADDED Viewed

@@ -0,0 +1,23 @@
+import std/Str
+import std/Int
+import std/Float
+import std/Slice
+enum Maybe =
+  | Nothing
+  | Just(value: Int)
+fun orZero(m: Maybe) -> Int = match m
+  Nothing => 0
+  Just(v) => v
+fun runMain() -> Int =
+  a: Maybe := Nothing()
+  b: Maybe := Just(value: 40)
+  orZero(a) + orZero(b) + 2
+# moved from e2e_types::synthetic_sites::field_less_variant_called_like_a_constructor
+# `Nothing()` (call syntax on a field-less variant) is the variant's
+# singleton, typed by the call node.
+test "field less variant called like a constructor"
+  assert runMain() == 42

compiler/tests/wasm_codegen/e2e_types/field_less_variant_of_a_generic_enum_called_like_a_constructor.plum ADDED Viewed

@@ -0,0 +1,22 @@
+import std/Str
+import std/Int
+import std/Float
+import std/Slice
+enum Maybe[T] =
+  | Nothing
+  | Just(value: T)
+fun orZero(m: Maybe[Int]) -> Int = match m
+  Nothing => 0
+  Just(v) => v
+fun runMain() -> Int =
+  a: Maybe[Int] := Nothing()
+  b: Maybe[Int] := Just(value: 40)
+  orZero(a) + orZero(b) + 2
+# moved from e2e_types::synthetic_sites::field_less_variant_of_a_generic_enum_called_like_a_constructor
+# The same call syntax on a variant of a generic enum: the call has the enum's instantiated type.
+test "field less variant of a generic enum called like a constructor"
+  assert runMain() == 42

compiler/tests/wasm_codegen/e2e_types/fn_field_returning_optional.plum ADDED Viewed

@@ -0,0 +1,15 @@
+import std/Int
+import std/Option
+struct Gen(next: fn() -> Option[Int])
+fun count(g: Gen) -> Int =
+  g.next().unwrapOr(0)
+fun runMain() -> Int =
+  k := 5
+  count(Gen(next: || Some(k)))
+# moved from e2e_types::closure_optional::fn_field_returning_optional
+test "fn field returning optional"
+  assert runMain() == 5

compiler/tests/wasm_codegen/e2e_types/g1_typed_param.plum ADDED Viewed

@@ -0,0 +1,13 @@
+import std/Int
+struct Box(v: Int) =
+  fun get(self) -> Int = self.v
+fun ap(f: fn(Box) -> Int) -> Int = f(Box(v: 2))
+fun runMain() -> Int =
+  ap(|b: Box| b.get())
+# moved from e2e_types::closure_types::g1_typed_param
+test "g1 typed param"
+  assert runMain() == 2

compiler/tests/wasm_codegen/e2e_types/g2_local_closure_inferred_from_first_call.plum ADDED Viewed

@@ -0,0 +1,12 @@
+import std/Int
+struct Box(v: Int) =
+  fun get(self) -> Int = self.v
+fun runMain() -> Int =
+  get := |b| b.get()
+  get(Box(v: 2))
+# moved from e2e_types::closure_types::g2_local_closure_inferred_from_first_call
+test "g2 local closure inferred from first call"
+  assert runMain() == 2

compiler/tests/wasm_codegen/e2e_types/g5_returned_closure.plum ADDED Viewed

@@ -0,0 +1,12 @@
+import std/Int
+fun adder(n: Int) -> fn(Int) -> Int =
+  |x| x + n
+fun runMain() -> Int =
+  add1 := adder(1)
+  add1(2)
+# moved from e2e_types::closure_types::g5_returned_closure
+test "g5 returned closure"
+  assert runMain() == 3

compiler/tests/wasm_codegen/e2e_types/inline_if_joins_bare_variant_instantiations.plum ADDED Viewed

@@ -0,0 +1,19 @@
+import std/Int
+import std/Option
+import std/Result
+struct Pt(first: Int, second: Int)
+fun runMain() -> Int =
+  flag := 3 > 2
+  o := if flag then Ok(4) else Err(5)
+  low := if flag then Err(1) else Ok(Pt(first: 1, second: 2))
+  a := o.unwrapOr(0)
+  match low
+    Ok(pt) => pt.first
+    Err(e) => a * 10 + e
+# moved from e2e_types::question::inline_if_joins_bare_variant_instantiations
+# An unannotated inline if: each bare variant pins the generic the other leaves open.
+test "inline if joins bare variant instantiations"
+  assert runMain() == 41

compiler/tests/wasm_codegen/e2e_types/inlined_constant_call_keeps_return_type.plum ADDED Viewed

@@ -0,0 +1,18 @@
+import std/Int
+import std/Option
+import std/Result
+struct Pt(first: Int, second: Int)
+fun pick(flag: Bool, n: Int) -> Result[Pt, Int] = if flag then Ok(Pt(first: n, second: 1)) else Err(100 + n)
+fun runMain() -> Int =
+  match pick(false, 1)
+    Ok(pt) => pt.first
+    Err(e) => e
+# moved from e2e_types::question::inlined_constant_call_keeps_return_type
+# Fusion inlines `pick(false, 1)` to a bare `Err(101)` and drops `Result[Pt, Int]`
+# (plum-core simplify), so codegen builds `Ok`'s payload as Unit.
+test "inlined constant call keeps return type"
+  assert runMain() == 101

compiler/tests/wasm_codegen/e2e_types/list_literal_element_pinned_by_a_later_element.plum ADDED Viewed

@@ -0,0 +1,37 @@
+import std/Str
+import std/Int
+import std/List
+enum Node[M] =
+  | Box(w: Int)
+  | Tag(msg: M, w: Int)
+  | Group(kids: List[Node[M]])
+  | Wrap(child: Node[M], k: Int)
+  fun total(self) -> Int = match self
+    Box(w) => w
+    Tag(_, w) => w
+    Group(kids) => Node.sumKids(kids)
+    Wrap(child, k) => Node.twice(child, k)
+  fun twice(child: Node[M], k: Int) -> Int = child.total() + child.total() + k
+  fun sumKids(kids: List[Node[M]]) -> Int = match kids
+    Nil => 0
+    Cons(head, tail) => head.total() + Node.sumKids(tail)
+# A second instantiation, so a wrongly pinned element picks a different type.
+fun other(n: Node[Int]) -> Int = n.total()
+fun tagged(s: Str) -> Node[Str] = Tag(msg: s, w: 2)
+fun view(s: Str) -> Node[Str] =
+  t := tagged(s)
+  Wrap(child: Group(kids: [Box(w: 1), t, Box(w: 3)]), k: 100)
+fun runMain() -> Int =
+  view("x").total() + other(Box(w: 10))
+# moved from e2e_types::list_and_shadow::list_literal_element_pinned_by_a_later_element
+test "list literal element pinned by a later element"
+  assert runMain() == 122

compiler/tests/wasm_codegen/e2e_types/map_err_closure_param_shadows_top_level_fn.plum ADDED Viewed

@@ -0,0 +1,17 @@
+import std/Int
+import std/Option
+import std/Result
+struct Pt(first: Int, second: Int)
+fun f(flag: Bool, n: Int) -> Result[Int, Int] = if flag then Ok(n) else Err(100 + n)
+fun runMain() -> Int =
+  match f(false, 1).mapErr(|e| e + 1000)
+    Ok(v) => v
+    Err(e) => e
+# moved from e2e_types::question::map_err_closure_param_shadows_top_level_fn
+# mapErr's closure param `f` must not take the arity of a top-level `fun f`.
+test "map err closure param shadows top level fn"
+  assert runMain() == 1101

compiler/tests/wasm_codegen/e2e_types/map_err_on_call_result.plum ADDED Viewed

@@ -0,0 +1,18 @@
+import std/Int
+import std/Option
+import std/Result
+struct Pt(first: Int, second: Int)
+fun fails() -> Result[Int, Int] =
+  r: Result[Int, Int] := Err(7)
+  r
+fun runMain() -> Int =
+  match fails().mapErr(|e| e + 1000)
+    Ok(v) => v
+    Err(e) => e
+# moved from e2e_types::question::map_err_on_call_result
+test "map err on call result"
+  assert runMain() == 1007

compiler/tests/wasm_codegen/e2e_types/map_err_then_unwrap_or_fuses.plum ADDED Viewed

@@ -0,0 +1,16 @@
+import std/Int
+import std/Option
+import std/Result
+struct Pt(first: Int, second: Int)
+fun pick(flag: Bool, n: Int) -> Result[Int, Int] = if flag then Ok(n) else Err(100 + n)
+fun runMain() -> Int =
+  pick(true, 2).mapErr(|e| e + 1).unwrapOr(0)
+# moved from e2e_types::question::map_err_then_unwrap_or_fuses
+# Simplify inlines `pick(true, 2)` to `Ok(2)`; drive then fuses `unwrapOr` over `mapErr`
+# into a fn generic in `E`, which a bare `Ok(2)` never binds (no instance is emitted).
+test "map err then unwrap or fuses"
+  assert runMain() == 2

compiler/tests/wasm_codegen/e2e_types/nested_generic.plum ADDED Viewed

@@ -0,0 +1,21 @@
+import std/Int
+import std/Slice
+import std/List
+struct Pt(x: Int) =
+  fun make(n: Int) -> Pt = Pt(x: n + 1)
+fun buildAll[T](ns: Slice[Int]) -> Slice[T] =
+  out := Slice[T]()
+  for n := range ns
+    out.push(T.make(n))
+  return out
+fun runMain() -> Int =
+  ps: Slice[Pt] := buildAll([1, 2, 3].toSlice())
+  p := ps.get(2).unwrapOr(Pt(x: 0))
+  return p.x
+# moved from e2e_types::type_param_static::nested_generic
+test "nested generic"
+  assert runMain() == 4

compiler/tests/wasm_codegen/e2e_types/none_as_generic_param_default.plum ADDED Viewed

@@ -0,0 +1,16 @@
+import std/Int
+import std/Option
+import std/Result
+struct Pt(first: Int, second: Int)
+fun g[T](x: T, o: Option[T] = None) -> Option[T] = o
+fun runMain() -> Int =
+  a := g(1).unwrapOr(7)
+  b := g(1, Some(3)).unwrapOr(0)
+  a * 10 + b
+# moved from e2e_types::question::none_as_generic_param_default
+test "none as generic param default"
+  assert runMain() == 73

compiler/tests/wasm_codegen/e2e_types/none_as_param_default.plum ADDED Viewed

@@ -0,0 +1,16 @@
+import std/Int
+import std/Option
+import std/Result
+struct Pt(first: Int, second: Int)
+fun f(n: Option[Int] = None) -> Option[Int] = n
+fun runMain() -> Int =
+  a := f().unwrapOr(7)
+  b := f(Some(3)).unwrapOr(0)
+  a * 10 + b
+# moved from e2e_types::question::none_as_param_default
+test "none as param default"
+  assert runMain() == 73

compiler/tests/wasm_codegen/e2e_types/ok_unit_and_expression_position.plum ADDED Viewed

@@ -0,0 +1,24 @@
+import std/Int
+import std/Option
+import std/Result
+struct Pt(first: Int, second: Int)
+fun g(n: Int) -> Option[Int] = if n > 0 then Some(n) else None
+fun u(n: Int) -> Result[Unit, Int] =
+  if n > 0
+    return Ok(Unit)
+  Err(n)
+fun h(n: Int) -> Option[Int] = Some(1 + g(n)?)
+fun runMain() -> Int =
+  a := h(5).unwrapOr(0)
+  b := u(1).isOk()
+  c := u(0).isErr()
+  if b && c then a else -1
+# moved from e2e_types::question::ok_unit_and_expression_position
+test "ok unit and expression position"
+  assert runMain() == 6

compiler/tests/wasm_codegen/e2e_types/option_question_returns_none.plum ADDED Viewed

@@ -0,0 +1,18 @@
+import std/Int
+import std/Option
+import std/Result
+struct Pt(first: Int, second: Int)
+fun g(n: Int) -> Option[Int] = if n > 0 then Some(n) else None
+fun f(n: Int) -> Option[Int] =
+  v := g(n)?
+  Some(v * 2)
+fun runMain() -> Int =
+  f(4).unwrapOr(-1) * 100 + f(0).unwrapOr(7)
+# moved from e2e_types::question::option_question_returns_none
+test "option question returns none"
+  assert runMain() == 807

compiler/tests/wasm_codegen/e2e_types/reused_cell_is_read_through_its_local.plum ADDED Viewed

@@ -0,0 +1,23 @@
+import std/Str
+import std/Int
+import std/Float
+import std/Slice
+enum Link =
+  | Nil
+  | Cons(head: Int, tail: Link)
+fun bump(xs: Link) -> Link = match xs
+  Nil => Nil
+  Cons(h, t) => Cons(head: h + 1, tail: t)
+fun sum(xs: Link) -> Int = match xs
+  Nil => 0
+  Cons(h, t) => h + sum(t)
+fun runMain() -> Int = sum(bump(Cons(head: 1, tail: Cons(head: 2, tail: Nil))))
+# moved from e2e_types::synthetic_sites::reused_cell_is_read_through_its_local
+# A rebuild that reuses the matched cell reads the cell's type off the local it names.
+test "reused cell is read through its local"
+  assert runMain() == 4

compiler/tests/wasm_codegen/e2e_types/seq_with_optional_next.plum ADDED Viewed

@@ -0,0 +1,19 @@
+import std/Int
+import std/Option
+struct Seq[T](next: fn(Int) -> Option[T]) =
+  fun upTo(n: Int) -> Seq[Int] = Seq(next: |i| {if i < n then Some(i * 2) else None})
+  fun sum(self) -> Int =
+    total := 0
+    i := 0
+    while Some(v) := self.next(i)
+      total = total + v
+      i = i + 1
+    total
+fun runMain() -> Int =
+  Seq.upTo(4).sum()
+# moved from e2e_types::closure_optional::seq_with_optional_next
+test "seq with optional next"
+  assert runMain() == 12

compiler/tests/wasm_codegen/e2e_types/single_letter_types_and_variants.plum ADDED Viewed

@@ -0,0 +1,24 @@
+import std/Int
+struct P(x: Int)
+enum Two = A | B
+struct Cfg(n: Int) =
+  E = 5
+fun pick(t: Two) -> Int = match t
+  A => 1
+  B => 20
+fun id[Elem](x: Elem) -> Elem = x
+fun runMain() -> Int =
+  p := P(x: id(3))
+  pick(A) + pick(B) + p.x + Cfg.E
+# moved from e2e_types::type_param_static::single_letter_types_and_variants
+# Single uppercase letters are ordinary names: a struct, enum variants, a constant, and a
+# declared multi-letter fn generic all work side by side.
+test "single letter types and variants"
+  assert runMain() == 29

compiler/tests/wasm_codegen/e2e_types/specialised_arm_keeps_result_type.plum ADDED Viewed

@@ -0,0 +1,26 @@
+import std/Int
+import std/Option
+import std/Result
+struct Pt(first: Int, second: Int)
+fun pick(flag: Bool, n: Int) -> Result[Pt, Int] = if flag then Ok(Pt(first: n, second: 1)) else Err(100 + n)
+fun viaMapErr() -> Int =
+  match pick(false, 2).mapErr(|e| e + 1)
+    Ok(pt) => pt.first
+    Err(e) => e
+fun viaOk() -> Int =
+  r := pick(false, 4)
+  match r.ok()
+    Some(pt) => pt.first
+    None => 8
+fun runMain() -> Int = viaMapErr() * 10 + viaOk()
+# moved from e2e_types::question::specialised_arm_keeps_result_type
+# Drive specialises `mapErr` / `ok` on the inlined `Err(..)`: the picked arm's own `Err` /
+# `None` leaves `mapErr` / `ok` and must keep its `Result[Pt, Int]` / `Option[Pt]`.
+test "specialised arm keeps result type"
+  assert runMain() == 1038

compiler/tests/wasm_codegen/e2e_types/static_method_of_generic_type_not_pinning_t.plum ADDED Viewed

@@ -0,0 +1,12 @@
+import std/Int
+struct Gen[T](v: T) =
+  fun ints(n: Int) -> Gen[Int] = Gen(v: n)
+  fun get(self) -> T = self.v
+fun runMain() -> Int =
+  Gen.ints(4).get()
+# moved from e2e_types::closure_optional::static_method_of_generic_type_not_pinning_t
+test "static method of generic type not pinning t"
+  assert runMain() == 4

compiler/tests/wasm_codegen/e2e_types/static_on_builtin.plum ADDED Viewed

@@ -0,0 +1,11 @@
+import std/Int
+fun maxOf[T](n: Int) -> T = T.Max
+fun runMain() -> Int =
+  m: Int := maxOf(1)
+  return if m == Int.Max then 1 else 0
+# moved from e2e_types::type_param_static::static_on_builtin
+test "static on builtin"
+  assert runMain() == 1

compiler/tests/wasm_codegen/e2e_types/static_on_builtin_method_and_json_cycle.plum ADDED Viewed

@@ -0,0 +1,17 @@
+import std/Int
+import std/Str
+import std/Json
+import std/Result
+fun parseIt[T](s: Str) -> Result[T, NumError] =
+  T.parse(s)
+fun runMain() -> Int =
+  r: Result[Int, NumError] := parseIt("41")
+  n := r.unwrapOr(0)
+  j := n.toJson()
+  return n + 1
+# moved from e2e_types::type_param_static::static_on_builtin_method_and_json_cycle
+test "static on builtin method and json cycle"
+  assert runMain() == 42

compiler/tests/wasm_codegen/e2e_types/static_on_type_param.plum ADDED Viewed

@@ -0,0 +1,14 @@
+import std/Int
+struct Pt(x: Int) =
+  fun make(n: Int) -> Pt = Pt(x: n * 10)
+fun build[T](n: Int) -> T = T.make(n)
+fun runMain() -> Int =
+  p: Pt := build(3)
+  return p.x
+# moved from e2e_types::type_param_static::static_on_type_param
+test "static on type param"
+  assert runMain() == 30

compiler/tests/wasm_codegen/e2e_types/struct_payload_in_some.plum ADDED Viewed

@@ -0,0 +1,18 @@
+import std/Int
+import std/Option
+import std/Result
+struct Pt(first: Int, second: Int)
+fun g(n: Int) -> Option[Pt] = if n > 0 then Some(Pt(first: n, second: 2)) else None
+fun f(n: Int) -> Option[Int] =
+  p := g(n)?
+  Some(p.first * 10 + p.second)
+fun runMain() -> Int =
+  f(3).unwrapOr(0)
+# moved from e2e_types::question::struct_payload_in_some
+test "struct payload in some"
+  assert runMain() == 32

compiler/tests/wasm_codegen/e2e_types/unannotated_local_of_list_pinned_by_a_later_element.plum ADDED Viewed

@@ -0,0 +1,39 @@
+import std/Str
+import std/Int
+import std/List
+enum Node[M] =
+  | Box(w: Int)
+  | Tag(msg: M, w: Int)
+  | Group(kids: List[Node[M]])
+  | Wrap(child: Node[M], k: Int)
+  fun total(self) -> Int = match self
+    Box(w) => w
+    Tag(_, w) => w
+    Group(kids) => Node.sumKids(kids)
+    Wrap(child, k) => Node.twice(child, k)
+  fun twice(child: Node[M], k: Int) -> Int = child.total() + child.total() + k
+  fun sumKids(kids: List[Node[M]]) -> Int = match kids
+    Nil => 0
+    Cons(head, tail) => head.total() + Node.sumKids(tail)
+# A second instantiation, so a wrongly pinned element picks a different type.
+fun other(n: Node[Int]) -> Int = n.total()
+fun tagged(s: Str) -> Node[Str] = Tag(msg: s, w: 2)
+fun view(s: Str) -> Int =
+  t := tagged(s)
+  g := Group(kids: [Box(w: 1), t])
+  q := g
+  g.total() + q.total()
+fun runMain() -> Int =
+  view("x") + other(Box(w: 10))
+# moved from e2e_types::list_and_shadow::unannotated_local_of_list_pinned_by_a_later_element
+test "unannotated local of list pinned by a later element"
+  assert runMain() == 16

compiler/tests/wasm_codegen/e2e_types/unit_closure_local_called_as_a_statement.plum ADDED Viewed

@@ -0,0 +1,15 @@
+import std/Str
+import std/Int
+import std/Float
+import std/Slice
+fun runMain() -> Int =
+  f := || Unit
+  f()
+  f()
+  7
+# moved from e2e_types::synthetic_sites::unit_closure_local_called_as_a_statement
+# A call through a local closure whose type is only known from the local's own initialiser.
+test "unit closure local called as a statement"
+  assert runMain() == 7

compiler/tests/wasm_codegen/e2e_types/untyped_closure_passes_none_to_an_option_param.plum ADDED Viewed

@@ -0,0 +1,18 @@
+import std/Str
+import std/Int
+import std/Float
+import std/Slice
+import std/Option
+fun run(n: Int, o: Option[Int]) -> Int =
+  rec := |o, acc, n|
+    if n <= 0 then 0 else rec(None, acc + 1, n - 1)
+  rec(o, 0, n)
+fun runMain() -> Int =
+  run(3, None)
+# moved from e2e_types::synthetic_sites::untyped_closure_passes_none_to_an_option_param
+test "untyped closure passes none to an option param"
+  assert runMain() == 0

compiler/tests/wasm_codegen/e2e_types/user_type_shadows_std_pair_imported_by_std.plum ADDED Viewed

@@ -0,0 +1,14 @@
+import std/Int
+struct Pair(a: Int, b: Int) =
+  fun sum(self) -> Int = self.a + self.b
+fun runMain() -> Int =
+  p := Pair(a: 3, b: 4)
+  for i := range 3
+    p = Pair(a: p.a + i, b: p.b)
+  p.a * 10 + p.sum()
+# moved from e2e_types::list_and_shadow::user_type_shadows_std_pair_imported_by_std
+test "user type shadows std pair imported by std"
+  assert runMain() == 70

compiler/wasm-codegen/tests/wasm_codegen/e2e_mem/unique_inplace.rs CHANGED Viewed

@@ -38,43 +38,6 @@ fn unique_spread_reuses_object() {
     assert_eq!(runInt("reuse_run", &unique), 207);
 }
-#[test]
-fn plain_spread_still_copies() {
-    let src = prog("struct Cell(x: Int, y: Int)
-fun main() -> Int =
-  s := Cell(x: 1, y: 7)
-  t := Cell(..s, x: 5)
-  s.x * 1000 + t.x * 100 + t.y
-");
-    assert_eq!(runInt("plain", &src), 1000 + 500 + 7);
-}
-#[test]
-fn unique_spread_sets_fields() {
-    let src = prog("struct Cell(x: Int, y: Int, z: Int)
-fun main() -> Int =
-  s := Cell(x: 1, y: 2, z: 3)
-  t := Cell(..s, z: 30, x: 10)
-  t.x * 10000 + t.y * 100 + t.z
-");
-    assert_eq!(runInt("sets", &src), 100000 + 200 + 30);
-}
-/// A value reading an already-overwritten field must still see the OLD value.
-#[test]
-fn unique_spread_swap_reads_old_values() {
-    let src = prog("struct Cell(x: Int, y: Int)
-fun main() -> Int =
-  s := Cell(x: 1, y: 2)
-  t := Cell(..s, x: s.y, y: s.x)
-  t.x * 10 + t.y
-");
-    assert_eq!(runInt("swap", &src), 21);
-}
 #[test]
 fn unique_base_record_spread_in_place() {
     let unique = prog("struct Actor() =\n  fun go(self) -> Int = 7\n\nstruct Ship(Actor, x: Int, hp: Int)\n\nfun hit(s: Ship) -> Ship = Ship(..s, hp: s.hp - 1, x: s.x + 5)\n\nfun main() -> Int =\n  s := Ship(x: 1, hp: 10)\n  t := hit(s)\n  t.go() * 100 + t.hp * 10 + t.x\n");
@@ -90,63 +53,6 @@ fn unique_base_field_record_spread_in_place() {
     assert!(spreadIsUnique("unique_base_field_flag", "hit", &unique));
 }
-#[test]
-fn unique_self_field_write() {
-    let src = prog("struct Cell(mut x: Int) =
-  fun bump(self) -> Cell =
-    self.x = self.x + 1
-    self
-fun main() -> Int =
-  s := Cell(x: 41)
-  t := s.bump()
-  t.x
-");
-    assert_eq!(runInt("selfwrite", &src), 42);
-}
-/// A later value that reads a field an earlier one overwrote, or uses the source
-/// any other way (here a method call), must still run (copy fallback).
-#[test]
-fn unique_spread_hazard_falls_back_to_copy() {
-    let src = prog("struct Cell(x: Int, y: Int) =
-  fun sum(self) -> Int = self.x + self.y
-fun main() -> Int =
-  s := Cell(x: 1, y: 2)
-  t := Cell(..s, x: 10, y: s.sum())
-  t.x * 100 + t.y
-");
-    assert_eq!(runInt("hazard_call", &src), 1000 + 3);
-    let src = prog("struct Cell(x: Int, y: Int, z: Int)
-fun main() -> Int =
-  s := Cell(x: 1, y: 2, z: 3)
-  t := Cell(..s, x: 10, z: s.y + s.z)
-  t.x * 100 + t.y * 10 + t.z
-");
-    assert_eq!(runInt("hazard_ok_read", &src), 1000 + 20 + 5);
-}
-/// R5: arms binding differently named locals of different record types.
-#[test]
-fn match_arm_rename_still_valid_wasm() {
-    let src = prog("struct Pa(x: Int)
-struct Pb(y: Int, z: Int)
-enum Pick = Wa(v: Pa) | Wb(v: Pb)
-fun go(p: Pick) -> Int =
-  match p
-    Wa(a) => a.x
-    Wb(b) => b.y * 10 + b.z
-fun main() -> Int =
-  go(Wa(v: Pa(x: 4))) * 100 + go(Wb(v: Pb(y: 5, z: 6)))
-");
-    assert_eq!(runInt("match_rename", &src), 400 + 56);
-}
 /// F-T6-3: `s = Cell(..s, ...)` on a param must reassign the param's own slot, not
 /// a fresh shadow local that every read of `s` (the spread source included) sees unset.
 #[test]
@@ -169,28 +75,3 @@ fun main() -> Int =
     assert_eq!(runInt("reassign_param", &unique), 41000 + 207);
     assert!(spreadIsUnique("reassign_param_flag", "bump", &unique));
 }
-#[test]
-fn unique_spread_reassign_local() {
-    let src = prog("struct Cell(x: Int, y: Int)
-fun main() -> Int =
-  s := Cell(x: 1, y: 7)
-  s = Cell(..s, x: s.x + 1)
-  s = Cell(..s, y: s.y + s.x)
-  s.x * 100 + s.y
-");
-    assert_eq!(runInt("reassign_local", &src), 200 + 9);
-}
-#[test]
-fn unique_self_spread_return() {
-    let src = prog("struct Cell(x: Int, y: Int) =
-  fun step(self) -> Cell = Cell(..self, x: self.x + 1)
-fun main() -> Int =
-  t := Cell(x: 1, y: 7).step().step()
-  t.x * 100 + t.y
-");
-    assert_eq!(runInt("self_spread", &src), 300 + 7);
-}

compiler/wasm-codegen/tests/wasm_codegen/e2e_records/enum_init.rs CHANGED Viewed

@@ -1,56 +1,8 @@
-use plum_test_support::{load, runInt};
-use plum_test_support::compileSource;
+use plum_test_support::{compileSource, load};
-const LINK: &str = "enum Link[T] =
-  | Nil
-  | Cons(head: T, tail: Link[T])
-  fun init(a: T, b: T) -> Link[T] = Cons(head: a, tail: Cons(head: b, tail: Nil))
-  fun length(self) -> Int = match self
-    Nil => 0
-    Cons(_, t) => 1 + t.length()
-  fun sum(self) -> Int = match self
-    Nil => 0
-    Cons(h, t) => h + t.sum()
-";
 fn prog(body: &str) -> String {
     format!("import std/Str\nimport std/Int\n\n{body}")
 }
-#[test]
-fn empty_init_with_annotation() {
-    let link0 = LINK.replace(
-        "fun init(a: T, b: T) -> Link[T] = Cons(head: a, tail: Cons(head: b, tail: Nil))",
-        "fun init() -> Link[T] = Nil",
-    );
-    let src = prog(&format!("{link0}fun main() -> Int =
-  xs: Link[Int] := Link()
-  xs.length() + 7
-"));
-    assert_eq!(runInt("empty", &src), 7);
-}
-#[test]
-fn fixed_param_init() {
-    let src = prog("enum Pair2 =
-  | Zero
-  | Two(a: Int, b: Int)
-  fun init(a: Int, b: Int) -> Pair2 = Two(a: a, b: b)
-  fun total(self) -> Int = match self
-    Zero => 0
-    Two(a, b) => a + b
-fun main() -> Int =
-  Pair2(3, 4).total()
-");
-    assert_eq!(runInt("fixed", &src), 7);
-}
 #[test]
 fn no_init_error_message() {
     let src = prog("enum Shape =
@@ -73,22 +25,3 @@ fun main() -> Int =
         "{err}"
     );
 }
-#[test]
-fn variant_name_wins() {
-    let src = prog(&format!("{LINK}fun main() -> Int =
-  xs := Cons(head: 5, tail: Link(1, 2))
-  xs.sum() * 10 + xs.length()
-"));
-    assert_eq!(runInt("variantwins", &src), 83);
-}
-#[test]
-fn generic_inferred_from_args() {
-    let src = prog(&format!("{LINK}fun total(xs: Link[Int]) -> Int = xs.sum()
-fun main() -> Int =
-  total(Link(5, 6)) + Link(\"a\", \"b\").length()
-"));
-    assert_eq!(runInt("infer", &src), 13);
-}

compiler/wasm-codegen/tests/wasm_codegen/e2e_records/inline_variants.rs CHANGED Viewed

@@ -1,78 +1,6 @@
-use plum_test_support::{load, runInt};
+use plum_test_support::{load};
-const HEAD: &str = "\
-import std/Str
-import std/Int
-import std/Slice
-enum Link[T] = Nil | Cons(head: T, tail: Link[T])
-fun length[T](xs: Link[T]) -> Int = match xs
-  Nil => 0
-  Cons(_, t) => 1 + length(t)
-fun sum(xs: Link[Int]) -> Int = match xs
-  Nil => 0
-  Cons(h, t) => h + sum(t)
-fun cons[T](h: T, t: Link[T]) -> Link[T] =
-  Cons(head: h, tail: t)
-fun map(xs: Link[Int], f: fn(Int) -> Int) -> Link[Int] = match xs
-  Nil => Nil
-  Cons(h, t) => Cons(head: f(h), tail: map(t, f))
-";
-#[test]
-fn cons_list_length_map_sum() {
-    let src = format!(
-        "{HEAD}\
-fun main() -> Int =
-  xs := cons(1, cons(2, cons(3, Nil)))
-  ys := map(xs, |n| n * 2)
-  sum(xs) * 100 + sum(ys) + length(ys) * 10000
-"
-    );
-    assert_eq!(runInt("cons", &src), 30000 + 600 + 12);
-}
-#[test]
-fn nested_literal_construction() {
-    let src = format!(
-        "{HEAD}\
-fun main() -> Int =
-  xs := Cons(head: 1, tail: Cons(head: 2, tail: Cons(head: 3, tail: Nil)))
-  sum(xs)
-"
-    );
-    assert_eq!(runInt("nested", &src), 6);
-}
-#[test]
-fn tree_insert_and_size() {
-    let src = "\
-import std/Str
-import std/Int
-enum Tree[T] = Empty | Leaf(v: Int) | Node(l: Tree[T], r: Tree[T])
-fun size[T](t: Tree[T]) -> Int = match t
-  Empty => 0
-  Leaf(_) => 1
-  Node(l, r) => size(l) + size(r)
-fun lf() -> Tree[Str] =
-  Leaf(v: 3)
-fun main() -> Int =
-  t := Node(l: lf(), r: Node(l: lf(), r: Empty))
-  size(t)
-";
-    assert_eq!(runInt("tree", src), 2);
-}
 #[test]
 fn union_enum_is_an_error() {
     let src = "\

compiler/wasm-codegen/tests/wasm_codegen/e2e_records/mod.rs CHANGED Viewed

@@ -1,7 +1,5 @@
 #![allow(non_snake_case)]
-mod empty_record_embed;
 mod enum_init;
 mod inline_variants;
-mod record_embed;
 mod record_init;
 mod unboxed_variants;

compiler/wasm-codegen/tests/wasm_codegen/e2e_records/record_embed.rs DELETED Viewed

@@ -1,79 +0,0 @@
-use plum_test_support::{runInt, PRE};
-fn prog(body: &str) -> String {
-    format!("{PRE}{body}")
-}
-const STAGE: &str = "struct Stage(camScale: Int) =
-  fun init(self) =
-    self.root: Int = 10
-    self.camX: Int = self.camScale * 2
-  fun act(self, dt: Int) -> Int = self.root + dt
-  fun draw(self) -> Int = 100
-";
-#[test]
-fn inherited_fields_methods_and_init_order() {
-    let src = prog(&format!("{STAGE}struct World(Stage(camScale), score: Int) =
-  fun init(self) =
-    self.best: Int = self.root + self.camX + 1
-fun main() -> Int =
-  w := World(camScale: 3, score: 4)
-  w.camScale + w.root * 10 + w.camX * 100 + w.score * 1000 + w.best * 10000 + w.act(5) * 100000
-"));
-    // camScale 3, root 10, camX 6, score 4, best 17, act(5) = 15
-    assert_eq!(runInt("fields", &src), 3 + 100 + 600 + 4000 + 170000 + 1500000);
-}
-#[test]
-fn override_calls_original() {
-    let src = prog(&format!("{STAGE}struct World(Stage(camScale), score: Int) =
-  override fun draw(self) -> Int = self.Stage.draw() + self.score
-fun main() -> Int =
-  w := World(camScale: 1, score: 7)
-  w.draw() * 10 + w.act(1)
-"));
-    assert_eq!(runInt("override", &src), 1070 + 11);
-}
-#[test]
-fn embedded_record_standalone_and_unselected_set_by_init() {
-    let src = prog("struct Stage(camScale: Int, tag: Int) =
-  fun init(self) =
-    self.camX: Int = 6
-struct World(Stage(tag), score: Int) =
-  fun init(self) =
-    self.camScale = 5
-fun main() -> Int =
-  s := Stage(camScale: 2, tag: 1)
-  w := World(tag: 3, score: 1)
-  s.camScale * 100 + w.camScale * 10 + w.camX + w.tag + s.camX
-");
-    assert_eq!(runInt("standalone", &src), 200 + 50 + 6 + 3 + 6);
-}
-#[test]
-fn base_through_embedded_struct() {
-    let src = prog("struct Actor(x: Int) =
-  fun go(self) -> Int = 1
-struct Mid(Actor(x), m: Int) =
-  override fun go(self) -> Int = 2 + self.Actor.go()
-struct Top(Mid(x, m), t: Int)
-fun run(a: Actor) -> Int = a.go()
-fun main() -> Int =
-  t := Top(x: 1, m: 2, t: 3)
-  run(t) * 10 + t.x
-");
-    assert_eq!(runInt("deep", &src), 31);
-}

compiler/wasm-codegen/tests/wasm_codegen/e2e_records/record_init.rs CHANGED Viewed

@@ -1,4 +1,4 @@
-use plum_test_support::{runInt, PRE};
+use plum_test_support::{PRE};
 use plum_test_support::load;
 fn prog(body: &str) -> String {
@@ -14,79 +14,6 @@ const ACTOR: &str = "struct Actor(px: Int, py: Int) =
 ";
-#[test]
-fn ship_example_values() {
-    let src = prog(&format!("{ACTOR}struct Ship(Actor(px, py), tex: Int) =
-  fun init(self) =
-    self.height = self.width + 1
-    self.vx = 7
-  override fun area(self) -> Int = self.width * self.height + self.vx
-fun main() -> Int =
-  s := Ship(px: 1, py: 2, tex: 3)
-  s.px + s.py * 10 + s.tex * 100 + s.area() * 1000
-"));
-    // px 1 + py 20 + tex 300 + (10*11+7)*1000
-    assert_eq!(runInt("ship", &src), 1 + 20 + 300 + 117 * 1000);
-}
-#[test]
-fn through_a_base_value() {
-    let src = prog("struct Actor(px: Int, width: Int) =
-  fun init(self) =
-    self.width = 10
-  fun area(self) -> Int = self.width * 2
-struct Ship(Actor(px), tex: Int) =
-  override fun area(self) -> Int = self.width * 20
-struct Rock(Actor(px))
-fun total(a: Actor) -> Int = a.area() + a.px
-fun main() -> Int =
-  total(Ship(px: 1, tex: 0)) * 1000 + total(Rock(px: 2))
-");
-    // Ship: 10*20 + 1 = 201 ; Rock: 20 + 2 = 22
-    assert_eq!(runInt("basevalue", &src), 201 * 1000 + 22);
-}
-#[test]
-fn fresh_list_per_construction() {
-    let src = prog(&format!("{ACTOR}struct Ship(Actor(px, py)) =
-  fun init(self) =
-    self.vx = 0
-fun main() -> Int =
-  a := Ship(px: 0, py: 0)
-  b := Ship(px: 0, py: 0)
-  a.kids.push(1)
-  a.kids.push(2)
-  b.kids.push(9)
-  a.kids.length() * 10 + b.kids.length()
-"));
-    assert_eq!(runInt("fresh", &src), 21);
-}
-#[test]
-fn rest_runs_after_build_and_nested_construction() {
-    let src = prog("struct Inner(mut n: Int)
-struct Outer(a: Int) =
-  fun init(self) =
-    self.inner = Inner(n: self.a + 1)
-    self.total = 0
-    self.bump()
-  fun bump(self) =
-    self.inner.n = self.inner.n * 10
-fun main() -> Int =
-  o := Outer(a: 4)
-  o.inner.n + o.a
-");
-    assert_eq!(runInt("rest", &src), 54);
-}
 #[test]
 fn errors_surface_through_the_loader() {
     let src = prog(&format!("{ACTOR}struct Ship(Actor(px, py)) =

compiler/wasm-codegen/tests/wasm_codegen/e2e_records/unboxed_variants.rs CHANGED Viewed

@@ -1,6 +1,6 @@
 //! Unboxed layout: union-enum members and inline variants are wasm-gc subtypes
 //! of the enum, so constructing one allocates exactly one struct.
-use plum_test_support::{compile, runInt};
+use plum_test_support::{compile};
 use wasmparser::{Operator, Parser, Payload};
 /// Number of `struct.new` instructions in the exported `main` function.
@@ -91,169 +91,3 @@ fun main() -> Int =
     );
     assert_eq!(structNewsInMain(&compile("generic", &src)), 3);
 }
-#[test]
-fn match_variant_fields() {
-    let src = format!(
-        "{HEAD}\
-enum Shape = Circle(r: Int) | Rect(w: Int, h: Int)
-fun area(s: Shape) -> Int =
-  match s
-    Circle(r) => r * r
-    Rect(w, h) => w * h
-fun main() -> Int =
-  area(Circle(r: 3)) * 100 + area(Rect(w: 2, h: 5))
-"
-    );
-    assert_eq!(runInt("match_fields", &src), 910);
-}
-#[test]
-fn nested_enum_match() {
-    let src = format!(
-        "{HEAD}\
-enum Link[T] = End | Duo(head: T, tail: Link[T])
-fun sum(l: Link[Int]) -> Int =
-  match l
-    End => 0
-    Duo(head, tail) => head + sum(tail)
-fun second(l: Link[Int]) -> Int =
-  match l
-    Duo(_, Duo(h, _)) => h
-    _ => -1
-fun main() -> Int =
-  l: Link[Int] := Duo(head: 1, tail: Duo(head: 20, tail: Duo(head: 300, tail: End)))
-  sum(l) * 1000 + second(l)
-"
-    );
-    assert_eq!(runInt("nested", &src), 321020);
-}
-#[test]
-fn equality_is_identity_of_the_variant_value() {
-    let src = format!(
-        "{HEAD}\
-enum Shape = Circle(r: Int) | Rect(w: Int, h: Int)
-fun main() -> Int =
-  a: Shape := Circle(r: 2)
-  b: Shape := a
-  c: Shape := Rect(w: 1, h: 2)
-  x := if a == b then 1 else 0
-  y := if a != c then 10 else 0
-  x + y
-"
-    );
-    assert_eq!(runInt("eq", &src), 11);
-}
-#[test]
-fn reassign_enum_local_across_variants() {
-    let src = format!(
-        "{HEAD}\
-enum Shape = Circle(r: Int) | Rect(w: Int, h: Int)
-fun area(s: Shape) -> Int =
-  match s
-    Circle(r) => r * 3
-    Rect(w, h) => w * h
-fun kind(s: Shape) -> Int =
-  match s
-    Circle(_) => 1
-    Rect(_, _) => 10
-fun main() -> Int =
-  s: Shape := Circle(r: 1)
-  n := area(s)
-  s = Rect(w: 2, h: 5)
-  n = n * 100 + area(s)
-  k := 0
-  for i := range 4
-    if i % 2 == 0
-      s = Rect(w: 1, h: 1)
-    else
-      s = Circle(r: 1)
-    k = k + kind(s)
-  n * 100 + k
-"
-    );
-    assert_eq!(runInt("reassign", &src), (3 * 100 + 10) * 100 + 22);
-}
-#[test]
-fn deep_nested_variant_match() {
-    let src = format!(
-        "{HEAD}\
-enum Tree = Leaf(v: Int) | Node(l: Tree, r: Tree)
-fun depthSum(t: Tree, d: Int) -> Int =
-  match t
-    Leaf(v) => v * d
-    Node(l, r) => depthSum(l, d + 1) + depthSum(r, d + 1)
-fun build(n: Int) -> Tree =
-  if n == 0 then Leaf(v: 1) else Node(l: build(n - 1), r: Leaf(v: n))
-fun main() -> Int = depthSum(build(5), 1)
-"
-    );
-    // Leaves: 1 at depth 6, then Leaf(n) at depth 7 - n for n = 1..5.
-    assert_eq!(runInt("deep", &src), 6 + (1..=5).map(|n| n * (7 - n)).sum::<i64>());
-}
-#[test]
-fn million_cells_built_and_mapped_in_constant_stack() {
-    let src = format!(
-        "{HEAD}\
-enum Link = End | Duo(head: Int, tail: Link)
-fun upTo(n: Int) -> Link =
-  if n == 0 then End else Duo(head: n, tail: upTo(n - 1))
-fun inc(xs: Link) -> Link =
-  match xs
-    End => End
-    Duo(h, t) => Duo(head: h + 1, tail: inc(t))
-fun sum(xs: Link, acc: Int) -> Int =
-  match xs
-    End => acc
-    Duo(h, t) => sum(t, acc + h)
-fun main() -> Int = sum(inc(upTo(1000000)), 0)
-"
-    );
-    assert_eq!(runInt("million", &src), 500000500000 + 1000000);
-}
-#[test]
-fn enum_init_versus_variant_name() {
-    let src = format!(
-        "{HEAD}\
-enum Cell =
-  | Empty
-  | Full(count: Int, label: Str)
-  fun init(n: Int) -> Cell = if n <= 0 then Empty else Full(count: n, label: \"n{{n}}\")
-  fun size(self) -> Int =
-    match self
-      Empty => 0
-      Full(c, _) => c
-fun main() -> Int =
-  a := Cell(5)
-  b := Cell(0)
-  c := Full(count: 9, label: \"nine\")
-  d := Full(label: \"swapped\", count: 2)
-  a.size() * 1000 + b.size() * 100 + c.size() * 10 + d.size()
-"
-    );
-    assert_eq!(runInt("init_names", &src), 5000 + 90 + 2);
-}

compiler/wasm-codegen/tests/wasm_codegen/e2e_tail/closure_tail.rs CHANGED Viewed

@@ -1,31 +1,7 @@
-use plum_test_support::{compile, runInt};
+use plum_test_support::{compile};
 const HEAD: &str = "import std/Int\n\n";
-#[test]
-fn closure_body_tail_call_million() {
-    let src = format!("{HEAD}fun countDown(n: Int) -> Int = if n == 0 then 0 else countDown(n - 1)\n\nfun main() -> Int =\n  dec := |n: Int| if n == 0 then 7 else countDown(n - 1) + 0\n  fin := |n: Int| countDown(n)\n  fin(1000000) + dec(0)\n");
-    assert_eq!(runInt("cbody", &src), 7);
-}
-#[test]
-fn recursive_local_closure_million() {
-    let src = format!("{HEAD}fun main() -> Int =\n  go := |n, acc| if n == 0 then acc else go(n - 1, acc + n)\n  go(1000000, 0)\n");
-    assert_eq!(runInt("rec", &src), 500000500000);
-}
-#[test]
-fn recursive_closure_captures_outer() {
-    let src = format!("{HEAD}fun main() -> Int =\n  k := 3\n  go := |n, acc| if n == 0 then acc else go(n - 1, acc + k)\n  go(1000000, 0)\n");
-    assert_eq!(runInt("reccap", &src), 3000000);
-}
-#[test]
-fn closure_not_recursive_unchanged() {
-    let src = format!("{HEAD}fun main() -> Int =\n  k := 10\n  f := |x| x + k\n  f(5)\n");
-    assert_eq!(runInt("plain", &src), 15);
-}
 #[test]
 fn wasm_closure_has_return_call() {
     let src = format!("{HEAD}fun main() -> Int =\n  go := |n, acc| if n == 0 then acc else go(n - 1, acc + n)\n  go(10, 0)\n");
@@ -43,15 +19,3 @@ fn wasm_closure_has_return_call() {
     }
     assert!(found, "expected return_call_indirect in a closure body");
 }
-#[test]
-fn self_calling_closure_typed_params_runs() {
-    let src = format!("{HEAD}fun main() -> Int =\n  fact := |n: Int| if n <= 1 then 1 else n * fact(n - 1)\n  fact(5)\n");
-    assert_eq!(runInt("selftyped", &src), 120);
-}
-#[test]
-fn self_calling_closure_untyped_params_runs() {
-    let src = format!("{HEAD}fun main() -> Int =\n  fact := |n| if n <= 1 then 1 else n * fact(n - 1)\n  fact(5)\n");
-    assert_eq!(runInt("selfuntyped", &src), 120);
-}

compiler/wasm-codegen/tests/wasm_codegen/e2e_tail/error_tail.rs DELETED Viewed

@@ -1,27 +0,0 @@
-use plum_test_support::runInt;
-const RHEAD: &str = "import std/Int\nimport std/Result\n\nenum NegError = Neg | Other\n\n";
-#[test]
-fn result_self_loop_million() {
-    let src = format!("{RHEAD}fun down(n: Int) -> Result[Int, NegError] =\n  if n < 0\n    return Err(Neg)\n  if n == 0\n    return Ok(5)\n  down(n - 1)\n\nfun main() -> Int = down(1000000).unwrapOr(99)\n");
-    assert_eq!(runInt("result_self_loop_million", &src), 5);
-}
-#[test]
-fn result_self_loop_returns_err() {
-    let src = format!("{RHEAD}fun down(n: Int) -> Result[Int, NegError] =\n  if n == 0\n    return Err(Neg)\n  down(n - 1)\n\nfun main() -> Int = down(1000000).unwrapOr(42)\n");
-    assert_eq!(runInt("result_self_loop_returns_err", &src), 42);
-}
-#[test]
-fn result_mutual_million() {
-    let src = format!("{RHEAD}fun ping(n: Int) -> Result[Int, NegError] =\n  if n == 0\n    return Ok(1)\n  pong(n - 1)\n\nfun pong(n: Int) -> Result[Int, NegError] =\n  if n == 0\n    return Ok(2)\n  ping(n - 1)\n\nfun main() -> Int = ping(1000000).unwrapOr(99)\n");
-    assert_eq!(runInt("result_mutual_million", &src), 1);
-}
-#[test]
-fn question_in_tail_not_tail_call() {
-    let src = format!("{RHEAD}fun down(n: Int) -> Result[Int, NegError] =\n  if n == 0\n    return Ok(5)\n  v := down(n - 1)?\n  Ok(v)\n\nfun main() -> Int = down(100).unwrapOr(99)\n");
-    assert_eq!(runInt("question_in_tail_not_tail_call", &src), 5);
-}

compiler/wasm-codegen/tests/wasm_codegen/e2e_tail/loop_break.rs DELETED Viewed

@@ -1,148 +0,0 @@
-use plum_test_support::{runInt, PRE};
-fn prog(body: &str) -> String {
-    format!("{PRE}{body}")
-}
-// Every loop is fuel-bounded (`i < 50`) so a wrong branch depth fails an
-// assertion instead of hanging the test.
-const LST: &str = "
-enum Lst = Nil | Cons(head: Int, tail: Lst)
-fun build(n: Int, acc: Lst) -> Lst =
-  if n == 0 then acc else build(n - 1, Cons(head: n, tail: acc))
-";
-#[test]
-fn break_in_if_in_match_arm_in_while() {
-    let src = prog(&format!(
-        "{LST}
-fun find(xs: Lst, target: Int) -> Int =
-  i := 0
-  cur := xs
-  while i < 50
-    match cur
-      Cons(h, t) =>
-        if h == target
-          break
-        cur = t
-      Nil =>
-        break
-    i = i + 1
-  return i
-fun main() -> Int = find(build(10, Nil), 4) * 100 + find(build(10, Nil), 99)
-"
-    ));
-    assert_eq!(runInt("break_if_match_while", &src), 3 * 100 + 10);
-}
-#[test]
-fn continue_in_if_in_match_arm_in_while() {
-    let src = prog(&format!(
-        "{LST}
-fun sumOdd(xs: Lst) -> Int =
-  total := 0
-  i := 0
-  cur := xs
-  while i < 50
-    i = i + 1
-    match cur
-      Cons(h, t) =>
-        cur = t
-        if h % 2 == 0
-          continue
-        total = total + h
-      Nil =>
-        break
-  return total * 100 + i
-fun main() -> Int = sumOdd(build(6, Nil))
-"
-    ));
-    // 1 + 3 + 5 = 9; seven iterations (six cons cells then Nil).
-    assert_eq!(runInt("continue_if_match_while", &src), 900 + 7);
-}
-#[test]
-fn break_in_match_arm_direct() {
-    let src = prog(&format!(
-        "{LST}
-fun count(xs: Lst) -> Int =
-  i := 0
-  cur := xs
-  while i < 50
-    match cur
-      Nil =>
-        break
-      Cons(h, t) =>
-        cur = t
-    i = i + 1
-  return i
-fun wild(n: Int) -> Int =
-  i := 0
-  while i < 50
-    match i
-      _ =>
-        break
-    i = i + 1
-  return i + n
-fun main() -> Int = count(build(5, Nil)) * 100 + wild(7)
-"
-    ));
-    assert_eq!(runInt("break_match_arm_direct", &src), 5 * 100 + 7);
-}
-#[test]
-fn break_in_else_if_chain_in_while() {
-    let src = prog(
-        "fun main() -> Int =
-  i := 0
-  while i < 50
-    if i == 100
-      i = i + 1000
-    else if i == 100
-      i = i + 2000
-    else if i == 7
-      break
-    i = i + 1
-  return i
-",
-    );
-    assert_eq!(runInt("break_else_if_chain", &src), 7);
-}
-#[test]
-fn nested_loops_with_match_in_inner() {
-    let src = prog(&format!(
-        "{LST}
-fun main() -> Int =
-  outer := 0
-  hits := 0
-  while outer < 50
-    if outer == 3
-      break
-    cur := build(5, Nil)
-    j := 0
-    while j < 50
-      match cur
-        Cons(h, t) =>
-          cur = t
-          if h == 2
-            j = j + 1
-            continue
-          if h == 4
-            break
-          hits = hits + 1
-        Nil =>
-          break
-      j = j + 1
-    outer = outer + 1
-  return outer * 100 + hits
-"
-    ));
-    // inner: h=1 hit, h=2 skipped, h=3 hit, h=4 break => 2 hits per outer pass, 3 passes.
-    assert_eq!(runInt("nested_loops_match", &src), 3 * 100 + 6);
-}

compiler/wasm-codegen/tests/wasm_codegen/e2e_tail/mod.rs CHANGED Viewed

@@ -1,5 +1,3 @@
 #![allow(non_snake_case)]
 mod closure_tail;
-mod error_tail;
-mod loop_break;
 mod tail;

compiler/wasm-codegen/tests/wasm_codegen/e2e_tail/tail.rs CHANGED Viewed

@@ -1,4 +1,4 @@
-use plum_test_support::{compile, runInt, PRE};
+use plum_test_support::{compile, PRE};
 fn prog(body: &str) -> String {
     format!("{PRE}{body}")
@@ -15,119 +15,6 @@ fun sumAcc(xs: Link[Int], acc: Int) -> Int = match xs
   Cons(h, t) => sumAcc(t, acc + h)
 ";
-#[test]
-fn self_tail_million() {
-    let src = prog(&format!(
-        "{LINK}
-fun main() -> Int = sumAcc(build(1000000, Nil), 0)
-"
-    ));
-    assert_eq!(runInt("self_tail_million", &src), 500000500000);
-}
-#[test]
-fn self_tail_args_swap() {
-    let src = prog(
-        "fun gcd(a: Int, b: Int) -> Int = if b == 0 then a else gcd(b, a % b)
-fun swapN(a: Int, b: Int, n: Int) -> Int =
-  if n == 0 then a * 1000 + b else swapN(b, a, n - 1)
-fun main() -> Int = gcd(1071, 462) * 1000000 + swapN(1, 2, 999999)
-",
-    );
-    // gcd = 21; odd swap count leaves (2, 1).
-    assert_eq!(runInt("self_tail_args_swap", &src), 21 * 1000000 + 2001);
-}
-#[test]
-fn mutual_tail_million() {
-    let src = prog(
-        "fun isEven(n: Int) -> Int = if n == 0 then 1 else isOdd(n - 1)
-fun isOdd(n: Int) -> Int = if n == 0 then 0 else isEven(n - 1)
-fun main() -> Int = isEven(1000001) * 10 + isOdd(1000001)
-",
-    );
-    assert_eq!(runInt("mutual_tail_million", &src), 1);
-}
-#[test]
-fn closure_tail_call_runs() {
-    let src = prog(
-        "fun run(n: Int, k: fn(Int) -> Int) -> Int = if n == 0 then 7 else k(n - 1)
-fun go(n: Int) -> Int = run(n, go)
-fun main() -> Int = go(1000000)
-",
-    );
-    assert_eq!(runInt("closure_tail_call_runs", &src), 7);
-}
-#[test]
-fn method_self_tail() {
-    let src = prog(
-        "struct Counter(step: Int) =
-  fun count(self, n: Int, acc: Int) -> Int =
-    if n == 0 then acc else self.count(n - 1, acc + self.step)
-fun main() -> Int = Counter(step: 3).count(1000000, 0)
-",
-    );
-    assert_eq!(runInt("method_self_tail", &src), 3000000);
-}
-#[test]
-fn param_self_tail() {
-    let src = prog(
-        "struct Cell(x: Int, y: Int)
-fun bump(c: Cell, n: Int) -> Cell =
-  if n == 0 then c else bump(Cell(..c, x: c.x + 1), n - 1)
-fun main() -> Int =
-  c := bump(Cell(x: 0, y: 5), 100000)
-  c.x * 10 + c.y
-",
-    );
-    assert_eq!(runInt("param_self_tail", &src), 1000005);
-}
-/// R3: a closure made in one iteration keeps that iteration's parameter value.
-#[test]
-fn closure_captures_iteration_value() {
-    let src = prog(
-        "fun go(i: Int, f: fn(Int) -> Int) -> Int =
-  if i == 3 then f(100) else go(i + 1, |x| x + i)
-fun main() -> Int = go(0, |x| x)
-",
-    );
-    assert_eq!(runInt("closure_captures_iteration_value", &src), 102);
-}
-/// Match arms and else-if chains nest wasm blocks between the call and the loop.
-#[test]
-fn self_tail_through_nested_branches() {
-    let src = prog(
-        "fun f(n: Int, acc: Int) -> Int =
-  if n == 0 then acc
-  else if n % 3 == 0 then f(n - 1, acc + 1)
-  else if n % 3 == 1 then f(n - 1, acc + 10)
-  else f(n - 1, acc + 100)
-fun g(n: Int, acc: Int) -> Int = match n
-  0 => acc
-  k => if k % 2 == 0 then g(k - 1, acc + 2) else g(k - 1, acc + 1)
-fun main() -> Int = f(30, 0) * 1000 + g(10, 0)
-",
-    );
-    assert_eq!(runInt("self_tail_nested", &src), 1110 * 1000 + 15);
-}
 #[derive(Default)]
 struct FnOps {
     calls: Vec<u32>,
@@ -237,39 +124,3 @@ fun main() -> Int = isEven(10)
 }
-const HEAD: &str = "import std/Int\n\n";
-#[test]
-fn tail_call_in_match_arm() {
-    let src = format!("{HEAD}enum Step =\n  | Go(n: Int)\n  | Stop\n\nfun run(s: Step, acc: Int) -> Int = match s\n  Go(n) => run(if n == 0 then Stop else Go(n - 1), acc + 1)\n  Stop => acc\n\nfun main() -> Int = run(Go(1000000), 0)\n");
-    assert_eq!(runInt("match", &src), 1000001);
-}
-#[test]
-fn non_tail_union_wrap_not_tail() {
-    // The callee returns Int but the fn returns Option[Int]: the call is wrapped on the way
-    // out, so it must stay a normal call and still produce the right value.
-    let src = format!("{HEAD}import std/Option\n\nfun inner(n: Int) -> Int = n + 1\n\nfun outer(n: Int) -> Option[Int] = Some(inner(n))\n\nfun main() -> Int =\n  v := outer(41)\n  v.unwrapOr(0)\n");
-    assert_eq!(runInt("wrap", &src), 42);
-}
-#[test]
-fn big_link_built_and_summed() {
-    let src = format!("{HEAD}enum Link =\n  | Nil\n  | Cons(head: Int, tail: Link)\n\nfun build(n: Int, acc: Link) -> Link = if n == 0 then acc else build(n - 1, Cons(n, acc))\n\nfun sum(l: Link, acc: Int) -> Int = match l\n  Nil => acc\n  Cons(h, t) => sum(t, acc + h)\n\nfun main() -> Int = sum(build(200000, Nil), 0)\n");
-    assert_eq!(runInt("link", &src), 200000i64 * 200001 / 2);
-}
-/// TRMC: a map over a native-variant list of 100k elements builds without stack growth.
-#[test]
-fn trmc_link_map_100k() {
-    let src = prog(&format!(
-        "{LINK}
-fun mapInc(xs: Link[Int]) -> Link[Int] = match xs
-  Nil => Nil
-  Cons(h, t) => Cons(head: h + 1, tail: mapInc(t))
-fun main() -> Int = sumAcc(mapInc(build(100000, Nil)), 0)
-"
-    ));
-    assert_eq!(runInt("trmc_link_map_100k", &src), 5000050000 + 100000);
-}

compiler/wasm-codegen/tests/wasm_codegen/e2e_types/closure_optional.rs DELETED Viewed

@@ -1,39 +0,0 @@
-//! F-T3-2: closures whose expected return is `Option[T]` / `Result[T, E]`, calls through an fn-typed
-//! field returning `T?`, and static methods of a generic type that never pin `T`.
-use plum_test_support::*;
-#[test]
-fn closure_coerced_into_optional_return() {
-    let src = "import std/Int\nimport std/Option\n\nfun ap(f: fn() -> Option[Int]) -> Int =\n  f().unwrapOr(0)\n\nfun main() -> Int =\n  ap(|| Some(3))\n";
-    assert_eq!(runInt("opt_present", src), 3);
-}
-#[test]
-fn closure_returning_none_into_optional() {
-    let src = "import std/Int\nimport std/Option\n\nfun ap(f: fn() -> Option[Int]) -> Int =\n  f().unwrapOr(7)\n\nfun main() -> Int =\n  ap(|| None)\n";
-    assert_eq!(runInt("opt_null", src), 7);
-}
-#[test]
-fn closure_into_ref_option_and_result() {
-    let src = "import std/Int\nimport std/Str\nimport std/Option\nimport std/Result\n\nenum BadError = Bad | Worse\n\nfun s(f: fn(Int) -> Option[Str]) -> Str =\n  f(1).unwrapOr(\"none\")\n\nfun e(f: fn(Int) -> Result[Int, BadError]) -> Int =\n  f(1).unwrapOr(9)\n\nfun main() -> Int =\n  b := s(|x| {if x > 0 then Some(\"yes\") else None}).length()\n  b2 := s(|x| Some(\"ab\")).length()\n  c := e(|x| Ok(x + 1))\n  d := e(|x| Err(Bad))\n  b * 1000 + b2 * 100 + c * 10 + d\n";
-    assert_eq!(runInt("opt_mixed", src), 3229);
-}
-#[test]
-fn fn_field_returning_optional() {
-    let src = "import std/Int\nimport std/Option\n\nstruct Gen(next: fn() -> Option[Int])\n\nfun count(g: Gen) -> Int =\n  g.next().unwrapOr(0)\n\nfun main() -> Int =\n  k := 5\n  count(Gen(next: || Some(k)))\n";
-    assert_eq!(runInt("field_opt", src), 5);
-}
-#[test]
-fn static_method_of_generic_type_not_pinning_t() {
-    let src = "import std/Int\n\nstruct Gen[T](v: T) =\n  fun ints(n: Int) -> Gen[Int] = Gen(v: n)\n  fun get(self) -> T = self.v\n\nfun main() -> Int =\n  Gen.ints(4).get()\n";
-    assert_eq!(runInt("static_unpinned", src), 4);
-}
-#[test]
-fn seq_with_optional_next() {
-    let src = "import std/Int\nimport std/Option\n\nstruct Seq[T](next: fn(Int) -> Option[T]) =\n  fun upTo(n: Int) -> Seq[Int] = Seq(next: |i| {if i < n then Some(i * 2) else None})\n  fun sum(self) -> Int =\n    total := 0\n    i := 0\n    while Some(v) := self.next(i)\n      total = total + v\n      i = i + 1\n    total\n\nfun main() -> Int =\n  Seq.upTo(4).sum()\n";
-    assert_eq!(runInt("seq_opt", src), 12);
-}

compiler/wasm-codegen/tests/wasm_codegen/e2e_types/closure_types.rs DELETED Viewed

@@ -1,50 +0,0 @@
-use plum_test_support::*;
-const BOX: &str = "import std/Int\n\nstruct Box(v: Int) =\n  fun get(self) -> Int = self.v\n\n";
-#[test]
-fn g1_typed_param() {
-    let src = format!("{BOX}fun ap(f: fn(Box) -> Int) -> Int = f(Box(v: 2))\n\nfun main() -> Int =\n  ap(|b: Box| b.get())\n");
-    assert_eq!(runInt("g1", &src), 2);
-}
-#[test]
-fn g2_local_closure_inferred_from_first_call() {
-    let src = format!("{BOX}fun main() -> Int =\n  get := |b| b.get()\n  get(Box(v: 2))\n");
-    assert_eq!(runInt("g2", &src), 2);
-}
-#[test]
-fn g5_returned_closure() {
-    let src = "import std/Int\n\nfun adder(n: Int) -> fn(Int) -> Int =\n  |x| x + n\n\nfun main() -> Int =\n  add1 := adder(1)\n  add1(2)\n";
-    assert_eq!(runInt("g5", src), 3);
-}
-// `adder(1)(2)` (call on a call result) does not parse: the grammar has no call-on-call form.
-#[test]
-fn adder_two_levels() {
-    let src = "import std/Int\n\nfun adder(n: Int) -> fn(Int) -> fn(Int) -> Int =\n  |x| |y| x + y + n\n\nfun main() -> Int =\n  f := adder(1)\n  g := f(2)\n  g(3)\n";
-    assert_eq!(runInt("two", src), 6);
-}
-const LINK: &str = "import std/Int\n\nenum Link[T] = Nil | Cons(head: T, tail: Link[T])\n\nfun len[T](xs: Link[T]) -> Int = match xs\n  Nil => 0\n  Cons(_, t) => 1 + len(t)\n\n";
-/// A bare `Nil` whose `T` is fixed by a LATER argument gets the call's `Link[Int]`.
-#[test]
-fn bare_tag_fixed_by_later_arg() {
-    let src = format!("{LINK}fun push[T](xs: Link[T], x: T) -> Link[T] = Cons(head: x, tail: xs)\n\nfun main() -> Int =\n  len(push(push(Nil, 1), 2))\n");
-    assert_eq!(runInt("bare_later", &src), 2);
-}
-#[test]
-fn bare_tag_fixed_by_other_link_arg() {
-    let src = format!("{LINK}fun two[T](a: Link[T], b: Link[T]) -> Int = len(a) + len(b)\n\nfun mk(n: Int) -> Link[Int] = Cons(head: n, tail: Nil)\n\nfun main() -> Int =\n  two(Nil, mk(2)) * 10 + two(mk(1), Nil)\n");
-    assert_eq!(runInt("bare_other", &src), 11);
-}
-#[test]
-fn curried_closure_runs() {
-    let src = "import std/Int\n\nfun curry() -> fn(Int) -> fn(Int) -> Int =\n  |x| |y| x + y\n\nfun main() -> Int =\n  add2 := curry()\n  f := add2(2)\n  f(3)\n";
-    assert_eq!(runInt("curried", src), 5);
-}

compiler/wasm-codegen/tests/wasm_codegen/e2e_types/list_and_shadow.rs DELETED Viewed

@@ -1,81 +0,0 @@
-//! F-T7-1: an unannotated list literal whose first element leaves the enum's generic
-//! unpinned (a later element pins it), and a user type shadowing a std type that std
-//! imports on its own (`std/Int` imports `std/Pair` for `Range.next`).
-use plum_test_support::*;
-const NODE: &str = "\
-import std/Str
-import std/Int
-import std/List
-enum Node[M] =
-  | Box(w: Int)
-  | Tag(msg: M, w: Int)
-  | Group(kids: List[Node[M]])
-  | Wrap(child: Node[M], k: Int)
-  fun total(self) -> Int = match self
-    Box(w) => w
-    Tag(_, w) => w
-    Group(kids) => Node.sumKids(kids)
-    Wrap(child, k) => Node.twice(child, k)
-  fun twice(child: Node[M], k: Int) -> Int = child.total() + child.total() + k
-  fun sumKids(kids: List[Node[M]]) -> Int = match kids
-    Nil => 0
-    Cons(head, tail) => head.total() + Node.sumKids(tail)
-# A second instantiation, so a wrongly pinned element picks a different type.
-fun other(n: Node[Int]) -> Int = n.total()
-fun tagged(s: Str) -> Node[Str] = Tag(msg: s, w: 2)
-";
-#[test]
-fn list_literal_element_pinned_by_a_later_element() {
-    let src = format!(
-        "{NODE}fun view(s: Str) -> Node[Str] =
-  t := tagged(s)
-  Wrap(child: Group(kids: [Box(w: 1), t, Box(w: 3)]), k: 100)
-fun main() -> Int =
-  view(\"x\").total() + other(Box(w: 10))
-"
-    );
-    assert_eq!(runInt("list_pinned_late_fused", &src), 122);
-}
-#[test]
-fn unannotated_local_of_list_pinned_by_a_later_element() {
-    let src = format!(
-        "{NODE}fun view(s: Str) -> Int =
-  t := tagged(s)
-  g := Group(kids: [Box(w: 1), t])
-  q := g
-  g.total() + q.total()
-fun main() -> Int =
-  view(\"x\") + other(Box(w: 10))
-"
-    );
-    assert_eq!(runInt("list_pinned_late_local", &src), 16);
-}
-#[test]
-fn user_type_shadows_std_pair_imported_by_std() {
-    let src = "\
-import std/Int
-struct Pair(a: Int, b: Int) =
-  fun sum(self) -> Int = self.a + self.b
-fun main() -> Int =
-  p := Pair(a: 3, b: 4)
-  for i := range 3
-    p = Pair(a: p.a + i, b: p.b)
-  p.a * 10 + p.sum()
-";
-    assert_eq!(runInt("user_pair", src), 70);
-}

compiler/wasm-codegen/tests/wasm_codegen/e2e_types/mod.rs CHANGED Viewed

@@ -1,9 +1,6 @@
 #![allow(non_snake_case)]
-mod closure_optional;
-mod closure_types;
 mod io_entry;
 mod io_primitive;
-mod list_and_shadow;
 mod question;
 mod subtyping;
 mod synthetic_sites;

compiler/wasm-codegen/tests/wasm_codegen/e2e_types/question.rs CHANGED Viewed

@@ -7,54 +7,6 @@ fn prog(body: &str) -> String {
     format!("{HEAD}{body}")
 }
-#[test]
-fn chained_question_returns_first_err() {
-    let src = prog(
-        "fun pick(n: Int) -> Result[Int, Int] =\n  if n > 0\n    return Ok(n)\n  Err(100 + n)\n\nfun f(x: Int, y: Int, z: Int) -> Result[Int, Int] =\n  p := pick(x)?\n  q := pick(y)?\n  r := pick(z)?\n  Ok(p + q + r)\n\nfun main() -> Int =\n  s := f(1, 2, 3).unwrapOr(0)\n  t := f(1, 0, 0)\n  bad := t.isErr()\n  if bad then s * 1000 + 1 else 0\n",
-    );
-    assert_eq!(runInt("q_chain", &src), 6001);
-}
-#[test]
-fn chained_err_value_is_first() {
-    let src = prog(
-        "fun pick(n: Int) -> Result[Int, Int] =\n  if n > 0\n    return Ok(n)\n  Err(100 + n)\n\nfun f(x: Int, y: Int, z: Int) -> Result[Int, Int] =\n  p := pick(x)?\n  q := pick(y)?\n  r := pick(z)?\n  Ok(p + q + r)\n\nfun main() -> Int =\n  match f(1, -5, -7)\n    Ok(v) => v\n    Err(e) => e\n",
-    );
-    assert_eq!(runInt("q_first_err", &src), 95);
-}
-#[test]
-fn option_question_returns_none() {
-    let src = prog(
-        "fun g(n: Int) -> Option[Int] = if n > 0 then Some(n) else None\n\nfun f(n: Int) -> Option[Int] =\n  v := g(n)?\n  Some(v * 2)\n\nfun main() -> Int =\n  f(4).unwrapOr(-1) * 100 + f(0).unwrapOr(7)\n",
-    );
-    assert_eq!(runInt("q_none", &src), 807);
-}
-#[test]
-fn ok_unit_and_expression_position() {
-    let src = prog(
-        "fun g(n: Int) -> Option[Int] = if n > 0 then Some(n) else None\n\nfun u(n: Int) -> Result[Unit, Int] =\n  if n > 0\n    return Ok(Unit)\n  Err(n)\n\nfun h(n: Int) -> Option[Int] = Some(1 + g(n)?)\n\nfun main() -> Int =\n  a := h(5).unwrapOr(0)\n  b := u(1).isOk()\n  c := u(0).isErr()\n  if b && c then a else -1\n",
-    );
-    assert_eq!(runInt("q_unit_expr", &src), 6);
-}
-#[test]
-fn struct_payload_in_some() {
-    let src = prog(
-        "fun g(n: Int) -> Option[Pt] = if n > 0 then Some(Pt(first: n, second: 2)) else None\n\nfun f(n: Int) -> Option[Int] =\n  p := g(n)?\n  Some(p.first * 10 + p.second)\n\nfun main() -> Int =\n  f(3).unwrapOr(0)\n",
-    );
-    assert_eq!(runInt("q_struct", &src), 32);
-}
-#[test]
-fn bang_unwraps_and_chains() {
-    let src = prog(
-        "fun g(n: Int) -> Option[Pt] = Some(Pt(first: n, second: 2))\n\nfun main() -> Int =\n  x := Some(3)!\n  y := g(4)!.first\n  r: Result[Int, Int] := Ok(5)\n  x + y * 10 + r! * 100\n",
-    );
-    assert_eq!(runInt("q_bang", &src), 543);
-}
 #[test]
 fn bang_on_none_crashes() {
     let src = prog("fun main() -> Int =\n  o: Option[Int] := None\n  o!\n");
@@ -62,99 +14,3 @@ fn bang_on_none_crashes() {
     assert!(std::panic::catch_unwind(|| runInt("q_crash", &src)).is_err());
 }
-#[test]
-fn bare_variants_in_if_branches_take_fn_return_type() {
-    let src = prog(
-        "fun pickInline(flag: Bool, n: Int) -> Result[Int, Int] = if flag then Ok(n) else Err(100 + n)\n\nfun pickBlock(flag: Bool, n: Int) -> Result[Int, Int] =\n  if flag\n    Ok(n)\n  else\n    Err(100 + n)\n\nfun maybe(flag: Bool, n: Int) -> Option[Int] = if flag then None else Some(n)\n\nfun main() -> Int =\n  a := pickInline(false, 1).isErr()\n  b := pickBlock(true, 2).unwrapOr(0)\n  c := maybe(false, 3).unwrapOr(0)\n  d := maybe(true, 3).isNone()\n  if a && d then b * 10 + c else -1\n",
-    );
-    assert_eq!(runInt("q_if_variants", &src), 23);
-}
-#[test]
-fn bare_variants_in_match_arms_take_fn_return_type() {
-    let src = prog(
-        "fun pick(n: Int) -> Result[Int, Int] = match n\n  0 => Err(100)\n  _ => Ok(n)\n\nfun main() -> Int =\n  match pick(0)\n    Ok(v) => v\n    Err(e) => e + pick(4).unwrapOr(0)\n",
-    );
-    assert_eq!(runInt("q_match_variants", &src), 104);
-}
-#[test]
-fn map_err_on_call_result() {
-    let src = prog(
-        "fun fails() -> Result[Int, Int] =\n  r: Result[Int, Int] := Err(7)\n  r\n\nfun main() -> Int =\n  match fails().mapErr(|e| e + 1000)\n    Ok(v) => v\n    Err(e) => e\n",
-    );
-    assert_eq!(runInt("q_map_err", &src), 1007);
-}
-/// mapErr's closure param `f` must not take the arity of a top-level `fun f`.
-#[test]
-fn map_err_closure_param_shadows_top_level_fn() {
-    let src = prog(
-        "fun f(flag: Bool, n: Int) -> Result[Int, Int] = if flag then Ok(n) else Err(100 + n)\n\nfun main() -> Int =\n  match f(false, 1).mapErr(|e| e + 1000)\n    Ok(v) => v\n    Err(e) => e\n",
-    );
-    assert_eq!(runInt("q_shadow", &src), 1101);
-}
-/// An unannotated inline if: each bare variant pins the generic the other leaves open.
-#[test]
-fn inline_if_joins_bare_variant_instantiations() {
-    let src = prog(
-        "fun main() -> Int =\n  flag := 3 > 2\n  o := if flag then Ok(4) else Err(5)\n  low := if flag then Err(1) else Ok(Pt(first: 1, second: 2))\n  a := o.unwrapOr(0)\n  match low\n    Ok(pt) => pt.first\n    Err(e) => a * 10 + e\n",
-    );
-    assert_eq!(runInt("q_if_join", &src), 41);
-}
-/// Fusion inlines `pick(false, 1)` to a bare `Err(101)` and drops `Result[Pt, Int]`
-/// (plum-core simplify), so codegen builds `Ok`'s payload as Unit.
-#[test]
-fn inlined_constant_call_keeps_return_type() {
-    let src = prog(
-        "fun pick(flag: Bool, n: Int) -> Result[Pt, Int] = if flag then Ok(Pt(first: n, second: 1)) else Err(100 + n)\n\nfun main() -> Int =\n  match pick(false, 1)\n    Ok(pt) => pt.first\n    Err(e) => e\n",
-    );
-    assert_eq!(runInt("q_inlined", &src), 101);
-}
-/// Simplify inlines `pick(true, 2)` to `Ok(2)`; drive then fuses `unwrapOr` over `mapErr`
-/// into a fn generic in `E`, which a bare `Ok(2)` never binds (no instance is emitted).
-#[test]
-fn map_err_then_unwrap_or_fuses() {
-    let src = prog(
-        "fun pick(flag: Bool, n: Int) -> Result[Int, Int] = if flag then Ok(n) else Err(100 + n)\n\nfun main() -> Int =\n  pick(true, 2).mapErr(|e| e + 1).unwrapOr(0)\n",
-    );
-    assert_eq!(runInt("q_map_err_unwrap", &src), 2);
-}
-/// Drive specialises `mapErr` / `ok` on the inlined `Err(..)`: the picked arm's own `Err` /
-/// `None` leaves `mapErr` / `ok` and must keep its `Result[Pt, Int]` / `Option[Pt]`.
-#[test]
-fn specialised_arm_keeps_result_type() {
-    let src = prog(
-        "fun pick(flag: Bool, n: Int) -> Result[Pt, Int] = if flag then Ok(Pt(first: n, second: 1)) else Err(100 + n)\n\nfun viaMapErr() -> Int =\n  match pick(false, 2).mapErr(|e| e + 1)\n    Ok(pt) => pt.first\n    Err(e) => e\n\nfun viaOk() -> Int =\n  r := pick(false, 4)\n  match r.ok()\n    Some(pt) => pt.first\n    None => 8\n\nfun main() -> Int = viaMapErr() * 10 + viaOk()\n",
-    );
-    assert_eq!(runInt("q_spec_arm", &src), 1038);
-}
-#[test]
-fn none_as_param_default() {
-    let src = prog(
-        "fun f(n: Option[Int] = None) -> Option[Int] = n\n\nfun main() -> Int =\n  a := f().unwrapOr(7)\n  b := f(Some(3)).unwrapOr(0)\n  a * 10 + b\n",
-    );
-    assert_eq!(runInt("q_none_default", &src), 73);
-}
-#[test]
-fn none_as_generic_param_default() {
-    let src = prog(
-        "fun g[T](x: T, o: Option[T] = None) -> Option[T] = o\n\nfun main() -> Int =\n  a := g(1).unwrapOr(7)\n  b := g(1, Some(3)).unwrapOr(0)\n  a * 10 + b\n",
-    );
-    assert_eq!(runInt("q_none_generic_default", &src), 73);
-}
-#[test]
-fn err_field_is_error() {
-    let src = prog(
-        "fun main() -> Int =\n  r: Result[Int, Int] := Err(error: 5)\n  match r\n    Ok(v) => v\n    Err(e) => e\n",
-    );
-    assert_eq!(runInt("q_err_field", &src), 5);
-}

compiler/wasm-codegen/tests/wasm_codegen/e2e_types/synthetic_sites.rs CHANGED Viewed

@@ -1,118 +1,11 @@
 //! The places codegen reads a type off a name or a call rather than off an expression node of
 //! its own: each runs the shape through the whole pipeline and checks the value.
-use plum_test_support::{compileSource, load, runInt, PRE};
+use plum_test_support::{compileSource, load, PRE};
 fn prog(body: &str) -> String {
     format!("{PRE}{body}")
 }
-/// `Nothing()` (call syntax on a field-less variant) is the variant's
-/// singleton, typed by the call node.
-#[test]
-fn field_less_variant_called_like_a_constructor() {
-    let src = prog("\
-enum Maybe =
-  | Nothing
-  | Just(value: Int)
-fun orZero(m: Maybe) -> Int = match m
-  Nothing => 0
-  Just(v) => v
-fun main() -> Int =
-  a: Maybe := Nothing()
-  b: Maybe := Just(value: 40)
-  orZero(a) + orZero(b) + 2
-");
-    assert_eq!(runInt("nothing_call", &src), 42);
-}
-/// A call through a local closure whose type is only known from the local's own initialiser.
-#[test]
-fn unit_closure_local_called_as_a_statement() {
-    let src = prog("\
-fun main() -> Int =
-  f := || Unit
-  f()
-  f()
-  7
-");
-    assert_eq!(runInt("unit_closure_local", &src), 7);
-}
-/// A rebuild that reuses the matched cell reads the cell's type off the local it names.
-#[test]
-fn reused_cell_is_read_through_its_local() {
-    let src = prog("\
-enum Link =
-  | Nil
-  | Cons(head: Int, tail: Link)
-fun bump(xs: Link) -> Link = match xs
-  Nil => Nil
-  Cons(h, t) => Cons(head: h + 1, tail: t)
-fun sum(xs: Link) -> Int = match xs
-  Nil => 0
-  Cons(h, t) => h + sum(t)
-fun main() -> Int = sum(bump(Cons(head: 1, tail: Cons(head: 2, tail: Nil))))
-");
-    assert_eq!(runInt("reuse_local", &src), 4);
-}
-/// The same call syntax on a variant of a generic enum: the call has the enum's instantiated type.
-#[test]
-fn field_less_variant_of_a_generic_enum_called_like_a_constructor() {
-    let src = prog("\
-enum Maybe[T] =
-  | Nothing
-  | Just(value: T)
-fun orZero(m: Maybe[Int]) -> Int = match m
-  Nothing => 0
-  Just(v) => v
-fun main() -> Int =
-  a: Maybe[Int] := Nothing()
-  b: Maybe[Int] := Just(value: 40)
-  orZero(a) + orZero(b) + 2
-");
-    assert_eq!(runInt("nothing_call_generic", &src), 42);
-}
-/// F-T9-2: a closure calling itself with `None` for an `Option[Int]` param. The checker
-/// types that `None` as `Option[Unit]`; the param's declared type picks the singleton, so the
-/// wasm is valid and the value right.
-#[test]
-fn closure_passes_none_to_an_option_param() {
-    let src = prog("\
-import std/Option
-fun main() -> Int =
-  rec := |o: Option[Int], acc: Int, n: Int|
-    if n <= 0 then acc else rec(None, acc + 1, n - 1)
-  rec(None, 0, 3)
-");
-    assert_eq!(runInt("closure_none_typed", &src), 3);
-}
-#[test]
-fn untyped_closure_passes_none_to_an_option_param() {
-    let src = prog("\
-import std/Option
-fun run(n: Int, o: Option[Int]) -> Int =
-  rec := |o, acc, n|
-    if n <= 0 then 0 else rec(None, acc + 1, n - 1)
-  rec(o, 0, n)
-fun main() -> Int =
-  run(3, None)
-");
-    assert_eq!(runInt("closure_none_untyped", &src), 0);
-}
 /// F-T9-1: a call to an unknown function reports that, not the missing type of its
 /// (unchecked) arguments.
 #[test]

compiler/wasm-codegen/tests/wasm_codegen/e2e_types/type_param_static.rs CHANGED Viewed

@@ -1,36 +1,5 @@
 use plum_test_support::*;
-#[test]
-fn static_on_type_param() {
-    let src = "\
-import std/Int
-struct Pt(x: Int) =
-  fun make(n: Int) -> Pt = Pt(x: n * 10)
-fun build[T](n: Int) -> T = T.make(n)
-fun main() -> Int =
-  p: Pt := build(3)
-  return p.x
-";
-    assert_eq!(runInt("rec", src), 30);
-}
-#[test]
-fn static_on_builtin() {
-    let src = "\
-import std/Int
-fun maxOf[T](n: Int) -> T = T.Max
-fun main() -> Int =
-  m: Int := maxOf(1)
-  return if m == Int.Max then 1 else 0
-";
-    assert_eq!(runInt("builtin", src), 1);
-}
 #[test]
 fn static_missing_reports() {
     let src = "\
@@ -52,50 +21,6 @@ fun main() -> Int =
     );
 }
-#[test]
-fn nested_generic() {
-    let src = "\
-import std/Int
-import std/Slice
-import std/List
-struct Pt(x: Int) =
-  fun make(n: Int) -> Pt = Pt(x: n + 1)
-fun buildAll[T](ns: Slice[Int]) -> Slice[T] =
-  out := Slice[T]()
-  for n := range ns
-    out.push(T.make(n))
-  return out
-fun main() -> Int =
-  ps: Slice[Pt] := buildAll([1, 2, 3].toSlice())
-  p := ps.get(2).unwrapOr(Pt(x: 0))
-  return p.x
-";
-    assert_eq!(runInt("nested", src), 4);
-}
-#[test]
-fn static_on_builtin_method_and_json_cycle() {
-    let src = "\
-import std/Int
-import std/Str
-import std/Json
-import std/Result
-fun parseIt[T](s: Str) -> Result[T, NumError] =
-  T.parse(s)
-fun main() -> Int =
-  r: Result[Int, NumError] := parseIt(\"41\")
-  n := r.unwrapOr(0)
-  j := n.toJson()
-  return n + 1
-";
-    assert_eq!(runInt("builtin_method", src), 42);
-}
 #[test]
 fn extension_outside_std_is_rejected() {
     let src = "\
@@ -130,11 +55,3 @@ fun main() -> Int =
     };
     assert!(!errs.is_empty(), "toJson must not exist without std/Json");
 }
-/// Single uppercase letters are ordinary names: a struct, enum variants, a constant, and a
-/// declared multi-letter fn generic all work side by side.
-#[test]
-fn single_letter_types_and_variants() {
-    let src = "import std/Int\n\nstruct P(x: Int)\n\nenum Two = A | B\n\nstruct Cfg(n: Int) =\n  E = 5\n\nfun pick(t: Two) -> Int = match t\n  A => 1\n  B => 20\n\nfun id[Elem](x: Elem) -> Elem = x\n\nfun main() -> Int =\n  p := P(x: id(3))\n  pick(A) + pick(B) + p.x + Cfg.E\n";
-    assert_eq!(runInt("single_letter_types", src), 29);
-}

docs/backlog.md CHANGED Viewed

@@ -4,7 +4,7 @@ Open work, in the order the user queued it, plus smaller items found during buil
 ## Planned (in order)
-**Current order (user 2026-11-05):** explicit fn generics (done faa4d7e) → cleanup phase 3b (pass list, positioned errors; running)  → Io primitive + extern methods → move Rust crates under `compiler/` → tooling + scripts moved under compiler/ (done) → cleanup phase 4 (done: node ids, typed codegen, `inferExpr` errors at spans; `docs/plans/2026-11-05-compiler-cleanup-phase4.results.md`) → phase 5 (file splits, enum kinds) → phase 6 (tests in Plum) → benchmark (incl. iterator unboxing / niche Option, run C game A/B) → FBIP (stop for user approval) → deterministic sim → kids' games. The items below keep their detail; this line wins on order.
+**Current order (user 2026-11-05):** explicit fn generics (done faa4d7e) → cleanup phase 3b (pass list, positioned errors; running)  → Io primitive + extern methods → move Rust crates under `compiler/` → tooling + scripts moved under compiler/ (done) → cleanup phase 4 (done: node ids, typed codegen, `inferExpr` errors at spans; `docs/plans/2026-11-05-compiler-cleanup-phase4.results.md`) → phases 5 and 6 (done: file splits, type kinds, tests in Plum; `docs/plans/2026-11-05-compiler-cleanup-phase5-6.results.md`) → benchmark (incl. iterator unboxing / niche Option, run C game A/B) → FBIP (stop for user approval) → deterministic sim → kids' games. The items below keep their detail; this line wins on order.
 1. **Compiler cleanup and architecture** — `docs/plans/2026-11-04-compiler-cleanup.review.md` (written in another session; meant to run after language-restrictions merged). Approved 2026-11-04; running on branch `superlite/compiler-cleanup`, phase 1 first.
    - **Explicit function generics** (user 2026-11-04: right after cleanup phase 2) — functions declare their generics (`fun map[B](...)`) instead of every single capital letter being a generic; allows longer generic names and one-letter concrete types/tags. Grammar change + about 140 signatures in std/examples. Phase 2's "generics by scope" makes this mostly a grammar + signature rewrite.

docs/plans/2026-11-05-compiler-cleanup-phase5-6.md CHANGED Viewed

@@ -112,7 +112,7 @@ e.g. `test "deep tail recursion"` running a 200000-step self-tail call, a method
 **Test code:** the new test passes; sweep with the new folder.
 ### T7 move wasm_codegen run tests · Complexity 4 · Est. context 50k
-**Owns:** compiler/wasm-codegen/tests/wasm_codegen/**/*.rs, compiler/tests/codegen/*.plum
+**Owns:** compiler/wasm-codegen/tests/wasm_codegen/**/*.rs, compiler/tests/wasm_codegen/**/*.plum
 **Components:** 1
 **LOC owned:** 200
 **Tests:** fast

docs/plans/2026-11-05-compiler-cleanup-phase5-6.progress.md ADDED Viewed

@@ -0,0 +1,26 @@
+- start 5ecf1ab
+Ruling: lint --max-task-min 25 for this plan - the predictor's history took in the last run's inflated timings (a 20-line results doc predicted at 19 min), so every task failed the 15 min limit; sizes are unchanged - cost: a task may run long
+Ruling: accept predicted 132 min over the 90 min target for the same reason; the predictor overstates it - cost: none
+Ruling: skip Wave 0 - no shared stubs - cost: none
+- unblocked: dispatched T1 T2 at 22:37:01; waiting on fixes: none
+Ruling: T2 waits for T1 despite the plan graph - wasm-codegen depends on plum-checker, so T2 can't build while T1 has the checker half moved - cost: about 15 min
+- checkpoint T1 7c6a0a8056 checker split
+- checkpoint T2 ed3a336e1c codegen split
+Ruling: T1 and T2 pure moves verified by a coordinator sorted-line check against HEAD instead of a reviewer - cost: none
+- checkpoint T3 56805e9736 codegen driver stages
+- unblocked: dispatched T4 prime at 22:59:17; waiting on fixes: T3 review
+Ruling: T3 review clean - statement order unchanged, no early returns, taken fields read only before they are taken; closure-only and tests-only files not exercised by it, covered by examples and std - cost: none
+- unblocked: dispatched T4 at 23:01:46; waiting on fixes: none
+- checkpoint T4 22338aefb9 type kinds
+Ruling: T5 run by the coordinator with a script - verification only, no judgement needed - cost: none
+- checkpoint T5 68cfdf7f34 verify phase 5
+- unblocked: dispatched T6 at 23:10:49; waiting on fixes: none
+- checkpoint T6 a4c7b4a80c Plum test home and tail-call proof
+- unblocked: dispatched T7 T8 at 23:13:34; waiting on fixes: none
+- checkpoint T8 dc0ff3997b move other run tests
+- checkpoint T7 47565d6c8e move wasm_codegen run tests
+Ruling: T7 Owns moved to compiler/tests/wasm_codegen - .gitignore ignores any path named codegen - cost: none
+- tests full passed=741 failed=0 skipped=0 seconds=49.3
+Ruling: final review - three findings, all "the packet shows no evidence", no defect. Evidence exists: T1 and T2 sorted-line check, 0 of about 12,500 lines lost; T3 and T4 reviews, statement order unchanged and wasm identical; 108 of 108 moved tests mapped with no value or program change; a flipped assert fails in each folder; counts 1510 before, 1514 after. Recorded as verified - cost: none
+Ruling: T7 and T8 checkpoint with a pathspec error on deleted files; the moves are committed directly and verified above - cost: none
+Ruling: run_tests --full is not the 14-binary check; verify_all.sh is - cost: none

docs/plans/2026-11-05-compiler-cleanup-phase5-6.results.md CHANGED Viewed

@@ -27,3 +27,39 @@ The T1 and T2 splits are pure moves. A sorted-line comparison against the previo
 **One behaviour note:** a user function literally named `__test_x` used to be skipped by a few passes, because they matched on the name. It no longer is. That name was never a supported way to mark a test.
 **Also fixed:** `compileEntryTests` shared one temp directory and failed about half the time under parallel threads. It now passes 20 of 20 runs.
+## Phase 6: tests in Plum
+**The gate passed.** The review plan only allows this phase if `plum test` runs tail calls the way a compiled program does. `compiler/tests/tail_calls.plum` runs a self, a method and a closure tail call each 1,000,000 deep. A non-tail version at that depth traps and is reported as a failure, so the test can tell the difference.
+| Check | Before | After |
+|---|---|---|
+| Rust tests, all 14 binaries | 848 | 740 (core 395, wasm_codegen 119, the rest unchanged) |
+| Plum tests in the sweep | 662 | 774, with `compiler/tests` added |
+| Total | 1,510 | 1,514 |
+| Example wasm | | byte-identical, 25 files |
+| Browser (stress_scene, imperative, functional, pure) | | PASS |
+The sweep is now `target/debug/plum test std examples compiler/tests`.
+**What moved:** 108 Rust tests, 102 from wasm_codegen and 6 from core, more than the 90 planned. They became 109 Plum tests, because one test that made two runs became two files. T6 adds 3 tail-call tests.
+**How the move was checked:**
+- A script mapped every removed Rust test to its Plum twin: 108 of 108 found, 0 with a different expected value or program.
+- Flipping an expected value made `plum test` fail, tried in each folder.
+- Every original compared an exact `Int`, so no assertion became weaker.
+- No behaviour differences: every moved test passed first time.
+- The explanatory comments moved too, 39 lines.
+**What stayed in Rust:** compile-error tests, wasm structure checks, traps and crashes, fusion decisions, CLI behaviour, and most of core and checker, because those assert a pass's output or an error message rather than a program's answer.
+**Costs:**
+- 103 of the new tests are one file each, because programs in one file share a namespace and these reuse names like `Link`. Each compiles separately.
+- `plum test compiler/tests` takes about 20 seconds, and the Rust suite is correspondingly shorter.
+- `.gitignore` ignores any path named `codegen`, so these live in `compiler/tests/wasm_codegen/` and the plan's path was updated.
+- Test bodies skip the tail, TRMC, closure-spec and drive passes, so moved programs keep their logic in helper functions. New tests need to do the same.
+## Not verified
+- Frame times against `BENCHMARK.md`. The browser runs are headless and capped, so the numbers don't compare. The benchmark item is still queued.
+- WebKit, release builds, and the LSP in an editor.