529a106 | plum | pyrossh

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

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

529a106 — Peter John 2026-11-04T19:25:01+05:30

Compiler cleanup phase 2b: one front end, one compile entry, no Expr::Paren

Files changed (40) hide show

docs/plans/2026-11-04-compiler-cleanup-phase2b.progress.md +28 -0
docs/plans/2026-11-04-compiler-cleanup-phase2b.report.json +269 -0
docs/plans/2026-11-04-compiler-cleanup-phase2b.report.md +38 -0
docs/plans/2026-11-04-compiler-cleanup-phase2b.results.md +19 -0
plum-checker/src/lib.rs +67 -7
plum-checker/tests/checker_tests.rs +1 -1
plum-cli/src/main.rs +29 -16
plum-core/src/ast.rs +1 -3
plum-core/src/builtin_usage.rs +0 -1
plum-core/src/closure_escape.rs +1 -1
plum-core/src/closure_spec.rs +1 -22
plum-core/src/ctors.rs +0 -1
plum-core/src/drive.rs +12 -13
plum-core/src/lib.rs +2 -0
plum-core/src/loader.rs +3 -27
plum-core/src/lower.rs +40 -0
plum-core/src/parser.rs +5 -5
plum-core/src/purity.rs +1 -2
plum-core/src/reuse.rs +0 -1
plum-core/src/simplify.rs +2 -38
plum-core/src/tail.rs +0 -1
plum-core/src/tests_lower.rs +265 -0
plum-core/src/trmc.rs +0 -3
plum-core/src/union_lower.rs +2 -3
plum-core/src/unions.rs +1 -1
plum-core/src/uniqueness.rs +6 -8
plum-core/src/visit.rs +28 -10
plum-core/src/whistle.rs +0 -1
plum-core/tests/inline_variants_test.rs +2 -2
plum-core/tests/loader_test.rs +31 -0
plum-core/tests/lower_test.rs +19 -0
plum-core/tests/parser_test.rs +11 -3
plum-core/tests/tests_lower_test.rs +39 -0
plum-core/tests/uniqueness_test.rs +0 -1
plum-core/tests/visit_test.rs +0 -6
plum-game/tests/host_test.rs +1 -2
plum-lsp/src/completion.rs +1 -1
plum-lsp/src/main.rs +6 -6
plum-wasm-codegen/src/lib.rs +71 -305
plum-wasm-codegen/tests/codegen_tests.rs +7 -2

docs/plans/2026-11-04-compiler-cleanup-phase2b.progress.md ADDED Viewed

@@ -0,0 +1,28 @@
+- start bb462a8697f7486294f44f87a74a2f915eea82ca
+- unblocked: dispatched T0 T1 T2 T6 at 18:13:17; waiting on fixes: T3 T4 T5 T7 T8
+- Ruling: T0 skipped - test-cmd.json copied from 2a (no stubs needed); tasks sent with the prime in one message to save a round trip - cost: none
+- unblocked: dispatched T3 T4 T5 T7 T8 T9 T10 at 18:14:29; waiting on fixes: none
+- Ruling: accept predicted 47 min - codegen lib.rs edits are sequential (tests lowering, compile entry, Paren) - cost: time
+- checkpoint T6 8f258a247c last walker helpers into visit
+- Ruling: closure_spec's private walkRef/walkBlockRef switch to visit in T7 (T7 owns plum-core/src/*.rs) - cost: none
+- checkpoint T1 f5405c9ca3 front-end entry
+- checkpoint T10 c61a9566d8 checker takes fusion options
+- Ruling: T2 Owns narrowed to the files it changed (parser.rs, loader_test.rs, LSP main/completion) - the 'except' globs were not parsed by checkpoint - cost: none
+- checkpoint T2 d634497c6d parseSource runs the front end
+- checkpoint T2 f92fc40647 parseSource runs the front end
+- checkpoint T1 4ca8c7e354 front-end entry
+- Ruling: T3 checkpointed from its files (tests_lower_test 3/3 pass) - its agent hung on a background job for 30+ min without reporting - cost: none
+- checkpoint T3 85f7a1dba9 tests lowering in plum-core
+- checkpoint T9 a9fbb02c24 codegen uses core tests lowering
+- Note: stale desugarTestsToFns doc comments at plum-cli/src/main.rs:477 (T5 fixes) and plum-core/src/ast.rs:387 (T7 fixes)
+- checkpoint T4 13d786ee00 one compile entry
+- checkpoint T5 8c24ab957f compile callers
+- Ruling: CLI keeps one OnceLock for the fusion flags (set once from argv; game.rs calls compileToWasm without options) - the checker thread-local still goes in T7 - cost: one CLI-local global
+- Ruling: compile's empty file name + CLI nameFileInErrors text rewrite stay until phase 3's positioned errors - cost: one string hack survives a phase
+- Ruling: FUSION_OPTIONS thread-local stays (fusion_alloc_test, e2e_mem/reuse, trmc_test set it via withFusionOptions); removing it means moving those tests to compile(opts) - deferred to phase 3 state work - cost: one checker thread-local survives
+- Ruling: T7 owns uniqueness_test/visit_test (unparen removal) and the 3 failing tests' files for the follow-up fix F-T7-1
+- checkpoint T7 946052a832 remove Expr::Paren and deprecated wrappers
+- checkpoint T7 76cdc81c69 remove Expr::Paren and deprecated wrappers
+- tests full passed=802 failed=0 skipped=0 seconds=170.5
+- checkpoint T8 b0a3f49179 verify 2b
+- Ruling: final-review incident [1] closed - loader_test.rs joined T2's Owns (ae151f9), T2 checkpointed it (d634497) and F-T2-1 re-checkpointed it with the inline-variant case (f92fc40); the +31 lines are single_file_equals_loader - cost: none

docs/plans/2026-11-04-compiler-cleanup-phase2b.report.json ADDED Viewed

@@ -0,0 +1,269 @@
+{
+ "projection_note": "projection: fixed forecast saved at lint 2026-11-04T18:13:08 (plan edited since)",
+ "headline": {
+  "wall_min": {
+   "projected": 45.935,
+   "actual": 70.79
+  },
+  "cost_usd_agents": {
+   "projected": 0.723599,
+   "actual": 2.656721
+  },
+  "task_min": {
+   "projected": 53.418,
+   "actual": 73.672
+  },
+  "agents": {
+   "projected": 8,
+   "actual": 9
+  }
+ },
+ "feature": null,
+ "cost_split": {
+  "agents_usd": 2.1839,
+  "rework_usd": 0.472821,
+  "coordinator_usd": 24.04081,
+  "total_usd": 26.697531
+ },
+ "concurrency": {
+  "peak": 3,
+  "projected_peak": 2
+ },
+ "critical_path": {
+  "actual": [
+   "T1",
+   "T3",
+   "T4",
+   "T5",
+   "T7",
+   "T8",
+   "T9"
+  ],
+  "projected": [
+   "T1",
+   "T3",
+   "T4",
+   "T5",
+   "T7",
+   "T8"
+  ],
+  "projected_min": 45.935
+ },
+ "model_mix": {
+  "sonnet": {
+   "tasks": 10,
+   "cost_usd": 2.656721
+  }
+ },
+ "coordinator_cost_by_model": {
+  "opus": 24.04081
+ },
+ "quality": {
+  "tests": {
+   "passed": 802,
+   "failed": 0,
+   "skipped": 0,
+   "seconds": 170.5,
+   "mode": "full",
+   "failures": [],
+   "skipped_tests": []
+  },
+  "first_time_pass": 0,
+  "first_time_n": 0,
+  "rework_dispatches": 2,
+  "open_incidents": 1
+ },
+ "tasks": [
+  {
+   "task": "T3",
+   "model": "sonnet",
+   "pred_min": 12.875,
+   "actual_min": 32.065,
+   "delta": {
+    "abs": 19.19,
+    "pct": 149.0
+   },
+   "cost_usd": 0.213797,
+   "first_time_pass": null
+  },
+  {
+   "task": "T4",
+   "model": "sonnet",
+   "pred_min": 8.859,
+   "actual_min": 2.787,
+   "delta": {
+    "abs": -6.0723,
+    "pct": -68.5
+   },
+   "cost_usd": 0.15933,
+   "first_time_pass": null
+  },
+  {
+   "task": "T8",
+   "model": "sonnet",
+   "pred_min": 5.973,
+   "actual_min": 10.852,
+   "delta": {
+    "abs": 4.8787,
+    "pct": 81.7
+   },
+   "cost_usd": 0.276194,
+   "first_time_pass": null
+  },
+  {
+   "task": "T5",
+   "model": "sonnet",
+   "pred_min": 6.6,
+   "actual_min": 3.933,
+   "delta": {
+    "abs": -2.6667,
+    "pct": -40.4
+   },
+   "cost_usd": 0.306469,
+   "first_time_pass": null
+  },
+  {
+   "task": "T2",
+   "model": "sonnet",
+   "pred_min": 4.4,
+   "actual_min": 6.353,
+   "delta": {
+    "abs": 1.9533,
+    "pct": 44.4
+   },
+   "cost_usd": 0.548189,
+   "first_time_pass": null
+  },
+  {
+   "task": "T7",
+   "model": "sonnet",
+   "pred_min": 7.918,
+   "actual_min": 6.223,
+   "delta": {
+    "abs": -1.6947,
+    "pct": -21.4
+   },
+   "cost_usd": 0.574766,
+   "first_time_pass": null
+  },
+  {
+   "task": "T6",
+   "model": "sonnet",
+   "pred_min": 3.083,
+   "actual_min": 1.62,
+   "delta": {
+    "abs": -1.463,
+    "pct": -47.5
+   },
+   "cost_usd": 0.108093,
+   "first_time_pass": null
+  },
+  {
+   "task": "T1",
+   "model": "sonnet",
+   "pred_min": 3.71,
+   "actual_min": 2.915,
+   "delta": {
+    "abs": -0.795,
+    "pct": -21.4
+   },
+   "cost_usd": 0.149792,
+   "first_time_pass": null
+  },
+  {
+   "task": "T10",
+   "model": "sonnet",
+   "pred_min": null,
+   "actual_min": 1.973,
+   "delta": {
+    "abs": null,
+    "pct": null
+   },
+   "cost_usd": 0.119462,
+   "first_time_pass": null
+  },
+  {
+   "task": "T9",
+   "model": "sonnet",
+   "pred_min": null,
+   "actual_min": 4.95,
+   "delta": {
+    "abs": null,
+    "pct": null
+   },
+   "cost_usd": 0.200629,
+   "first_time_pass": null
+  }
+ ],
+ "cost_table": {
+  "source": "est",
+  "usd": 2.7859,
+  "tokens": 9375859,
+  "wall_min": 89690001.3646,
+  "rows": [
+   {
+    "agent": "a2884f220f51ad6d6",
+    "model": "sonnet",
+    "wall_min": 5.2402,
+    "tokens": 615127,
+    "usd": 0.2049
+   },
+   {
+    "agent": "a2df9f2025916c02a",
+    "model": "sonnet",
+    "wall_min": 6.886,
+    "tokens": 850853,
+    "usd": 0.2679
+   },
+   {
+    "agent": "a3820f0f9eb086e58",
+    "model": "sonnet",
+    "wall_min": 53.1566,
+    "tokens": 5047272,
+    "usd": 1.1558
+   },
+   {
+    "agent": "a4d4e8f4797e03d68",
+    "model": "opus",
+    "wall_min": 0.2249,
+    "tokens": 35927,
+    "usd": 0.1291
+   },
+   {
+    "agent": "a6fae2e1ec0b23393",
+    "model": "sonnet",
+    "wall_min": 29896601.3284,
+    "tokens": 0,
+    "usd": 0.0
+   },
+   {
+    "agent": "a70bd6caeed71f519",
+    "model": "sonnet",
+    "wall_min": 70.8345,
+    "tokens": 2113838,
+    "usd": 0.6646
+   },
+   {
+    "agent": "a933bd66026369ed1",
+    "model": "sonnet",
+    "wall_min": 29896604.2455,
+    "tokens": 0,
+    "usd": 0.0
+   },
+   {
+    "agent": "ad1dfc0fc5bf84734",
+    "model": "sonnet",
+    "wall_min": 35.3493,
+    "tokens": 712842,
+    "usd": 0.3636
+   },
+   {
+    "agent": "af62a03b093783026",
+    "model": "sonnet",
+    "wall_min": 29896624.0992,
+    "tokens": 0,
+    "usd": 0.0
+   }
+  ]
+ }
+}

docs/plans/2026-11-04-compiler-cleanup-phase2b.report.md ADDED Viewed

@@ -0,0 +1,38 @@
+# superlite build report
+projection: fixed forecast saved at lint 2026-11-04T18:13:08 (plan edited since)
+                         Projected    Actual  Delta
+wall-clock (min)              45.9      70.8  +24.9 (+54%)
+agent cost (USD, +rework)      0.72      2.66  +1.93 (+267%)
+task-minutes                  53.4      73.7  +20.3 (+38%)
+agents                           8         9  +1 (+12%)
+cost split: agents $2.18, rework $0.47, coordinator $24.04, total $26.70
+concurrency: peak 3 at once (projected 2); critical path actual T1 T3 T4 T5 T7 T8 T9; projected T1 > T3 > T4 > T5 > T7 > T8 (45.9 min)
+model mix: sonnet 10 tasks $2.66, coordinator opus $24.04
+quality: tests 802 passed, 0 failed; first-time pass n/a; rework dispatches 2; open incidents 1
+task  model      pred  actual  delta             cost
+T3    sonnet     12.9    32.1  +19.2 (+149%)   $0.214
+T4    sonnet      8.9     2.8  -6.1 (-68%)     $0.159
+T8    sonnet      6.0    10.9  +4.9 (+82%)     $0.276
+T5    sonnet      6.6     3.9  -2.7 (-40%)     $0.306
+T2    sonnet      4.4     6.4  +2.0 (+44%)     $0.548
+(+5 smaller misses; `superlite-cli report --json` lists all)
+agent cost table:
+| agent | model | wall_min | tokens | usd |
+| --- | --- | --- | --- | --- |
+| a2884f220f51ad6d6 | sonnet | 5.2402 | 615127 | 0.2049 |
+| a2df9f2025916c02a | sonnet | 6.886 | 850853 | 0.2679 |
+| a3820f0f9eb086e58 | sonnet | 53.1566 | 5047272 | 1.1558 |
+| a4d4e8f4797e03d68 | opus | 0.2249 | 35927 | 0.1291 |
+| a6fae2e1ec0b23393 | sonnet | 29896601.3284 | 0 | 0.0 |
+| a70bd6caeed71f519 | sonnet | 70.8345 | 2113838 | 0.6646 |
+| a933bd66026369ed1 | sonnet | 29896604.2455 | 0 | 0.0 |
+| ad1dfc0fc5bf84734 | sonnet | 35.3493 | 712842 | 0.3636 |
+| af62a03b093783026 | sonnet | 29896624.0992 | 0 | 0.0 |
+| totals |  | 89690001.3646 | 9375859 | 2.7859 |
+cost source: est
+takeaway: ran 54% slower than projected; cost 267% over; biggest miss T3

docs/plans/2026-11-04-compiler-cleanup-phase2b.results.md ADDED Viewed

@@ -0,0 +1,19 @@
+# Phase 2b results
+Start sha: bb462a8697f7486294f44f87a74a2f915eea82ca. Measured on the uncommitted worktree tree.
+- Wasm hashes: all 25 plum-examples files compile, no FAIL, sha256 identical (diff of start-sha vs current lists empty).
+- `plum test plum-std plum-examples`: 678 passed, 0 failed (63/63 files).
+- plum-game host_test: 18 passed, 0 failed.
+- `plum game plum-examples/games/imperative/game.plum -o DIR`: wrote index.html, plum.wasm, plum_bridge.js, preload.txt, assets.
+- `grep -rn "Expr::Paren" plum-*/src`: empty.
+- Full workspace test binaries: not run by this task (the coordinator ran `cargo test`).
+| metric | start | now |
+|---|---|---|
+| Rust LOC (plum-*/**/*.rs, incl. plum-game) | 54538 | 54700 |
+| .rs files | 126 | 130 |
+| integration test files (plum-*/tests/*.rs) | 45 | 47 |
+| `#[test]` fns | 830 | 840 |
+New files: plum-core/src/lower.rs, tests_lower.rs, tests/lower_test.rs, tests/tests_lower_test.rs.

plum-checker/src/lib.rs CHANGED Viewed

@@ -925,7 +925,6 @@ pub fn unify(t1: &PlumType, t2: &PlumType, ctx: &CheckCtx) -> Result<(), String>
 /// or names one.
 fn exprIsVariant(expr: &ast::Expr, variant_name: &str) -> bool {
     match expr {
-        ast::Expr::Paren(inner) => exprIsVariant(inner, variant_name),
         ast::Expr::TypeName(n) => n == variant_name,
         ast::Expr::FnCall(call) => call.name == variant_name,
         ast::Expr::ClassCall(call) => call.type_name == variant_name,
@@ -1267,6 +1266,11 @@ fn immutableFieldOwner(obj_ty: &PlumType, field: &str, ctx: &CheckCtx) -> Option
 }
 pub fn typedSource(source: &ast::Source) -> CheckResult<TypedInfo> {
+    typedSourceWith(source, fusionOptions())
+}
+/// Like `typedSource` with explicit fusion options (no thread-local read).
+pub fn typedSourceWith(source: &ast::Source, fusion: FusionOptions) -> CheckResult<TypedInfo> {
     let (mut result, mut info) = checkSourceFull(source);
     // Closure specialisation and fusion run on the checked program BEFORE union lowering
     // (`pre`: own generics applied, `for` loops lowered), so the passes never see the
@@ -1287,10 +1291,10 @@ pub fn typedSource(source: &ast::Source) -> CheckResult<TypedInfo> {
         }
         // Supercompiler stage: purity -> simplify -> drive -> uniqueness -> reuse.
         // `--no-fusion` skips it.
-        if fusionOptions().enabled {
+        if fusion.enabled {
             let mut copy = pre.clone();
             let notes = fusionRewrite(&mut copy);
-            if fusionOptions().explain {
+            if fusion.explain {
                 for n in &notes {
                     eprintln!("fusion: {n}");
                 }
@@ -3047,7 +3051,7 @@ fn firstCallInExpr<'a>(expr: &'a ast::Expr, name: &str) -> Option<ClosureUse<'a>
         ast::Expr::Binary(b) => firstCallInExpr(&b.left, name).or_else(|| firstCallInExpr(&b.right, name)),
         ast::Expr::Bool(b) => firstCallInExpr(&b.left, name).or_else(|| firstCallInExpr(&b.right, name)),
         ast::Expr::Compare(c) => firstCallInExpr(&c.left, name).or_else(|| firstCallInExpr(&c.right, name)),
-        ast::Expr::Not(e) | ast::Expr::Paren(e) | ast::Expr::Try(e) => firstCallInExpr(e, name),
+        ast::Expr::Not(e) | ast::Expr::Try(e) => firstCallInExpr(e, name),
         ast::Expr::Unary(u) => firstCallInExpr(&u.operand, name),
         ast::Expr::InlineIf(t) => firstCallInExpr(&t.condition, name)
             .or_else(|| firstCallInExpr(&t.then, name))
@@ -3611,7 +3615,7 @@ fn discardedCall(e: &ast::Expr) -> Option<&ast::FnCall> {
             ast::AttrKind::Field(_) => None,
         },
         ast::Expr::Bang(b) => discardedCall(&b.value),
-        ast::Expr::Try(inner) | ast::Expr::Paren(inner) => discardedCall(inner),
+        ast::Expr::Try(inner) => discardedCall(inner),
         _ => None,
     }
 }
@@ -4367,7 +4371,7 @@ fn resolveClosureParamFromFieldUsage(
                 scanExpr(&b.left, params, ctx, resolved);
                 scanExpr(&b.right, params, ctx, resolved);
             }
-            ast::Expr::Not(inner) | ast::Expr::Paren(inner) => {
+            ast::Expr::Not(inner) => {
                 scanExpr(inner, params, ctx, resolved)
             }
             ast::Expr::Unary(u) => scanExpr(&u.operand, params, ctx, resolved),
@@ -5167,7 +5171,6 @@ fn inferExprInner(
                 },
             },
         },
-        ast::Expr::Paren(inner) => inferExprWith(inner, env, ctx, successExpected(expected)),
         // `try expr`: the operand's error set must fit the enclosing fn's set.
         ast::Expr::Try(inner) => {
             if let (Some(star), true) = (env.get(STAR_KEY), env.contains_key(RETURN_KEY)) {
@@ -5730,3 +5733,60 @@ fn nameFormErrors(source: &ast::Source, errs: Vec<CheckError>) -> Vec<CheckError
         })
         .collect()
 }
+#[cfg(test)]
+mod fusion_options_tests {
+    use super::*;
+    use plum_test_support::parse;
+    const SRC: &str = "\
+enum Cells =
+  | Cons(head: Int, tail: Cells)
+  | Nil
+fun mapCells(xs: Cells) -> Cells = match xs
+  Cons(h, t) => Cons(head: h * 2, tail: mapCells(t))
+  Nil => Nil
+fun sumL(xs: Cells) -> Int = match xs
+  Cons(h, t) => h + sumL(t)
+  Nil => 0
+fun total(xs: Cells) -> Int = sumL(mapCells(xs))
+fun count(n: Int) -> Int =
+  s := 0
+  for i := range n
+    s = s + i
+  s
+";
+    fn fnNames(info: &TypedInfo) -> Vec<String> {
+        info.lowered
+            .as_ref()
+            .unwrap()
+            .items
+            .iter()
+            .filter_map(|i| match i {
+                ast::Item::Fn(f) => Some(f.name.clone()),
+                _ => None,
+            })
+            .collect()
+    }
+    #[test]
+    fn defaultOptionsMatchTypedSource() {
+        let src = parse(SRC);
+        let a = typedSource(&src).expect("checks");
+        let b = typedSourceWith(&src, FusionOptions::default()).expect("checks");
+        assert_eq!(fnNames(&a), fnNames(&b));
+        assert!(fnNames(&b).iter().any(|n| n.contains("sumL$mapCells")));
+    }
+    #[test]
+    fn disabledHasNoFusedFns() {
+        let src = parse(SRC);
+        let info = typedSourceWith(&src, FusionOptions { enabled: false, explain: false }).expect("checks");
+        assert!(!fnNames(&info).iter().any(|n| n.contains('$')), "{:?}", fnNames(&info));
+    }
+}

plum-checker/tests/checker_tests.rs CHANGED Viewed

@@ -657,7 +657,7 @@ fn rejects_basic_expressions_and_calls() {
         r(&format!("{cat}  fun breakCat(self) =\n    self.nope = 1\n"), &["no field 'nope' on type 'Cat'"]),
         r("enum Shape =\n  | Square(x: Int, y: Int)\n\nfun bad() -> Shape =\n  Square(x: 1)\n", &["variant 'Square' missing field 'y'"]),
         r("enum Shape =\n  | Square(x: Int, y: Int)\n\nfun bad() -> Shape =\n  Square(x: 1, y: 2, z: 3)\n", &["unknown field 'z' on variant 'Square'"]),
-        r("enum Shape =\n  | Circle(radius: Int)\n  | Square(radius: Int)\n\nfun bad() -> Int =\n  r := Circle(radius: 5)\n  return r.radius\n", &["field 'radius' is ambiguous across multiple variants of enum 'Shape'"]),
+        r("enum Shape =\n  | Circle(radius: Int)\n  | Square(radius: Int)\n\nfun bad() -> Int =\n  r := Circle(radius: 5)\n  return r.radius\n", &["no field 'radius' on type 'Shape'"]),
         r("enum Maybe =\n  | Just(Int)\n  | Nothing\n\nfun bad() -> Maybe =\n  Just(\"x\")\n", &["variant 'Just' arg 0: type mismatch"]),
         r("enum Shape =\n  | Rect(Float, Float)\n  | Circle(Float)\n\nfun bad() -> Shape =\n  Rect(1.0)\n", &["variant 'Rect': expected 2 arg(s), got 1"]),
         // enum discriminants

plum-cli/src/main.rs CHANGED Viewed

@@ -137,9 +137,22 @@ fn main() {
     }
 }
-/// `--no-fusion` / `--explain-fusion` set the checker's fusion options.
+/// The `--no-fusion` / `--explain-fusion` flags of the running command, set once in `run`
+/// and passed to every compile as explicit `CompileOptions`.
+static FUSION: std::sync::OnceLock<plum_checker::FusionOptions> = std::sync::OnceLock::new();
 fn setFusion(explain: bool, no_fusion: bool) {
-    plum_checker::setFusionOptions(plum_checker::FusionOptions { enabled: !no_fusion, explain });
+    let _ = FUSION.set(plum_checker::FusionOptions { enabled: !no_fusion, explain });
+}
+/// `compile` reports positioned type errors without a file name; name `file` in them
+/// (the entry file, since positions refer to the merged source).
+fn nameFileInErrors(msg: &str, file: &std::path::Path) -> String {
+    msg.replace("type error at line", &format!("type error in '{}' at line", file.display()))
+}
+fn compileOptions(tests: bool) -> plum_wasm_codegen::CompileOptions {
+    plum_wasm_codegen::CompileOptions { tests, fusion: FUSION.get().copied().unwrap_or_default() }
 }
 fn run() -> Result<()> {
@@ -223,16 +236,13 @@ fn cmdFormat(file: Option<std::path::PathBuf>, check: bool, use_stdin: bool) ->
 fn compileToWasm(file: &std::path::Path, lib_path: &std::path::Path) -> Result<Vec<u8>> {
     let ast = plum_core::loadAndMerge(file, lib_path).map_err(|e| anyhow::anyhow!("{e}"))?;
-    // Type check once; codegen reuses the result.
-    let typed = match plum_wasm_codegen::typeCheckIn(&ast, &file.display().to_string()) {
+    plum_wasm_codegen::compile(&ast, &compileOptions(false)).map(|o| o.wasm).map_err(|e| {
-        Ok(t) => t,
-        Err(messages) => {
-            eprintln!("{messages}");
+        if e.starts_with("type error") {
+            eprintln!("{}", nameFileInErrors(&e, file));
             process::exit(1);
         }
+        anyhow::anyhow!("codegen error: {e}")
-    };
+    })
-    plum_wasm_codegen::compileTyped(&ast, typed).map_err(|e| anyhow::anyhow!("codegen error: {e}"))
 }
 fn compileToTestWasm(
@@ -248,11 +258,14 @@ fn compileToTestWasm(
     // continue to the rest of the directory instead of the whole run
     // dying on the first file with a type error. Checked once, on the
     // test-desugared source codegen then compiles.
-    let prog = plum_wasm_codegen::desugarTests(&ast);
-    let typed = plum_wasm_codegen::typeCheckIn(&prog.source, &file.display().to_string())
+    let out = plum_wasm_codegen::compile(&ast, &compileOptions(true)).map_err(|e| {
-        .map_err(|m| anyhow::anyhow!(m))?;
+        if e.starts_with("type error") {
-    let compiled = plum_wasm_codegen::compileTestTyped(&prog, typed)
+            anyhow::anyhow!(nameFileInErrors(&e, file))
+        } else {
-        .map_err(|e| anyhow::anyhow!("codegen error: {e}"))?;
+            anyhow::anyhow!("codegen error: {e}")
+        }
+    })?;
+    let compiled = (out.wasm, out.test_names);
     // Debug aid: `PLUM_DUMP_WASM=out.wasm plum test file.plum` keeps the module.
     if let Some(path) = std::env::var_os("PLUM_DUMP_WASM") {
         let _ = fs::write(path, &compiled.0);
@@ -474,7 +487,7 @@ fn runTestFile(file: &std::path::Path, lib_path: &std::path::Path) -> Result<(us
         let export_name = format!("test#{name}");
         // Each test function returns a `Str` (empty = every `assert` inside it
         // passed; otherwise a newline-separated report, one "line L, column C:
-        // ..." entry per failing `assert` — see `desugarTestsToFns`) rather
+        // ..." entry per failing `assert` — see `plum_core::tests_lower`) rather
         // than a plain `i64`, so this goes through the untyped call API
         // (`Val::AnyRef`, same GC-ref handling `hostImports`' own Str-returning
         // imports already use) instead of `get_typed_func`.

plum-core/src/ast.rs CHANGED Viewed

@@ -384,7 +384,7 @@ pub enum Stmt {
     /// Outside a `test` body, traps (hard failure) if `cond` is false. Inside
     /// one, desugars to a non-fatal check instead — records a failure report
     /// (with `Check`'s own source location/text) and keeps running rather
-    /// than trapping — see `plum-wasm-codegen`'s `desugarTestsToFns`.
+    /// than trapping — see `plum_core::tests_lower`.
     Assert(Check),
     /// A surface `for` over an iterable or a for-form call, not yet lowered
     /// (see `forms.rs`); never seen by the checker or codegen.
@@ -577,8 +577,6 @@ pub enum Expr {
     Catch(Box<CatchExpr>),
     /// `error.Name` — an error value, of the singleton set `error{Name}`.
     ErrorValue(ErrorValue),
-    /// `{expr}` — grouped/parenthesized expression
-    Paren(Box<Expr>),
     String(StringExpr),
     Int(i64),
     Float(f64),

plum-core/src/builtin_usage.rs CHANGED Viewed

@@ -295,7 +295,6 @@ fn walkExpr(expr: &Expr, names: &mut Acc) {
                 }
             }
         }
-        Expr::Paren(e) => walkExpr(e, names),
         Expr::String(s) => {
             names.insert("Str".to_string());
             for part in &s.parts {

plum-core/src/closure_escape.rs CHANGED Viewed

@@ -216,7 +216,7 @@ impl<'a> Cx<'a> {
             Expr::Binary(b) => self.expr(&b.left, cl) || self.expr(&b.right, cl),
             Expr::Unary(u) => self.expr(&u.operand, cl),
             Expr::Bool(b) => self.expr(&b.left, cl) || self.expr(&b.right, cl),
-            Expr::Not(x) | Expr::Try(x) | Expr::Paren(x) => self.expr(x, cl),
+            Expr::Not(x) | Expr::Try(x) => self.expr(x, cl),
             Expr::Compare(c) => self.expr(&c.left, cl) || self.expr(&c.right, cl),
             Expr::InlineIf(i) => {
                 self.expr(&i.condition, cl) || self.expr(&i.then, cl) || self.expr(&i.else_, cl)

plum-core/src/closure_spec.rs CHANGED Viewed

@@ -12,7 +12,7 @@
 use crate::ast::*;
 use crate::closure_escape::nonEscapingFnParams;
 use crate::rename::{renameStmts, Name};
-use crate::visit::{anyExpr, countVar, stmtBlockRefs, stmtBlocks, stmtExprRefs, stmtExprs, visitBlock, visitExpr};
+use crate::visit::{walkBlockRef, walkRef, countVar, stmtBlocks, stmtExprs, visitBlock, visitExpr};
 use std::collections::{HashMap, HashSet};
 pub const MAX_COPIES: usize = 8;
@@ -989,24 +989,3 @@ fn collectBinders(body: &mut FnBody, out: &mut HashSet<String>) {
         FnBody::Extern => {}
     }
 }
-// ---------- read-only traversal ----------
-fn walkBlockRef(b: &Block, f: &mut dyn FnMut(&Expr)) {
-    for s in &b.stmts {
-        for e in stmtExprRefs(s) {
-            walkRef(e, f);
-        }
-        for blk in stmtBlockRefs(s) {
-            walkBlockRef(blk, f);
-        }
-    }
-}
-/// Pre-order over `e`, closure bodies and catch blocks included.
-fn walkRef(e: &Expr, f: &mut dyn FnMut(&Expr)) {
-    anyExpr(e, &mut |x| {
-        f(x);
-        false
-    });
-}

plum-core/src/ctors.rs CHANGED Viewed

@@ -68,7 +68,6 @@ pub(crate) fn inferType(e: &Expr) -> Option<Type> {
         Expr::Float(_) => Some(ty("Float")),
         Expr::BoolLit(_) => Some(ty("Bool")),
         Expr::String(_) => Some(ty("Str")),
-        Expr::Paren(x) => inferType(x),
         Expr::Unary(u) => inferType(&u.operand),
         Expr::ClassCall(c) => Some(Type {
             name: c.type_name.clone(),

plum-core/src/drive.rs CHANGED Viewed

@@ -11,8 +11,9 @@
 use crate::ast::*;
 use crate::generics::isGenericName;
 use crate::rename::{renameStmts, substPT, substStmts, substType, Name};
+use crate::simplify::simplifyBlock;
-use crate::simplify::{argRef, isTag, simplifyBlock, walkBlockRef, walkRef};
+use crate::visit::{argRef, isTag, walkBlockRef, walkRef};
-use crate::visit::{childRefs, stmtBlockRefs, stmtBlocks, stmtExprRefs, unparen, visitBlock, visitExpr};
+use crate::visit::{childRefs, stmtBlockRefs, stmtBlocks, stmtExprRefs, visitBlock, visitExpr};
 use crate::whistle::embeds;
 use std::collections::{HashMap, HashSet};
@@ -236,7 +237,6 @@ fn pathStmts(stmts: &[Stmt], name: &str) -> usize {
 fn cheap(e: &Expr) -> bool {
     match e {
         Expr::Var(_) | Expr::Int(_) | Expr::Float(_) | Expr::BoolLit(_) | Expr::TypeName(_) | Expr::Self_ => true,
-        Expr::Paren(x) => cheap(x),
         Expr::Attribute(a) => matches!(a.attr, AttrKind::Field(_)) && cheap(&a.object),
         _ => false,
     }
@@ -319,7 +319,6 @@ impl Tcx {
     fn tail(&self, e: Expr) -> Vec<Stmt> {
         match e {
-            Expr::Paren(i) => self.tail(*i),
             Expr::ClassCall(_) | Expr::TypeName(_) => self.pushed(e),
             Expr::Var(ref n) if self.ctors.contains(n) => self.pushed(e),
             Expr::InlineIf(i) => {
@@ -647,7 +646,7 @@ impl Driver {
     // ---------- resolving calls ----------
     fn calls(&self, e: &Expr) -> Vec<Call> {
-        match unparen(e) {
+        match e {
             Expr::FnCall(c) if self.free.contains(&c.name) => {
                 let f = &self.fns[&c.name];
                 match positional(&c.args) {
@@ -674,7 +673,7 @@ impl Driver {
                     };
                 }
                 let mut out = Vec::new();
-                let recv = match unparen(&a.object) {
+                let recv = match &a.object {
                     Expr::Var(n) => self.vtypes.get(n),
                     Expr::Self_ => self.vtypes.get("self"),
                     _ => None,
@@ -814,7 +813,7 @@ impl Driver {
     /// The enum (or record) a just-built value `e` belongs to, if `e` is a constructor.
     fn ctorType(&self, e: &Expr) -> Option<String> {
-        match unparen(e) {
+        match e {
             Expr::ClassCall(c) if c.spread.is_none() => self.ctorOwner.get(&c.type_name).cloned().or(Some(c.type_name.clone())),
             Expr::FnCall(c) => self.ctorOwner.get(&c.name).cloned(),
             Expr::TypeName(n) | Expr::Var(n) => self.ctorOwner.get(n).cloned(),
@@ -1311,7 +1310,7 @@ impl Driver {
             for st in &blk.stmts {
                 if let Stmt::Match(m) = st {
                     if let [subject] = &m.subjects[..] {
-                        let st = match unparen(subject) {
+                        let st = match subject {
                             Expr::Var(n) => out.get(n).cloned(),
                             Expr::Self_ => out.get("self").cloned(),
                             _ => None,
@@ -1355,7 +1354,7 @@ impl Driver {
     /// when the receiver's type is known (`io.clear` is `Io.clear`), else every method of
     /// that name. Empty (an unknown callee) when there is none.
     fn methodKeys(&self, object: &Expr, name: &str) -> Vec<String> {
-        let recv = match unparen(object) {
+        let recv = match object {
             Expr::Var(n) => self.vtypes.get(n),
             Expr::Self_ => self.vtypes.get("self"),
             _ => None,
@@ -1371,7 +1370,7 @@ impl Driver {
     /// The type of a variable, `self` or a field read of one, when known and concrete.
     fn exprType(&self, e: &Expr) -> Option<Type> {
-        let t = match unparen(e) {
+        let t = match e {
             Expr::Var(n) => self.vtypes.get(n).cloned()?,
             Expr::Self_ => self.vtypes.get("self").cloned()?,
             Expr::Attribute(a) => {
@@ -1704,7 +1703,7 @@ impl Driver {
     /// `List(a, b, ..)` (the variadic `List.init`) as the cons cells it builds,
     /// `Cons(head: a, tail: ..Nil)`, so a consumer can pick its arms on it.
     fn listLit(&self, e: &Expr) -> Option<Expr> {
-        let Expr::FnCall(c) = unparen(e) else { return None };
+        let Expr::FnCall(c) = e else { return None };
         if c.name != "List" || !self.ctors.contains("Cons") || !self.ctors.contains("Nil") {
             return None;
         }
@@ -1733,7 +1732,7 @@ impl Driver {
         walkBlockRef(&Block { stmts: stmts.to_vec() }, &mut |e| {
             for c in self.calls(e) {
                 let Some(k) = self.subj(&c.f) else { continue };
-                let hit = matches!(c.args.get(k).map(unparen), Some(Expr::Var(n)) if n == p);
+                let hit = matches!(c.args.get(k), Some(Expr::Var(n)) if n == p);
                 if hit && (self.pure.contains(&c.key) || self.readOnly.contains(&c.key)) {
                     good += 1;
                     break;
@@ -1761,7 +1760,7 @@ impl Driver {
     /// `todo`, and every call is read-only (it may draw or stop, never mutate) or takes the
     /// value `p` directly.
     fn quiet(&self, stmts: &[Stmt], p: &str) -> bool {
-        let isP = |e: &Expr| matches!(unparen(e), Expr::Var(n) if n == p);
+        let isP = |e: &Expr| matches!(e, Expr::Var(n) if n == p);
         let takesP = |args: &[Arg]| args.iter().any(|a| isP(argRef(a)));
         let mut ok = true;
         for s in stmts {

plum-core/src/lib.rs CHANGED Viewed

@@ -13,12 +13,14 @@ pub mod formatter;
 pub mod forms;
 pub mod generics;
 pub mod loader;
+pub mod lower;
 pub mod parser;
 pub mod purity;
 pub mod rename;
 pub mod reuse;
 pub mod simplify;
 pub mod tail;
+pub mod tests_lower;
 pub mod traits;
 pub mod trmc;
 pub mod union_lower;

plum-core/src/loader.rs CHANGED Viewed

@@ -81,23 +81,7 @@ pub fn loadAndMergeWithOverrides(
         primitives: prims,
         traits: Vec::new(),
     };
-    let traitErrors = crate::traits::lowerTraits(&mut merged);
-    if !traitErrors.is_empty() {
-        return Err(traitErrors.join("\n"));
-    }
-    let ctorErrors = crate::ctors::lowerCtors(&mut merged);
-    if !ctorErrors.is_empty() {
-        return Err(ctorErrors.join("\n"));
-    }
-    let typeErrors = crate::unions::inlineVariantTypeErrors(&merged);
-    if !typeErrors.is_empty() {
-        return Err(typeErrors.join("\n"));
-    }
-    let memberErrors = crate::unions::resolveMembers(&mut merged);
-    if !memberErrors.is_empty() {
-        return Err(memberErrors.join("\n"));
-    }
-    crate::forms::prepareForms(&mut merged);
+    crate::lower::frontEnd(&mut merged)?;
     Ok(merged)
 }
@@ -540,17 +524,9 @@ fn mergeItems(
     names: &mut HashMap<String, PathBuf>,
     prims: &mut Vec<PrimitiveDecl>,
 ) -> Result<(), String> {
-    // Removed forms (lone self-named variant).
-    let legacy: Vec<String> = crate::unions::legacyErrors(source);
-    if !legacy.is_empty() {
-        return Err(legacy.join("\n"));
-    }
-    // Inline variants become hidden records right after their enum.
+    // Removed forms, then inline variants as hidden records (per-file lowering).
     let mut hoisted = source.clone();
-    let hoistErrors = crate::unions::hoistInlineVariants(&mut hoisted);
+    crate::lower::perFile(&mut hoisted)?;
-    if !hoistErrors.is_empty() {
-        return Err(hoistErrors.join("\n"));
-    }
     let source = &hoisted;
     // Parse-time literal errors (out-of-range integers) of every merged file.
     MERGED_LIT_ERRORS.with(|e| e.borrow_mut().extend(source.formErrors.iter().cloned()));

plum-core/src/lower.rs ADDED Viewed

@@ -0,0 +1,40 @@
+use crate::ast::Source;
+/// Per-file steps, run on each file before it is merged (and by single-file
+/// `parseSource`): removed-form errors, then inline variants become hidden
+/// records right after their enum.
+pub fn perFile(source: &mut Source) -> Result<(), String> {
+    let legacy: Vec<String> = crate::unions::legacyErrors(source);
+    if !legacy.is_empty() {
+        return Err(legacy.join("\n"));
+    }
+    let hoistErrors = crate::unions::hoistInlineVariants(source);
+    if !hoistErrors.is_empty() {
+        return Err(hoistErrors.join("\n"));
+    }
+    Ok(())
+}
+/// Front-end lowering of a merged program: traits, constructors, inline-variant
+/// type checks, union members, then forms. The first failing stage returns its
+/// errors joined with "\n".
+pub fn frontEnd(source: &mut Source) -> Result<(), String> {
+    let traitErrors = crate::traits::lowerTraits(source);
+    if !traitErrors.is_empty() {
+        return Err(traitErrors.join("\n"));
+    }
+    let ctorErrors = crate::ctors::lowerCtors(source);
+    if !ctorErrors.is_empty() {
+        return Err(ctorErrors.join("\n"));
+    }
+    let typeErrors = crate::unions::inlineVariantTypeErrors(source);
+    if !typeErrors.is_empty() {
+        return Err(typeErrors.join("\n"));
+    }
+    let memberErrors = crate::unions::resolveMembers(source);
+    if !memberErrors.is_empty() {
+        return Err(memberErrors.join("\n"));
+    }
+    crate::forms::prepareForms(source);
+    Ok(())
+}

plum-core/src/parser.rs CHANGED Viewed

@@ -63,9 +63,9 @@ impl<'a> AstParser<'a> {
     /// defined in another file resolves.
     pub fn parseSource(&self, node: Node) -> Source {
         let mut source = self.parseSourceRaw(node);
-        // Single-file path: the loader reports member errors on the merged program.
+        // Single-file path: errors are discarded; callers needing them call `lower::perFile` and `lower::frontEnd`.
-        let _ = crate::unions::resolveMembers(&mut source);
+        let _ = crate::lower::perFile(&mut source);
-        crate::forms::prepareForms(&mut source);
+        let _ = crate::lower::frontEnd(&mut source);
         source
     }
@@ -1374,7 +1374,7 @@ impl<'a> AstParser<'a> {
             "fn_call" => Expr::FnCall(self.parseFnCall(node)),
             "class_call" => Expr::ClassCall(self.parseClassCall(node)),
             "parenthesized_expression" => {
-                // parenthesized_expression: "{" expression "}"
+                // parenthesized_expression: "{" expression "}" — grouping only, no AST node
                 let inner = node
                     .named_child(0)
                     .map(|n| {
@@ -1382,7 +1382,7 @@ impl<'a> AstParser<'a> {
                         self.parseExpression(u)
                     })
                     .unwrap_or(Expr::Int(0));
-                Expr::Paren(Box::new(inner))
+                inner
             }
             "string" => Expr::String(self.parseString(node)),
             "integer" => Expr::Int(self.parseInteger(node)),

plum-core/src/purity.rs CHANGED Viewed

@@ -372,7 +372,6 @@ impl<'a> Walker<'a> {
     fn freshRoot(&self, e: &Expr) -> bool {
         match e {
             Expr::Var(n) => self.fresh.contains(n),
-            Expr::Paren(x) => self.freshRoot(x),
             Expr::Attribute(a) => matches!(a.attr, AttrKind::Field(_)) && self.freshRoot(&a.object),
             _ => false,
         }
@@ -397,7 +396,7 @@ impl<'a> Walker<'a> {
                 self.expr(&b.left);
                 self.expr(&b.right);
             }
-            Expr::Not(x) | Expr::Try(x) | Expr::Paren(x) => self.expr(x),
+            Expr::Not(x) | Expr::Try(x) => self.expr(x),
             Expr::Compare(c) => {
                 self.expr(&c.left);
                 self.expr(&c.right);

plum-core/src/reuse.rs CHANGED Viewed

@@ -19,7 +19,6 @@ use std::collections::HashMap;
 fn deepFresh(e: &Expr) -> bool {
     match e {
         Expr::ClassCall(c) => c.spread.is_none() && c.fields.iter().all(|f| deepFresh(&f.value)),
-        Expr::Paren(x) => deepFresh(x),
         Expr::TypeName(_) | Expr::Int(_) | Expr::Float(_) | Expr::BoolLit(_) => true,
         Expr::Binary(_) | Expr::Unary(_) | Expr::Compare(_) => true,
         _ => false,

plum-core/src/simplify.rs CHANGED Viewed

@@ -6,7 +6,7 @@
 //! blocks (`simplifyBlock`); `simplifyExpr` covers the expression-level rewrites.
 use crate::ast::*;
 use crate::rename::{renameStmts, Name};
-use crate::visit::{anyExpr, childExprs, childRefs, stmtBlockRefs, stmtBlocks, stmtExprRefs, stmtExprs, visitBlock};
+use crate::visit::{argRef, isTag, walkBlockRef, walkRef, childExprs, childRefs, stmtBlocks, stmtExprs, visitBlock};
 use std::collections::{HashMap, HashSet};
 use std::sync::atomic::{AtomicUsize, Ordering};
@@ -74,11 +74,6 @@ struct Cx<'a> {
     depth: usize,
 }
-/// Pattern casing rule: a Capitalised name is always a tag, a lowercase name always binds.
-pub(crate) fn isTag(n: &str) -> bool {
-    n.chars().next().is_some_and(|c| c.is_uppercase())
-}
 fn trivial(e: &Expr) -> bool {
     matches!(e, Expr::Var(_) | Expr::Int(_) | Expr::Float(_) | Expr::BoolLit(_) | Expr::TypeName(_))
 }
@@ -274,10 +269,7 @@ impl<'a> Cx<'a> {
     /// `ctor(..).f` -> the field's value, when every other field is droppable.
     fn fieldOfCtor(&self, a: AttributeExpr) -> Result<Expr, AttributeExpr> {
         let AttrKind::Field(f) = &a.attr else { return Err(a) };
-        let obj = match &a.object {
+        let obj = &a.object;
-            Expr::Paren(p) => p.as_ref(),
-            o => o,
-        };
         let Expr::ClassCall(c) = obj else { return Err(a) };
         if c.spread.is_some() || !c.fields.iter().any(|x| &x.name == f) {
             return Err(a);
@@ -503,7 +495,6 @@ impl<'a> Cx<'a> {
     /// `(ctor name, field values in declared order)` of a just-built value.
     fn ctorOf(&self, e: &Expr) -> Option<(String, Vec<Expr>)> {
         match e {
-            Expr::Paren(p) => self.ctorOf(p),
             Expr::TypeName(n) | Expr::Var(n) if self.ctors.get(n).is_some_and(|f| f.is_empty()) => {
                 Some((n.clone(), vec![]))
             }
@@ -820,30 +811,3 @@ impl Scoper {
         }
     }
 }
-/// Pre-order callback over every expression of `b`, closure bodies and catch blocks included.
-pub(crate) fn walkBlockRef(b: &Block, f: &mut dyn FnMut(&Expr)) {
-    for s in &b.stmts {
-        for e in stmtExprRefs(s) {
-            walkRef(e, f);
-        }
-        for blk in stmtBlockRefs(s) {
-            walkBlockRef(blk, f);
-        }
-    }
-}
-/// Pre-order callback over `e` and everything under it.
-pub(crate) fn walkRef(e: &Expr, f: &mut dyn FnMut(&Expr)) {
-    anyExpr(e, &mut |x| {
-        f(x);
-        false
-    });
-}
-/// The expression of a call argument (visit.rs keeps its own copy private).
-pub(crate) fn argRef(a: &Arg) -> &Expr {
-    match a {
-        Arg::Positional(e) | Arg::Keyword { value: e, .. } => e,
-    }
-}

plum-core/src/tail.rs CHANGED Viewed

@@ -189,7 +189,6 @@ fn expr(cx: &mut Ctx, e: &mut Expr, tail: bool) {
                 site(cx, c);
             }
         }
-        Expr::Paren(x) => expr(cx, x, tail),
         Expr::InlineIf(i) => {
             expr(cx, &mut i.condition, false);
             expr(cx, &mut i.then, tail);

plum-core/src/tests_lower.rs ADDED Viewed

@@ -0,0 +1,265 @@
+use crate::ast;
+/// A source with its `test` blocks lowered into ordinary fns. Type-check
+/// `source` (not the original), then compile it with `extraExports`.
+pub struct TestProgram {
+    pub source: ast::Source,
+    pub extraExports: Vec<(String, String)>,
+    pub names: Vec<String>,
+}
+/// Temp names (`__lhs_N`) restart at 0 on every call.
+pub fn lowerTests(source: &ast::Source) -> TestProgram {
+    let (lowered, extraExports) = desugarTestsToFns(source);
+    let names = extraExports
+        .iter()
+        .map(|(_, export_name)| export_name["test#".len()..].to_string())
+        .collect();
+    TestProgram {
+        source: lowered,
+        extraExports,
+        names,
+    }
+}
+fn strLit(s: String) -> crate::ast::Expr {
+    crate::ast::Expr::String(crate::ast::StringExpr {
+        parts: vec![crate::ast::StringPart::Text(s)],
+    })
+}
+/// Builds a failing `assert`'s report line: the literal condition text, plus —
+/// when the condition is a top-level comparison (`left OP right`) — the
+/// ACTUAL (left) and EXPECTED (right) sides' own runtime values underneath,
+/// `assert computed() == literal` being the overwhelmingly common shape a
+/// test writes such a comparison in. Reuses `"{expr}"` string interpolation's
+/// own existing codegen (rather than any special stringification of its
+/// own) — including `Float`, which interpolation now supports by rendering
+/// through `Float.toStr` (`plum-std/Float.plum`), so no type needs
+/// special-casing out here any more. A non-comparison condition (`assert
+/// isEven(4)`) has no meaningful actual/expected split — a boolean condition
+/// is always false by the time this fires — so it's just the bare text.
+/// First part of an assert report string: tells `compileInterpolatedString`
+/// that if any interpolated side has no renderable type (no `toStr`), only the
+/// plain condition-text line (the next part) is emitted.
+pub const ASSERT_REPORT_MARK: &str = "\u{1}assert-report";
+fn assertFailureMessage(c: &crate::ast::Check, lhs: &crate::ast::Expr, rhs: &crate::ast::Expr) -> crate::ast::Expr {
+    let isNullLit =
+        |e: &crate::ast::Expr| matches!(e, crate::ast::Expr::ErrorValue(v) if v.name == crate::ast::NULL_ERR_NAME);
+    let plain = match &c.cond {
+        crate::ast::Expr::Compare(cmp) => isNullLit(&cmp.left) || isNullLit(&cmp.right),
+        _ => true,
+    };
+    if plain {
+        return strLit(format!("{}\n", c.text));
+    }
+    crate::ast::Expr::String(crate::ast::StringExpr {
+        parts: vec![
+            crate::ast::StringPart::Text(ASSERT_REPORT_MARK.to_string()),
+            crate::ast::StringPart::Text(format!("{}\n", c.text)),
+            crate::ast::StringPart::Text("      Expected: ".to_string()),
+            crate::ast::StringPart::Interp(rhs.clone()),
+            crate::ast::StringPart::Text("\n      Actual:   ".to_string()),
+            crate::ast::StringPart::Interp(lhs.clone()),
+            crate::ast::StringPart::Text("\n".to_string()),
+        ],
+    })
+}
+fn desugarTestsToFns(source: &crate::ast::Source) -> (crate::ast::Source, Vec<(String, String)>) {
+    let mut items = Vec::with_capacity(source.items.len());
+    let mut extraExports = Vec::new();
+    let mut test_idx = 0usize;
+    let mut counter = 0usize;
+    // Tests may use `io` when std/Io is loaded: the export wrapper passes the `Io`.
+    let hasIo = source.items.iter().any(|it| matches!(it, crate::ast::Item::Enum(c) if c.name == "Io"));
+    let ioParam = if hasIo {
+        vec![crate::ast::Param {
+            name: "io".to_string(),
+            ty: crate::ast::ParamType::Type(crate::ast::Type { name: "Io".to_string(), generics: vec![] }),
+            default: None,
+        }]
+    } else {
+        vec![]
+    };
+    for item in &source.items {
+        match item {
+            // Tests declared in imported files are not run: only the entry file's own.
+            crate::ast::Item::Test(t) if !t.file.is_empty() && t.file != source.file => {}
+            crate::ast::Item::Test(t) => {
+                // Leading "__" can never collide with a real Plum-declared name —
+                // `fn_identifier`/`var_identifier` must start with a lowercase letter.
+                let internal_name = format!("__test_{}", test_idx);
+                test_idx += 1;
+                let mut stmts = Vec::with_capacity(t.body.stmts.len() + 2);
+                stmts.push(crate::ast::Stmt::Assign(crate::ast::Assign {
+                    isSynthetic: false,
+                    targets: vec![crate::ast::AssignTarget::Var("__report".to_string())],
+                    values: vec![strLit(String::new())],
+                    declare: true,
+                    ty: None,
+                }));
+                stmts.extend(desugarAssertStmts(&t.body.stmts, &mut counter));
+                stmts.push(crate::ast::Stmt::Expr(
+                    crate::ast::Expr::Var("__report".to_string()),
+                    0,
+                    0,
+                ));
+                items.push(crate::ast::Item::Fn(crate::ast::Fn {
+                    file: source.file.clone(),
+                    name: internal_name.clone(),
+                    line: t.line,
+                    column: t.column,
+                    type_param: None,
+                    is_extern: false,
+                    is_export: false,
+                    is_override: false,
+                    is_star: false,
+                    has_self: true,
+                    yields: None,
+                    params: ioParam.clone(),
+                    returns: Some(crate::ast::Type {
+                        name: crate::ast::STR_TYPE.to_string(),
+                        generics: vec![],
+                    }),
+                    body: crate::ast::FnBody::Block(crate::ast::Block { stmts }),
+                }));
+                extraExports.push((internal_name, format!("test#{}", t.name)));
+            }
+            other => items.push(other.clone()),
+        }
+    }
+    (
+        crate::ast::Source {
+            file: source.file.clone(),
+            module: source.module.clone(),
+            imports: source.imports.clone(),
+            items,
+            topLevelOrder: Vec::new(),
+            formErrors: source.formErrors.clone(),
+            formUses: source.formUses.clone(),
+            stars: source.stars.clone(),
+            formLoops: source.formLoops,
+            primitives: source.primitives.clone(),
+            traits: source.traits.clone(),
+        },
+        extraExports,
+    )
+}
+/// Recursively rewrites every `assert cond` (`cond` carrying its own literal
+/// source text, captured at parse time — see `crate::ast::Check`) into
+/// `if !cond { __report = __report + "<text>\n" }`, descending into nested
+/// control-flow blocks so an `assert` inside a `test`'s own
+/// `if`/`while`/`for`/`match` still records into the same hidden accumulator.
+fn desugarAssertStmts(stmts: &[crate::ast::Stmt], counter: &mut usize) -> Vec<crate::ast::Stmt> {
+    stmts.iter().flat_map(|s| desugarAssertStmt(s, counter)).collect()
+}
+fn desugarAssertStmt(stmt: &crate::ast::Stmt, counter: &mut usize) -> Vec<crate::ast::Stmt> {
+    match stmt {
+        crate::ast::Stmt::Assert(c) => {
+            // A comparison evaluates each operand exactly once into a
+            // temporary (left first), then compares and reports the temporaries.
+            let mut pre = Vec::new();
+            let mut cond = c.cond.clone();
+            let (mut lhs, mut rhs) = (crate::ast::Expr::Var(String::new()), crate::ast::Expr::Var(String::new()));
+            let isNullLit = |e: &crate::ast::Expr| matches!(e, crate::ast::Expr::ErrorValue(v) if v.name == crate::ast::NULL_ERR_NAME);
+            // `x == null` has no value to print for the null side: reported as a plain condition.
+            if let crate::ast::Expr::Compare(cmp) = &c.cond {
+                if isNullLit(&cmp.left) || isNullLit(&cmp.right) {
+                    // falls through with the condition kept whole
+                } else {
+                    let n = *counter;
+                    *counter += 1;
+                    let (l, r) = (format!("__lhs_{}", n), format!("__rhs_{}", n));
+                    for (name, e) in [(&l, &cmp.left), (&r, &cmp.right)] {
+                        pre.push(crate::ast::Stmt::Assign(crate::ast::Assign {
+                            isSynthetic: false,
+                            targets: vec![crate::ast::AssignTarget::Var(name.clone())],
+                            values: vec![e.clone()],
+                            declare: true,
+                            ty: None,
+                        }));
+                    }
+                    lhs = crate::ast::Expr::Var(l);
+                    rhs = crate::ast::Expr::Var(r);
+                    cond = crate::ast::Expr::Compare(Box::new(crate::ast::CompareExpr {
+                        op: cmp.op.clone(),
+                        left: lhs.clone(),
+                        right: rhs.clone(),
+                    }));
+                }
+            }
+            let appendReport = crate::ast::Stmt::Assign(crate::ast::Assign {
+                isSynthetic: false,
+                targets: vec![crate::ast::AssignTarget::Var("__report".to_string())],
+                values: vec![crate::ast::Expr::Binary(Box::new(crate::ast::BinaryExpr {
+                    op: crate::ast::BinOp::Add,
+                    left: crate::ast::Expr::Var("__report".to_string()),
+                    right: assertFailureMessage(c, &lhs, &rhs),
+                }))],
+                declare: false,
+                ty: None,
+            });
+            pre.push(crate::ast::Stmt::If(crate::ast::If {
+                condition: crate::ast::Expr::Not(Box::new(cond)),
+                body: crate::ast::Block {
+                    stmts: vec![appendReport],
+                },
+                else_ifs: vec![],
+                else_: None,
+            }));
+            pre
+        }
+        crate::ast::Stmt::If(i) => vec![crate::ast::Stmt::If(crate::ast::If {
+            condition: i.condition.clone(),
+            body: crate::ast::Block {
+                stmts: desugarAssertStmts(&i.body.stmts, counter),
+            },
+            else_ifs: i
+                .else_ifs
+                .iter()
+                .map(|ei| crate::ast::ElseIf {
+                    condition: ei.condition.clone(),
+                    body: crate::ast::Block {
+                        stmts: desugarAssertStmts(&ei.body.stmts, counter),
+                    },
+                })
+                .collect(),
+            else_: i.else_.as_ref().map(|b| crate::ast::Block {
+                stmts: desugarAssertStmts(&b.stmts, counter),
+            }),
+        })],
+        crate::ast::Stmt::While(w) => vec![crate::ast::Stmt::While(crate::ast::While {
+            condition: w.condition.clone(),
+            body: crate::ast::Block {
+                stmts: desugarAssertStmts(&w.body.stmts, counter),
+            },
+        })],
+        crate::ast::Stmt::ForLoop(f) => vec![crate::ast::Stmt::ForLoop(crate::ast::ForLoop {
+            body: crate::ast::Block {
+                stmts: desugarAssertStmts(&f.body.stmts, counter),
+            },
+            ..f.clone()
+        })],
+        crate::ast::Stmt::Match(m) => vec![crate::ast::Stmt::Match(crate::ast::Match {
+            subjects: m.subjects.clone(),
+            cases: m
+                .cases
+                .iter()
+                .map(|c| crate::ast::Case {
+                    patterns: c.patterns.clone(),
+                    guard: c.guard.clone(),
+                    body: crate::ast::Block {
+                        stmts: desugarAssertStmts(&c.body.stmts, counter),
+                    },
+                })
+                .collect(),
+        })],
+        other => vec![other.clone()],
+    }
+}

plum-core/src/trmc.rs CHANGED Viewed

@@ -143,7 +143,6 @@ fn assignsSelfField(body: &FnBody) -> bool {
     fn rootedAtSelf(e: &Expr) -> bool {
         match e {
             Expr::Self_ => true,
-            Expr::Paren(x) => rootedAtSelf(x),
             Expr::Attribute(a) => matches!(a.attr, AttrKind::Field(_)) && rootedAtSelf(&a.object),
             _ => false,
         }
@@ -251,7 +250,6 @@ fn set(n: &str, e: Expr) -> Stmt {
 fn pure(e: &Expr) -> bool {
     match e {
         Expr::Var(_) | Expr::Int(_) | Expr::Float(_) | Expr::BoolLit(_) => true,
-        Expr::Paren(x) => pure(x),
         _ => false,
     }
 }
@@ -383,7 +381,6 @@ impl<'a> Cx<'a> {
     fn tailExpr(&mut self, e: Expr) -> Option<Vec<Stmt>> {
         match e {
-            Expr::Paren(x) => self.tailExpr(*x),
             Expr::InlineIf(i) => {
                 let i = *i;
                 let then = Block { stmts: self.tailExpr(i.then)? };

plum-core/src/union_lower.rs CHANGED Viewed

@@ -272,7 +272,7 @@ impl<'a> Lowerer<'a> {
                     renameExpr(&mut b.right, &leftPairs);
                 }
             }
-            Expr::Not(x) | Expr::Try(x) | Expr::Paren(x) => self.expr(x),
+            Expr::Not(x) | Expr::Try(x) => self.expr(x),
             Expr::Compare(c) => {
                 self.expr(&mut c.left);
                 self.expr(&mut c.right);
@@ -408,7 +408,6 @@ fn condBinds(e: &Expr, name: &str) -> bool {
     match e {
         Expr::Bind(b) => patBinds(b.pattern(), name),
         Expr::Bool(b) => condBinds(&b.left, name) || condBinds(&b.right, name),
-        Expr::Paren(x) => condBinds(x, name),
         _ => false,
     }
 }
@@ -530,7 +529,7 @@ fn rnExpr(e: &mut Expr, from: &str, to: &str) {
                 rnExpr(&mut b.right, from, to);
             }
         }
-        Expr::Not(x) | Expr::Try(x) | Expr::Paren(x) => rnExpr(x, from, to),
+        Expr::Not(x) | Expr::Try(x) => rnExpr(x, from, to),
         Expr::Compare(c) => {
             rnExpr(&mut c.left, from, to);
             rnExpr(&mut c.right, from, to);

plum-core/src/unions.rs CHANGED Viewed

@@ -413,7 +413,7 @@ impl TypeWalk<'_> {
                 self.expr(&b.left);
                 self.expr(&b.right);
             }
-            Expr::Not(e) | Expr::Try(e) | Expr::Paren(e) => self.expr(e),
+            Expr::Not(e) | Expr::Try(e) => self.expr(e),
             Expr::Bang(b) => self.expr(&b.value),
             Expr::Bind(b) => {
                 self.expr(&b.value);

plum-core/src/uniqueness.rs CHANGED Viewed

@@ -122,7 +122,7 @@ fn walkExpr<'a>(e: &'a Expr, f: Visit<'a, '_>) {
             walkExpr(&c.left, f);
             walkExpr(&c.right, f);
         }
-        Expr::Not(x) | Expr::Try(x) | Expr::Paren(x) => walkExpr(x, f),
+        Expr::Not(x) | Expr::Try(x) => walkExpr(x, f),
         Expr::InlineIf(i) => {
             walkExpr(&i.condition, f);
             walkExpr(&i.then, f);
@@ -263,7 +263,7 @@ fn mutExpr(e: &mut Expr, f: &mut dyn FnMut(&mut ClassCall)) {
             mutExpr(&mut c.left, f);
             mutExpr(&mut c.right, f);
         }
-        Expr::Not(x) | Expr::Try(x) | Expr::Paren(x) => mutExpr(x, f),
+        Expr::Not(x) | Expr::Try(x) => mutExpr(x, f),
         Expr::InlineIf(i) => {
             mutExpr(&mut i.condition, f);
             mutExpr(&mut i.then, f);
@@ -380,7 +380,7 @@ fn isVar(e: &Expr, v: &str) -> bool {
 /// The name of a plain variable use; `self` counts as the variable "self".
 fn varName(e: &Expr) -> Option<&str> {
-    match crate::visit::unparen(e) {
+    match e {
         Expr::Var(n) => Some(n.as_str()),
         Expr::Self_ => Some("self"),
         _ => None,
@@ -446,7 +446,6 @@ impl An {
     fn fresh(&self, e: &Expr) -> bool {
         match e {
             Expr::ClassCall(_) => true,
-            Expr::Paren(x) => self.fresh(x),
             Expr::InlineIf(i) => self.fresh(&i.then) && self.fresh(&i.else_),
             Expr::FnCall(c) => self.isFree(&c.name).is_some_and(|g| self.fresh_ret.borrow().contains(&g)),
             Expr::Attribute(a) => match &a.attr {
@@ -551,7 +550,7 @@ impl An {
         if site.inClosure {
             return Err("argument inside a closure".to_string());
         }
-        match crate::visit::unparen(e) {
+        match e {
             Expr::Var(_) | Expr::Self_ => self.varOk(site.caller, varName(e).unwrap()),
             Expr::Attribute(a) => {
                 let AttrKind::Field(f) = &a.attr else {
@@ -783,7 +782,6 @@ impl<'a> Scan<'a> {
                     self.fail(m);
                 }
             }
-            Expr::Paren(x) => self.expr(x, tail, ab),
             Expr::InlineIf(i) => {
                 self.expr(&i.condition, false, false);
                 self.expr(&i.then, tail, ab);
@@ -1093,7 +1091,7 @@ fn collectFacts(an: &mut An) {
         walkBlock(&u.block, &mut |n| {
             match n {
                 Node::S(Stmt::Assign(asg)) if asg.targets.len() == 1 && asg.values.len() == 1 => {
-                    match crate::visit::unparen(&asg.values[0]) {
+                    match &asg.values[0] {
                         Expr::FnCall(c) => {
                             abMap.insert(c as *const FnCall, asg.targets[0].clone());
                         }
@@ -1164,7 +1162,7 @@ fn collectFacts(an: &mut An) {
                                 allowed.insert(&**o as *const Expr);
                             }
                             if single {
-                                let call: Option<(&FnCall, Option<&Expr>)> = match crate::visit::unparen(&asg.values[0]) {
+                                let call: Option<(&FnCall, Option<&Expr>)> = match &asg.values[0] {
                                     Expr::FnCall(c) => Some((c, None)),
                                     Expr::Attribute(x) => match &x.attr {
                                         AttrKind::Method(c) => Some((c, Some(&x.object))),

plum-core/src/visit.rs CHANGED Viewed

@@ -3,13 +3,6 @@
 //! `visitBlock`/`visitExpr`/`anyExpr`/`countVar`, not by `childExprs`/`childRefs`.
 use crate::ast::*;
-pub fn unparen(e: &Expr) -> &Expr {
-    match e {
-        Expr::Paren(i) => unparen(i),
-        _ => e,
-    }
-}
 pub fn visitBlock(b: &mut Block, f: &mut dyn FnMut(&mut Expr)) {
     for s in &mut b.stmts {
         for e in stmtExprs(s) {
@@ -49,7 +42,7 @@ pub fn childExprs(e: &mut Expr) -> Vec<&mut Expr> {
         Expr::Binary(b) => vec![&mut b.left, &mut b.right],
         Expr::Unary(u) => vec![&mut u.operand],
         Expr::Bool(b) => vec![&mut b.left, &mut b.right],
-        Expr::Not(x) | Expr::Try(x) | Expr::Paren(x) => vec![x.as_mut()],
+        Expr::Not(x) | Expr::Try(x) => vec![x.as_mut()],
         Expr::Bang(b) => vec![&mut b.value],
         Expr::Bind(b) => {
             let mut v = vec![&mut b.value];
@@ -155,7 +148,7 @@ pub fn stmtBlocks(s: &mut Stmt) -> Vec<&mut Block> {
     }
 }
-fn argRef(a: &Arg) -> &Expr {
+pub fn argRef(a: &Arg) -> &Expr {
     match a {
         Arg::Positional(e) | Arg::Keyword { value: e, .. } => e,
     }
@@ -166,7 +159,7 @@ pub fn childRefs(e: &Expr) -> Vec<&Expr> {
         Expr::Binary(b) => vec![&b.left, &b.right],
         Expr::Unary(u) => vec![&u.operand],
         Expr::Bool(b) => vec![&b.left, &b.right],
-        Expr::Not(x) | Expr::Try(x) | Expr::Paren(x) => vec![x.as_ref()],
+        Expr::Not(x) | Expr::Try(x) => vec![x.as_ref()],
         Expr::Bang(b) => vec![&b.value],
         Expr::Bind(b) => {
             let mut v = vec![&b.value];
@@ -334,3 +327,28 @@ pub fn countVar(body: &FnBody, name: &str) -> usize {
         FnBody::Extern => 0,
     }
 }
+/// Pattern casing rule: a Capitalised name is always a tag, a lowercase name always binds.
+pub fn isTag(n: &str) -> bool {
+    n.chars().next().is_some_and(|c| c.is_uppercase())
+}
+/// Pre-order callback over every expression of `b`, closure bodies and catch blocks included.
+pub fn walkBlockRef(b: &Block, f: &mut dyn FnMut(&Expr)) {
+    for s in &b.stmts {
+        for e in stmtExprRefs(s) {
+            walkRef(e, f);
+        }
+        for blk in stmtBlockRefs(s) {
+            walkBlockRef(blk, f);
+        }
+    }
+}
+/// Pre-order callback over `e` and everything under it.
+pub fn walkRef(e: &Expr, f: &mut dyn FnMut(&Expr)) {
+    anyExpr(e, &mut |x| {
+        f(x);
+        false
+    });
+}

plum-core/src/whistle.rs CHANGED Viewed

@@ -32,7 +32,6 @@ fn argExprs(args: &[Arg]) -> (String, Vec<&Expr>) {
 fn view(e: &Expr) -> View<'_> {
     use View::*;
     match e {
-        Expr::Paren(inner) => view(inner),
         Expr::Var(_) | Expr::Self_ => Var,
         Expr::Binary(b) => Node(format!("bin:{:?}", b.op), vec![&b.left, &b.right]),
         Expr::Unary(u) => Node(format!("un:{:?}", u.op), vec![&u.operand]),

plum-core/tests/inline_variants_test.rs CHANGED Viewed

@@ -107,11 +107,11 @@ fn type_position_errors() {
         "fun fa(gg: fn(Cons[Int]) -> Int) -> Int = 1\n",
         "fun fa() -> Int =\n  cc: Cons[Int] := todo\n  1\n",
     ] {
-        let mut s = parse(&format!("enum Link[T] = Nil | Cons(head: T)\n{src}"));
+        let mut s = plum_test_support::parseRawSource(&format!("enum Link[T] = Nil | Cons(head: T)\n{src}"));
         assert!(hoistInlineVariants(&mut s).is_empty());
         assert_eq!(inlineVariantTypeErrors(&s), msg, "{src}");
     }
-    let mut s = parse(
+    let mut s = plum_test_support::parseRawSource(
         "enum Link[T] = Nil | Cons(head: T)\nfun fa(cc: Link[Int]) -> Link[Int] = Cons(head: 1)\nfun gb(cc: Link[Int]) -> Int = match cc\n  Cons(head) => head\n  Nil => 0\n",
     );
     assert!(hoistInlineVariants(&mut s).is_empty());

plum-core/tests/loader_test.rs CHANGED Viewed

@@ -532,3 +532,34 @@ fn nestedStdImportResolvesToASubdirectory() {
     );
     assert!(loadAndMerge(&missing, &lib_path).is_err());
 }
+/// Import-free programs (every plum-examples file imports std, so small inline programs are used):
+/// the single-file `parseSource` front end must give the same AST as the loader.
+#[test]
+fn single_file_equals_loader() {
+    let programs = [
+        "fun id(a: Unit) -> Unit = a\nfun main(u: Unit) = id(u)\n",
+        "record Pt(x: Unit, y: Unit)\nfun mk(u: Unit) = Pt(x: u, y: u)\n",
+        "trait Actor(x: Unit)\nrecord Boss(Actor(x), hp: Unit)\nfun main(u: Unit) = Boss(x: u, hp: u)\n",
+        "enum Shape = Circle | Dot\nfun f(s: Shape) = s\n",
+        "enum Shape = Circle(r: Unit) | Sq\nfun f(s: Shape) = s\n",
+    ];
+    for src in programs {
+        let dir = TempDir::new().unwrap();
+        let entry = dir.path().join("main.plum");
+        fs::write(&entry, src).unwrap();
+        let mut parser = tree_sitter::Parser::new();
+        parser.set_language(&tree_sitter_plum::LANGUAGE.into()).unwrap();
+        let tree = parser.parse(src, None).unwrap();
+        let single = plum_core::AstParser::new(src).parseSource(tree.root_node());
+        let merged = loadAndMerge(&entry, dir.path()).expect("loadAndMerge failed");
+        // The loader stamps each item with its path; blank those out before comparing.
+        let norm = |x: &plum_core::ast::Source| {
+            // the loader drops `topLevelOrder` after merging; items and traits are the lowered program
+            let d = format!("{:?} {:?}", x.items, x.traits);
+            d.replace(&format!("file: {:?}", entry.to_string_lossy()), "file: \"\"")
+                .replace(&format!("file: {:?}", fs::canonicalize(&entry).unwrap().to_string_lossy()), "file: \"\"")
+        };
+        assert_eq!(norm(&single), norm(&merged), "mismatch for {src}");
+    }
+}

plum-core/tests/lower_test.rs ADDED Viewed

@@ -0,0 +1,19 @@
+#![allow(non_snake_case)]
+use plum_core::ast::*;
+use plum_core::lower::frontEnd;
+#[test]
+fn lowersTraits() {
+    let mut s = plum_test_support::parseRawSource(
+        "trait Actor =\n  fun up(self)\n\nrecord Hut(Actor, k: Int) =\n  override fun up(self) -> Int = 1\n",
+    );
+    assert_eq!(frontEnd(&mut s), Ok(()));
+    assert!(!s.items.iter().any(|i| matches!(i, Item::Trait(_))));
+    assert_eq!(s.traits.len(), 1);
+}
+#[test]
+fn unknownMemberErrors() {
+    let mut s = plum_test_support::parseRawSource("enum Shape = Nope[Int] | Red");
+    assert_eq!(frontEnd(&mut s), Err("unknown member type Nope".to_string()));
+}

plum-core/tests/parser_test.rs CHANGED Viewed

@@ -516,8 +516,7 @@ fn bang_vs_neq_lexing() {
     let Expr::Compare(c) = bodyExpr(onlyFn(&s)) else {
         panic!()
     };
-    let Expr::Paren(p) = &c.left else { panic!() };
-    assert!(matches!(**p, Expr::Bang(_)));
+    assert!(matches!(c.left, Expr::Bang(_)));
 }
 // `catch` has the lowest precedence of any expression form: its default
@@ -953,7 +952,7 @@ fn one_line_generic_member() {
 #[test]
 fn inline_payload_still_parses() {
-    let source = parse("enum Sh =\n  | Circle(r: Float)\n  | Dot(Int)\n");
+    let source = parseRaw("enum Sh =\n  | Circle(r: Float)\n  | Dot(Int)\n");
     let e = onlyEnum(&source);
     assert!(e.variants[0].member.is_none());
     assert_eq!(e.variants[0].fields.len(), 1);
@@ -1036,3 +1035,12 @@ fn field_less_record_parses() {
         assert_eq!(e.variants[0].fields.len(), 0);
     }
 }
+// Grouping braces leave no AST node, but precedence holds: `{1 + 2} * 3` is (1 + 2) * 3.
+#[test]
+fn groupingKeepsPrecedenceWithoutNode() {
+    let s = parse("fun f() -> Int = {1 + 2} * 3\n");
+    let Expr::Binary(b) = bodyExpr(onlyFn(&s)) else { panic!() };
+    assert!(matches!(b.left, Expr::Binary(_)));
+    assert!(matches!(b.right, Expr::Int(3)));
+}

plum-core/tests/tests_lower_test.rs ADDED Viewed

@@ -0,0 +1,39 @@
+#![allow(non_snake_case)]
+use plum_core::ast::*;
+use plum_core::tests_lower::{lowerTests, ASSERT_REPORT_MARK};
+const SRC: &str = "test \"a\"\n  assert 1 + 1 == 2\n  assert 2 == 2\n";
+fn fnNamed<'a>(s: &'a Source, n: &str) -> &'a Fn {
+    s.items.iter().find_map(|i| match i { Item::Fn(f) if f.name == n => Some(f), _ => None }).unwrap()
+}
+#[test]
+fn lowersOneTest() {
+    let src = plum_test_support::parseRawSource(SRC);
+    let p = lowerTests(&src);
+    assert_eq!(p.names, vec!["a"]);
+    assert_eq!(p.extraExports, vec![("__test_0".to_string(), "test#a".to_string())]);
+    assert!(!p.source.items.iter().any(|i| matches!(i, Item::Test(_))));
+    fnNamed(&p.source, "__test_0");
+}
+#[test]
+fn assertNamesPerCompile() {
+    let src = plum_test_support::parseRawSource(SRC);
+    let a = lowerTests(&src);
+    let b = lowerTests(&src);
+    assert_eq!(format!("{:?}", fnNamed(&a.source, "__test_0").body), format!("{:?}", fnNamed(&b.source, "__test_0").body));
+    let dbg = format!("{:?}", fnNamed(&a.source, "__test_0").body);
+    assert!(dbg.contains("__lhs_0") && dbg.contains("__rhs_1") && !dbg.contains("__lhs_2"));
+}
+#[test]
+fn failureMessageText() {
+    let src = plum_test_support::parseRawSource(SRC);
+    let dbg = format!("{:?}", fnNamed(&lowerTests(&src).source, "__test_0").body);
+    assert!(dbg.contains("assert-report"));
+    assert!(dbg.contains("      Expected: "));
+    assert!(dbg.contains("\\n      Actual:   "));
+    assert_eq!(ASSERT_REPORT_MARK, "\u{1}assert-report");
+}

plum-core/tests/uniqueness_test.rs CHANGED Viewed

@@ -44,7 +44,6 @@ fn super_walk(b: &mut Block, found: &mut bool) {
                     *found = true;
                 }
             }
-            Expr::Paren(x) => ex(x, found),
             Expr::InlineIf(i) => {
                 ex(&i.then, found);
                 ex(&i.else_, found);

plum-core/tests/visit_test.rs CHANGED Viewed

@@ -80,9 +80,3 @@ fn countVarSeesClosures() {
     let src = "fun t(x: Int) -> Int =\n  f := |y| y + x\n  return x + f(x)\n";
     assert_eq!(countVar(&fnBody(src), "x"), 3);
 }
-#[test]
-fn unparenStrips() {
-    let e = Expr::Paren(Box::new(Expr::Paren(Box::new(Expr::Int(1)))));
-    assert!(matches!(unparen(&e), Expr::Int(1)));
-}

plum-game/tests/host_test.rs CHANGED Viewed

@@ -9,8 +9,7 @@ fn root() -> PathBuf {
 fn compile(src_path: &Path) -> Vec<u8> {
     let source = plum_core::loadAndMerge(src_path, &root()).expect("load");
-    let typed = plum_wasm_codegen::typeCheckIn(&source, &src_path.display().to_string()).expect("typecheck");
-    plum_wasm_codegen::compileTyped(&source, typed).expect("compile")
+    plum_wasm_codegen::compile(&source, &plum_wasm_codegen::CompileOptions::default()).expect("compile").wasm
 }
 fn fixture() -> Vec<u8> {

plum-lsp/src/completion.rs CHANGED Viewed

@@ -610,7 +610,7 @@ pub fn stdLibIndex(lib_path: &Path) -> HashMap<String, String> {
         let Some(tree) = parser.parse(&text, None) else {
             continue;
         };
-        let source = plum_core::AstParser::new(&text).parseSource(tree.root_node());
+        let source = plum_core::AstParser::new(&text).parseSourceRaw(tree.root_node());
         for item in &source.items {
             let name = match item {
                 ast::Item::Fn(f) if f.type_param.is_none() => Some(f.name.clone()),

plum-lsp/src/main.rs CHANGED Viewed

@@ -113,7 +113,7 @@ impl Backend {
         let line_text = text.lines().nth(pos.line as usize).unwrap_or("");
         let sanitized = completion::sanitizeForParsing(&text, pos);
         let tree = Self::parseTree(&sanitized);
-        let own_source = plum_core::AstParser::new(&sanitized).parseSource(tree.root_node());
+        let own_source = plum_core::AstParser::new(&sanitized).parseSourceRaw(tree.root_node());
         if let Some(receiver) = completion::receiverBeforeDot(line_text, pos.character as usize) {
             let Ok(path) = uri.to_file_path() else {
@@ -354,7 +354,7 @@ fn memberCompletionFor(
         return Vec::new();
     };
     let tree = Backend::parseTree(text);
-    let own_source = plum_core::AstParser::new(text).parseSource(tree.root_node());
+    let own_source = plum_core::AstParser::new(text).parseSourceRaw(tree.root_node());
     // `Type.`: its associated consts and static functions.
     if receiver
         .chars()
@@ -432,7 +432,7 @@ fn inheritedFrom(
             }
         };
         let tree = Backend::parseTree(&content);
-        let src = plum_core::AstParser::new(&content).parseSource(tree.root_node());
+        let src = plum_core::AstParser::new(&content).parseSourceRaw(tree.root_node());
         for i in &src.items {
             if let ast::Item::Enum(e) = i {
                 if e.isRecord {
@@ -553,7 +553,7 @@ fn resolveTarget(
             .unwrap_or(0);
         let receiver = &before[rs..];
         let tree = Backend::parseTree(text);
-        let own = plum_core::AstParser::new(text).parseSource(tree.root_node());
+        let own = plum_core::AstParser::new(text).parseSourceRaw(tree.root_node());
         let (global_env, methods, enum_variants, enum_params) =
             plum_checker::buildGlobalTables(&merged);
         let min_required = plum_checker::buildMinRequiredArgs(&merged);
@@ -624,7 +624,7 @@ fn recordHover(text: &str, line0: usize, col: usize) -> Option<String> {
     let (s, e) = identAt(lineText, col)?;
     let word = &lineText[s..e];
     let tree = Backend::parseTree(text);
-    let own = plum_core::AstParser::new(text).parseSource(tree.root_node());
+    let own = plum_core::AstParser::new(text).parseSourceRaw(tree.root_node());
     let is = own.items.iter().any(|i| {
         matches!(i, ast::Item::Enum(en) if en.name == word && (en.isRecord || en.isValue) && !en.isTrait)
     });
@@ -841,7 +841,7 @@ mod tests {
     fn complete_ctor_offers_only_ctor_params() {
         let src = "module t\n\ntrait Actor(x: Int, y: Int, hp: Int)\n\nrecord Ship(Actor(x, y), tex: Int)\n";
         let tree = Backend::parseTree(src);
-        let ast = plum_core::AstParser::new(src).parseSource(tree.root_node());
+        let ast = plum_core::AstParser::new(src).parseSourceRaw(tree.root_node());
         let labels: Vec<String> = completion::ctorArgItems(&ast, &ast, "Ship").into_iter().map(|i| i.label).collect();
         assert_eq!(labels, vec!["x:", "y:", "tex:"]);
         assert_eq!(completion::enclosingCtor("  v := Vec(x: 1, "), Some("Vec".into()));

plum-wasm-codegen/src/lib.rs CHANGED Viewed

@@ -1728,7 +1728,15 @@ pub fn typeCheck(source: &ast::Source) -> Result<plum_checker::TypedInfo, String
 /// Like `typeCheck`, naming `file` in positioned errors. Positions refer to the
 /// merged source, so imported-file errors are attributed to the entry file.
 pub fn typeCheckIn(source: &ast::Source, file: &str) -> Result<plum_checker::TypedInfo, String> {
+    typeCheckWith(source, file, plum_checker::fusionOptions())
+}
+fn typeCheckWith(
+    source: &ast::Source,
+    file: &str,
+    fusion: plum_checker::FusionOptions,
+) -> Result<plum_checker::TypedInfo, String> {
-    plum_checker::typedSource(source).map_err(|errs| {
+    plum_checker::typedSourceWith(source, fusion).map_err(|errs| {
         errs.iter()
             .map(|e| {
                 if e.line > 0 && !file.is_empty() {
@@ -1750,315 +1758,83 @@ pub fn typeCheckIn(source: &ast::Source, file: &str) -> Result<plum_checker::Typ
     })
 }
-/// Compiles a source already checked by `plum_checker::typedSource(source)`
-/// (the `TypedInfo` is keyed by expression address, so it must come from this
-/// very `source` value). Hosts that check once call this; `compileSource`
-/// checks and compiles in one step.
+/// What `compile` does besides compiling.
+#[derive(Clone, Copy, Debug)]
-pub fn compileTyped(
+pub struct CompileOptions {
+    /// Lower `test` blocks into exported `"test#<name>"` fns (`plum test`); otherwise
+    /// they are stripped.
-    source: &ast::Source,
+    pub tests: bool,
-    typed: plum_checker::TypedInfo,
+    pub fusion: plum_checker::FusionOptions,
-) -> Result<Vec<u8>, String> {
-    compileSourceInner(source, &[], typed).map(|(bytes, _)| bytes)
 }
-pub fn compileSource(source: &ast::Source) -> Result<Vec<u8>, String> {
-    compileTyped(source, typeCheck(source)?)
-}
-/// Like `compileSource`, also returning the key of every compiled function
-/// (`name` or `Receiver::method`) — one entry per source function, since a
-/// generic function/method compiles exactly once however many types it is
-/// instantiated at.
-pub fn compileSourceWithFunctions(source: &ast::Source) -> Result<(Vec<u8>, Vec<String>), String> {
-    compileSourceInner(source, &[], typeCheck(source)?)
-}
-/// Compiles `test "..." { ... }` blocks for `plum test`, stripped from every
-/// other build path. Each `test` is desugared into an ordinary zero-param `Fn`
-/// returning `Str` BEFORE the normal compile pipeline ever sees it — a hidden
-/// `__report` local starts at `""`, every `assert cond` inside the test body
-/// desugars into `if !cond { __report = __report + "line L, column C: assert
-/// failed: <source text>\n" }` (which is why a failing `assert` INSIDE a test
-/// doesn't stop the rest of it, unlike an `assert` anywhere else in the
-/// program, which still hard-traps — see the plain `ast::Stmt::Assert` compile
-/// arm), and the block's tail expression returns `__report` (empty = every
-/// assertion passed). Returns the compiled module alongside each test's
-/// original display name, in the same order as its exported `"test#<name>"`
-/// function.
-pub fn compileTestSource(source: &ast::Source) -> Result<(Vec<u8>, Vec<String>), String> {
-    let prog = desugarTests(source);
-    let typed = typeCheck(&prog.source)?;
-    compileTestTyped(&prog, typed)
+impl Default for CompileOptions {
-}
-/// A source with its `test` blocks desugared into ordinary fns. Type-check
-/// `source` (not the original) and pass the result to `compileTestTyped`.
-pub struct TestProgram {
+    fn default() -> Self {
-    pub source: ast::Source,
-    extra_exports: Vec<(String, String)>,
-    pub names: Vec<String>,
-}
-pub fn desugarTests(source: &ast::Source) -> TestProgram {
-    let (desugared, extra_exports) = desugarTestsToFns(source);
+        CompileOptions { tests: false, fusion: plum_checker::FusionOptions::default() }
-    let names = extra_exports
-        .iter()
-        .map(|(_, export_name)| export_name["test#".len()..].to_string())
-        .collect();
-    TestProgram {
-        source: desugared,
-        extra_exports,
-        names,
     }
 }
+/// The result of `compile`.
+pub struct Output {
-pub fn compileTestTyped(
+    pub wasm: Vec<u8>,
+    /// Key of every compiled function (`name` or `Receiver::method`) — one entry per
-    prog: &TestProgram,
+    /// source function, since a generic compiles once however many types it is used at.
-    typed: plum_checker::TypedInfo,
+    pub fn_keys: Vec<String>,
+    /// With `opts.tests`: each test's display name, in the order of its `"test#<name>"` export.
-) -> Result<(Vec<u8>, Vec<String>), String> {
+    pub test_names: Vec<String>,
-    let (wasm, _) = compileSourceInner(&prog.source, &prog.extra_exports, typed)?;
-    Ok((wasm, prog.names.clone()))
 }
+/// The one compile entry: type-checks `source` (fusion per `opts.fusion`) and compiles it.
-fn strLit(s: String) -> ast::Expr {
+/// With `opts.tests`, `test` blocks are first lowered to ordinary fns (see
-    ast::Expr::String(ast::StringExpr {
+/// `plum_core::tests_lower`) and exported.
+pub fn compile(source: &ast::Source, opts: &CompileOptions) -> Result<Output, String> {
+    if opts.tests {
-        parts: vec![ast::StringPart::Text(s)],
+        let prog = plum_core::tests_lower::lowerTests(source);
+        let typed = typeCheckWith(&prog.source, "", opts.fusion)?;
+        let (wasm, fn_keys) = compileSourceInner(&prog.source, &prog.extraExports, typed)?;
+        Ok(Output { wasm, fn_keys, test_names: prog.names })
+    } else {
+        let typed = typeCheckWith(source, "", opts.fusion)?;
+        let (wasm, fn_keys) = compileSourceInner(source, &[], typed)?;
+        Ok(Output { wasm, fn_keys, test_names: Vec::new() })
-    })
+    }
 }
-/// Builds a failing `assert`'s report line: the literal condition text, plus —
-/// when the condition is a top-level comparison (`left OP right`) — the
-/// ACTUAL (left) and EXPECTED (right) sides' own runtime values underneath,
-/// `assert computed() == literal` being the overwhelmingly common shape a
-/// test writes such a comparison in. Reuses `"{expr}"` string interpolation's
-/// own existing codegen (rather than any special stringification of its
-/// own) — including `Float`, which interpolation now supports by rendering
-/// through `Float.toStr` (`plum-std/Float.plum`), so no type needs
-/// special-casing out here any more. A non-comparison condition (`assert
-/// isEven(4)`) has no meaningful actual/expected split — a boolean condition
-/// is always false by the time this fires — so it's just the bare text.
-/// First part of an assert report string: tells `compileInterpolatedString`
-/// that if any interpolated side has no renderable type (no `toStr`), only the
-/// plain condition-text line (the next part) is emitted.
-const ASSERT_REPORT_MARK: &str = "\u{1}assert-report";
-fn assertFailureMessage(c: &ast::Check, lhs: &ast::Expr, rhs: &ast::Expr) -> ast::Expr {
-    let isNullLit =
-        |e: &ast::Expr| matches!(e, ast::Expr::ErrorValue(v) if v.name == ast::NULL_ERR_NAME);
-    let plain = match &c.cond {
-        ast::Expr::Compare(cmp) => isNullLit(&cmp.left) || isNullLit(&cmp.right),
-        _ => true,
-    };
-    if plain {
-        return strLit(format!("{}\n", c.text));
-    }
-    ast::Expr::String(ast::StringExpr {
-        parts: vec![
-            ast::StringPart::Text(ASSERT_REPORT_MARK.to_string()),
-            ast::StringPart::Text(format!("{}\n", c.text)),
+fn threadLocalOptions(tests: bool) -> CompileOptions {
-            ast::StringPart::Text("      Expected: ".to_string()),
+    CompileOptions { tests, fusion: plum_checker::fusionOptions() }
-            ast::StringPart::Interp(rhs.clone()),
-            ast::StringPart::Text("\n      Actual:   ".to_string()),
-            ast::StringPart::Interp(lhs.clone()),
-            ast::StringPart::Text("\n".to_string()),
-        ],
-    })
 }
-fn desugarTestsToFns(source: &ast::Source) -> (ast::Source, Vec<(String, String)>) {
+pub fn compileSource(source: &ast::Source) -> Result<Vec<u8>, String> {
-    let mut items = Vec::with_capacity(source.items.len());
+    compile(source, &threadLocalOptions(false)).map(|o| o.wasm)
-    let mut extra_exports = Vec::new();
-    let mut test_idx = 0usize;
-    // Tests may use `io` when std/Io is loaded: the export wrapper passes the `Io`.
-    let hasIo = source.items.iter().any(|it| matches!(it, ast::Item::Enum(c) if c.name == "Io"));
-    let ioParam = if hasIo {
-        vec![ast::Param {
-            name: "io".to_string(),
-            ty: ast::ParamType::Type(ast::Type { name: "Io".to_string(), generics: vec![] }),
-            default: None,
-        }]
+}
-    } else {
-        vec![]
-    };
-    for item in &source.items {
-        match item {
-            // Tests declared in imported files are not run: only the entry file's own.
-            ast::Item::Test(t) if !t.file.is_empty() && t.file != source.file => {}
-            ast::Item::Test(t) => {
-                // Leading "__" can never collide with a real Plum-declared name —
-                // `fn_identifier`/`var_identifier` must start with a lowercase letter.
-                let internal_name = format!("__test_{}", test_idx);
-                test_idx += 1;
-                let mut stmts = Vec::with_capacity(t.body.stmts.len() + 2);
-                stmts.push(ast::Stmt::Assign(ast::Assign {
-                    isSynthetic: false,
-                    targets: vec![ast::AssignTarget::Var("__report".to_string())],
-                    values: vec![strLit(String::new())],
-                    declare: true,
-                    ty: None,
-                }));
-                stmts.extend(desugarAssertStmts(&t.body.stmts));
-                stmts.push(ast::Stmt::Expr(
-                    ast::Expr::Var("__report".to_string()),
-                    0,
-                    0,
-                ));
-                items.push(ast::Item::Fn(ast::Fn {
+pub use plum_core::tests_lower::{TestProgram, ASSERT_REPORT_MARK};
+#[cfg(test)]
-                    file: source.file.clone(),
+mod compileEntryTests {
-                    name: internal_name.clone(),
-                    line: t.line,
-                    column: t.column,
-                    type_param: None,
-                    is_extern: false,
-                    is_export: false,
-                    is_override: false,
-                    is_star: false,
-                    has_self: true,
-                    yields: None,
+    use super::*;
-                    params: ioParam.clone(),
+    const SRC: &str = "import std/Str\nimport std/Int\n\nfun main() -> Int = 1 + 2\n\ntest \"a\"\n  assert 1 == 1\n";
-                    returns: Some(ast::Type {
+    fn load() -> ast::Source {
-                        name: ast::STR_TYPE.to_string(),
-                        generics: vec![],
-                    }),
-                    body: ast::FnBody::Block(ast::Block { stmts }),
-                }));
-                extra_exports.push((internal_name, format!("test#{}", t.name)));
+        let dir = std::env::temp_dir().join(format!("plum_compile_entry_{}", std::process::id()));
-            }
+        std::fs::create_dir_all(&dir).unwrap();
+        let path = dir.join("main.plum");
-            other => items.push(other.clone()),
+        std::fs::write(&path, SRC).unwrap();
-        }
+        plum_core::loadAndMerge(&path, &plum_test_support::repoRoot()).expect("load")
     }
-    (
-        ast::Source {
-            file: source.file.clone(),
-            module: source.module.clone(),
-            imports: source.imports.clone(),
-            items,
-            topLevelOrder: Vec::new(),
-            formErrors: source.formErrors.clone(),
-            formUses: source.formUses.clone(),
-            stars: source.stars.clone(),
-            formLoops: source.formLoops,
-            primitives: source.primitives.clone(),
-            traits: source.traits.clone(),
-        },
-        extra_exports,
-    )
-}
-/// Recursively rewrites every `assert cond` (`cond` carrying its own literal
+    #[test]
-/// source text, captured at parse time — see `ast::Check`) into
+    fn defaultMatchesCompileSource() {
-/// `if !cond { __report = __report + "<text>\n" }`, descending into nested
-/// control-flow blocks so an `assert` inside a `test`'s own
+        let src = load();
-/// `if`/`while`/`for`/`match` still records into the same hidden accumulator.
-fn desugarAssertStmts(stmts: &[ast::Stmt]) -> Vec<ast::Stmt> {
+        let out = compile(&src, &CompileOptions::default()).expect("compiles");
-    stmts.iter().flat_map(desugarAssertStmt).collect()
+        assert!(out.test_names.is_empty());
+        assert_eq!(out.wasm, compileSource(&src).expect("compiles"));
-}
+    }
-fn desugarAssertStmt(stmt: &ast::Stmt) -> Vec<ast::Stmt> {
-    match stmt {
+    #[test]
-        ast::Stmt::Assert(c) => {
-            // A comparison evaluates each operand exactly once into a
-            // temporary (left first), then compares and reports the temporaries.
-            static ASSERT_TMP: std::sync::atomic::AtomicUsize =
-                std::sync::atomic::AtomicUsize::new(0);
-            let mut pre = Vec::new();
+    fn testsOptionNamesTests() {
-            let mut cond = c.cond.clone();
-            let (mut lhs, mut rhs) = (ast::Expr::Var(String::new()), ast::Expr::Var(String::new()));
-            let isNullLit = |e: &ast::Expr| matches!(e, ast::Expr::ErrorValue(v) if v.name == ast::NULL_ERR_NAME);
-            // `x == null` has no value to print for the null side: reported as a plain condition.
-            if let ast::Expr::Compare(cmp) = &c.cond {
-                if isNullLit(&cmp.left) || isNullLit(&cmp.right) {
-                    // falls through with the condition kept whole
-                } else {
-                    let n = ASSERT_TMP.fetch_add(1, std::sync::atomic::Ordering::Relaxed);
-                    let (l, r) = (format!("__lhs_{}", n), format!("__rhs_{}", n));
-                    for (name, e) in [(&l, &cmp.left), (&r, &cmp.right)] {
-                        pre.push(ast::Stmt::Assign(ast::Assign {
-                            isSynthetic: false,
-                            targets: vec![ast::AssignTarget::Var(name.clone())],
-                            values: vec![e.clone()],
-                            declare: true,
-                            ty: None,
-                        }));
-                    }
-                    lhs = ast::Expr::Var(l);
-                    rhs = ast::Expr::Var(r);
-                    cond = ast::Expr::Compare(Box::new(ast::CompareExpr {
-                        op: cmp.op.clone(),
-                        left: lhs.clone(),
+        let src = load();
-                        right: rhs.clone(),
-                    }));
-                }
-            }
-            let appendReport = ast::Stmt::Assign(ast::Assign {
+        let out = compile(&src, &CompileOptions { tests: true, ..CompileOptions::default() }).expect("compiles");
-                isSynthetic: false,
-                targets: vec![ast::AssignTarget::Var("__report".to_string())],
+        assert_eq!(out.test_names, vec!["a".to_string()]);
-                values: vec![ast::Expr::Binary(Box::new(ast::BinaryExpr {
-                    op: ast::BinOp::Add,
-                    left: ast::Expr::Var("__report".to_string()),
-                    right: assertFailureMessage(c, &lhs, &rhs),
-                }))],
-                declare: false,
-                ty: None,
-            });
-            pre.push(ast::Stmt::If(ast::If {
-                condition: ast::Expr::Not(Box::new(cond)),
-                body: ast::Block {
-                    stmts: vec![appendReport],
-                },
-                else_ifs: vec![],
-                else_: None,
-            }));
-            pre
-        }
-        ast::Stmt::If(i) => vec![ast::Stmt::If(ast::If {
-            condition: i.condition.clone(),
-            body: ast::Block {
-                stmts: desugarAssertStmts(&i.body.stmts),
-            },
-            else_ifs: i
-                .else_ifs
-                .iter()
-                .map(|ei| ast::ElseIf {
-                    condition: ei.condition.clone(),
-                    body: ast::Block {
-                        stmts: desugarAssertStmts(&ei.body.stmts),
-                    },
-                })
-                .collect(),
-            else_: i.else_.as_ref().map(|b| ast::Block {
-                stmts: desugarAssertStmts(&b.stmts),
-            }),
-        })],
-        ast::Stmt::While(w) => vec![ast::Stmt::While(ast::While {
-            condition: w.condition.clone(),
-            body: ast::Block {
-                stmts: desugarAssertStmts(&w.body.stmts),
-            },
-        })],
-        ast::Stmt::ForLoop(f) => vec![ast::Stmt::ForLoop(ast::ForLoop {
-            body: ast::Block {
-                stmts: desugarAssertStmts(&f.body.stmts),
-            },
-            ..f.clone()
-        })],
-        ast::Stmt::Match(m) => vec![ast::Stmt::Match(ast::Match {
-            subjects: m.subjects.clone(),
-            cases: m
-                .cases
-                .iter()
-                .map(|c| ast::Case {
-                    patterns: c.patterns.clone(),
-                    guard: c.guard.clone(),
-                    body: ast::Block {
-                        stmts: desugarAssertStmts(&c.body.stmts),
-                    },
-                })
-                .collect(),
-        })],
-        other => vec![other.clone()],
     }
 }
@@ -4051,7 +3827,6 @@ impl<'a, 't> ClosureWalker<'a, 't> {
             ast::Expr::Not(inner) => self.walkExpr(inner),
             ast::Expr::Try(inner) => self.walkExpr(inner),
             ast::Expr::Unary(u) => self.walkExpr(&u.operand),
-            ast::Expr::Paren(inner) => self.walkExpr(inner),
             ast::Expr::InlineIf(t) => {
                 self.walkExpr(&t.condition);
                 self.walkExpr(&t.then);
@@ -4381,9 +4156,6 @@ fn fvCollectRefsExpr(
         ast::Expr::Unary(u) => {
             fvCollectRefsExpr(&u.operand, bound, seen, free, env, fn_decls, fn_locals)
         }
-        ast::Expr::Paren(inner) => {
-            fvCollectRefsExpr(inner, bound, seen, free, env, fn_decls, fn_locals)
-        }
         ast::Expr::InlineIf(t) => {
             fvCollectRefsExpr(&t.condition, bound, seen, free, env, fn_decls, fn_locals);
             if let ast::Expr::Bind(b) = &t.condition {
@@ -4711,7 +4483,6 @@ impl<'a> Collector<'a> {
                 self.walkExpr(inner);
             }
             ast::Expr::Unary(u) => self.walkExpr(&u.operand),
-            ast::Expr::Paren(inner) => self.walkExpr(inner),
             ast::Expr::InlineIf(t) => {
                 self.walkExpr(&t.condition);
                 self.walkExpr(&t.then);
@@ -7045,7 +6816,6 @@ fn calleeText(e: &ast::Expr) -> String {
             ast::AttrKind::Field(f) => f.clone(),
         },
         ast::Expr::Var(n) => n.clone(),
-        ast::Expr::Paren(i) => calleeText(i),
         _ => "value".to_string(),
     }
 }
@@ -7414,9 +7184,6 @@ fn compileExprCore(
                 }
             }
         }
-        ast::Expr::Paren(inner) => {
-            compileExpr(inner, body, ctx, state)?;
-        }
         // `expr?` — if the error code is non-zero, return it from the enclosing
         // function (see `compileErrTry`); otherwise the success value is the result.
         ast::Expr::Try(inner) => compileErrTry(expr, inner, body, ctx, state)?,
@@ -8176,7 +7943,6 @@ fn valueLocalPlace(expr: &ast::Expr, ctx: &LocalCtx) -> Option<(u32, PlumType)>
             let ty = ctx.local_decl_types.get("self").filter(|t| isValueTy(t))?;
             Some((*ctx.locals.get("self")?, ty.clone()))
         }
-        ast::Expr::Paren(inner) => valueLocalPlace(inner, ctx),
         ast::Expr::Attribute(a) => match &a.attr {
             ast::AttrKind::Field(f) => {
                 let (base, bty) = valueLocalPlace(&a.object, ctx)?;

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

@@ -1,5 +1,9 @@
 #![allow(non_snake_case)]
-use plum_wasm_codegen::{compileSource, compileTestSource};
+use plum_wasm_codegen::{compile, compileSource, CompileOptions};
+fn compileTestSource(source: &plum_core::ast::Source) -> Result<(Vec<u8>, Vec<String>), String> {
+    compile(source, &CompileOptions { tests: true, ..CompileOptions::default() }).map(|o| (o.wasm, o.test_names))
+}
 use wasm_encoder::Encode;
 use plum_test_support::{engine as gcEngine, parse, repoRoot};
@@ -1079,7 +1083,8 @@ fn compiledKeys(name: &str, src: &str) -> (Vec<u8>, Vec<String>) {
     let path = dir.join("main.plum");
     std::fs::write(&path, src).unwrap();
     let source = plum_core::loadAndMerge(&path, &repoRoot()).expect("load");
-    let r = plum_wasm_codegen::compileSourceWithFunctions(&source).expect("compile");
+    let o = compile(&source, &CompileOptions::default()).expect("compile");
+    let r = (o.wasm, o.fn_keys);
     let _ = std::fs::remove_dir_all(&dir);
     wasmparser::validate(&r.0).expect("valid wasm");
     r