e8446dd | plum | pyrossh

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

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

e8446dd — Peter John 2026-11-04T20:26:00+05:30

Compiler cleanup phase 3a: per-compile state, no fusion globals

Files changed (21) hide show

docs/plans/2026-11-04-compiler-cleanup-phase3a.progress.md +20 -0
docs/plans/2026-11-04-compiler-cleanup-phase3a.report.json +212 -0
docs/plans/2026-11-04-compiler-cleanup-phase3a.report.md +38 -0
docs/plans/2026-11-04-compiler-cleanup-phase3a.results.md +31 -0
plum-checker/src/lib.rs +108 -181
plum-checker/src/state.rs +126 -0
plum-checker/src/traits.rs +7 -12
plum-checker/src/unions.rs +14 -32
plum-cli/src/game.rs +2 -1
plum-cli/src/main.rs +37 -30
plum-core/src/forms.rs +15 -3
plum-core/src/lib.rs +1 -0
plum-core/src/loader.rs +6 -0
plum-core/src/lower.rs +1 -0
plum-core/src/session.rs +15 -0
plum-core/src/simplify.rs +9 -4
plum-core/tests/session_test.rs +50 -0
plum-core/tests/trmc_test.rs +8 -7
plum-wasm-codegen/src/lib.rs +102 -98
plum-wasm-codegen/tests/e2e_mem/reuse.rs +17 -11
plum-wasm-codegen/tests/fusion_alloc_test.rs +7 -8

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

@@ -0,0 +1,20 @@
+- start 529a1064cb6f0e203401d8c5524b57c7b546bd4b
+- unblocked: dispatched T0 T2 T3 at 19:49:26; waiting on fixes: T1 T4 T5
+- Ruling: T0 skipped (test-cmd.json copied), prime+task sent together - cost: none
+- unblocked: dispatched T1 T4 T5 T6 at 19:50:23; waiting on fixes: none
+- checkpoint T3 a2eb6574c6 core counters per compile
+- Ruling: T3's hash check deferred to T5 (codegen mid-edit by T2 at the time) - cost: none
+- checkpoint T2 95294015b3 codegen state value
+- Note: after T2+T3, closure_spec_test 5 fail and trmc_test 1 fail while T1 is mid-edit on checker lib.rs; diagnose after T1 lands
+- checkpoint T1 dbf61b1b2c checker state value
+- checkpoint T6 dc61485351 checker unions/traits state
+- Note: plum-checker/src/types.rs NAMED_ERR_SETS/FN_ERR_SETS thread-locals remain (not in any 3a task) - left for 3b
+- checkpoint T3 bb7823d076 core counters per compile
+- checkpoint T4 5d6a67b462 fusion globals out
+- tests full passed=807 failed=1 skipped=0 seconds=214.9
+- Ruling: remaining thread-locals accepted - core forms/simplify/loader/unions blocks are all reset by session::begin per compile; checker types.rs FN_ERR_SETS/NAMED_ERR_SETS go in 3b - cost: 4 small holders survive
+- checkpoint T5 e70d20769d verify 3a
+- Ruling: trmc_test::std_map_1m_within_3x_of_build failure in the full run is the known load-sensitive timing test (flaky since phase 1; T5's direct run passed 807/0) - cost: none
+- Ruling: final-review finding (timing test) closed - std_map_1m_within_3x_of_build passes 3/3 run alone on this branch (0.75-0.77s); the full-suite failure was CPU load - cost: none
+- tests full passed=809 failed=0 skipped=0 seconds=61.1
+- checkpoint T1 f822efe1f8 checker state value

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

@@ -0,0 +1,212 @@
+{
+ "projection_note": "projection: fixed forecast saved at lint 2026-11-04T19:49:20 (plan edited since)",
+ "headline": {
+  "wall_min": {
+   "projected": 21.585,
+   "actual": 25.432
+  },
+  "cost_usd_agents": {
+   "projected": 0.400732,
+   "actual": 2.039698
+  },
+  "task_min": {
+   "projected": 32.577,
+   "actual": 33.037
+  },
+  "agents": {
+   "projected": 5,
+   "actual": 10
+  }
+ },
+ "feature": null,
+ "cost_split": {
+  "agents_usd": 1.904189,
+  "rework_usd": 0.135509,
+  "coordinator_usd": 31.381217,
+  "total_usd": 33.420915
+ },
+ "concurrency": {
+  "peak": 3,
+  "projected_peak": 3
+ },
+ "critical_path": {
+  "actual": [
+   "T3",
+   "T5"
+  ],
+  "projected": [
+   "T1",
+   "T4",
+   "T5"
+  ],
+  "projected_min": 21.585
+ },
+ "model_mix": {
+  "sonnet": {
+   "tasks": 4,
+   "cost_usd": 1.594382
+  },
+  "opus": {
+   "tasks": 1,
+   "cost_usd": 0.445316
+  }
+ },
+ "coordinator_cost_by_model": {
+  "opus": 31.381217
+ },
+ "quality": {
+  "tests": {
+   "passed": 809,
+   "failed": 0,
+   "skipped": 0,
+   "seconds": 61.1,
+   "mode": "full",
+   "failures": [],
+   "skipped_tests": []
+  },
+  "first_time_pass": 0,
+  "first_time_n": 0,
+  "rework_dispatches": 1,
+  "open_incidents": 2
+ },
+ "tasks": [
+  {
+   "task": "T5",
+   "model": "opus",
+   "pred_min": 5.742,
+   "actual_min": 8.483,
+   "delta": {
+    "abs": 2.7413,
+    "pct": 47.7
+   },
+   "cost_usd": 0.445316,
+   "first_time_pass": null
+  },
+  {
+   "task": "T1",
+   "model": "sonnet",
+   "pred_min": 8.976,
+   "actual_min": 11.35,
+   "delta": {
+    "abs": 2.374,
+    "pct": 26.4
+   },
+   "cost_usd": 0.549345,
+   "first_time_pass": null
+  },
+  {
+   "task": "T2",
+   "model": "sonnet",
+   "pred_min": 7.036,
+   "actual_min": 5.463,
+   "delta": {
+    "abs": -1.5727,
+    "pct": -22.4
+   },
+   "cost_usd": 0.288141,
+   "first_time_pass": null
+  },
+  {
+   "task": "T3",
+   "model": "sonnet",
+   "pred_min": 3.956,
+   "actual_min": 3.398,
+   "delta": {
+    "abs": -0.5577,
+    "pct": -14.1
+   },
+   "cost_usd": 0.376171,
+   "first_time_pass": null
+  },
+  {
+   "task": "T6",
+   "model": "sonnet",
+   "pred_min": null,
+   "actual_min": 4.342,
+   "delta": {
+    "abs": null,
+    "pct": null
+   },
+   "cost_usd": 0.380725,
+   "first_time_pass": null
+  }
+ ],
+ "cost_table": {
+  "source": "est",
+  "usd": 3.2168,
+  "tokens": 7975937,
+  "wall_min": 89690167.9142,
+  "rows": [
+   {
+    "agent": "a5b9d5a1c5936dbc7",
+    "model": "sonnet",
+    "wall_min": 15.8987,
+    "tokens": 3762158,
+    "usd": 0.9301
+   },
+   {
+    "agent": "a8a003b8140763d73",
+    "model": "opus",
+    "wall_min": 8.4877,
+    "tokens": 557627,
+    "usd": 0.4453
+   },
+   {
+    "agent": "aadb1cc264b30bfb1",
+    "model": "sonnet",
+    "wall_min": 2.7002,
+    "tokens": 339143,
+    "usd": 0.1355
+   },
+   {
+    "agent": "aaed74cd7cef5ea8b",
+    "model": "sonnet",
+    "wall_min": 29896696.8122,
+    "tokens": 0,
+    "usd": 0.0
+   },
+   {
+    "agent": "ab29eca71a3d8584f",
+    "model": "opus",
+    "wall_min": 0.2177,
+    "tokens": 32198,
+    "usd": 0.111
+   },
+   {
+    "agent": "ac4f885b3a637d9a2",
+    "model": "sonnet",
+    "wall_min": 3.4246,
+    "tokens": 614190,
+    "usd": 0.2407
+   },
+   {
+    "agent": "acab0918e28f4b621",
+    "model": "opus",
+    "wall_min": 7.2594,
+    "tokens": 1916727,
+    "usd": 1.0661
+   },
+   {
+    "agent": "ae8c7981719782a5f",
+    "model": "sonnet",
+    "wall_min": 29896700.1004,
+    "tokens": 0,
+    "usd": 0.0
+   },
+   {
+    "agent": "aec9919ccca8c25c6",
+    "model": "sonnet",
+    "wall_min": 29896727.5257,
+    "tokens": 0,
+    "usd": 0.0
+   },
+   {
+    "agent": "afc79a4ba65a52d67",
+    "model": "sonnet",
+    "wall_min": 5.4876,
+    "tokens": 753894,
+    "usd": 0.2881
+   }
+  ]
+ }
+}

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

@@ -0,0 +1,38 @@
+# superlite build report
+projection: fixed forecast saved at lint 2026-11-04T19:49:20 (plan edited since)
+                         Projected    Actual  Delta
+wall-clock (min)              21.6      25.4  +3.8 (+18%)
+agent cost (USD, +rework)      0.40      2.04  +1.64 (+409%)
+task-minutes                  32.6      33.0  +0.5 (+1%)
+agents                           5        10  +5 (+100%)
+cost split: agents $1.90, rework $0.14, coordinator $31.38, total $33.42
+concurrency: peak 3 at once (projected 3); critical path actual T3 T5; projected T1 > T4 > T5 (21.6 min)
+model mix: opus 1 tasks $0.45, sonnet 4 tasks $1.59, coordinator opus $31.38
+quality: tests 809 passed, 0 failed; first-time pass n/a; rework dispatches 1; open incidents 2
+task  model      pred  actual  delta             cost
+T5    opus        5.7     8.5  +2.7 (+48%)     $0.445
+T1    sonnet      9.0    11.3  +2.4 (+26%)     $0.549
+T2    sonnet      7.0     5.5  -1.6 (-22%)     $0.288
+T3    sonnet      4.0     3.4  -0.6 (-14%)     $0.376
+T6    sonnet      n/a     4.3  n/a             $0.381
+agent cost table:
+| agent | model | wall_min | tokens | usd |
+| --- | --- | --- | --- | --- |
+| a5b9d5a1c5936dbc7 | sonnet | 15.8987 | 3762158 | 0.9301 |
+| a8a003b8140763d73 | opus | 8.4877 | 557627 | 0.4453 |
+| aadb1cc264b30bfb1 | sonnet | 2.7002 | 339143 | 0.1355 |
+| aaed74cd7cef5ea8b | sonnet | 29896696.8122 | 0 | 0.0 |
+| ab29eca71a3d8584f | opus | 0.2177 | 32198 | 0.111 |
+| ac4f885b3a637d9a2 | sonnet | 3.4246 | 614190 | 0.2407 |
+| acab0918e28f4b621 | opus | 7.2594 | 1916727 | 1.0661 |
+| ae8c7981719782a5f | sonnet | 29896700.1004 | 0 | 0.0 |
+| aec9919ccca8c25c6 | sonnet | 29896727.5257 | 0 | 0.0 |
+| afc79a4ba65a52d67 | sonnet | 5.4876 | 753894 | 0.2881 |
+| totals |  | 89690167.9142 | 7975937 | 3.2168 |
+cost source: est
+takeaway: ran 18% slower than projected; cost 409% over; biggest miss T5

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

@@ -0,0 +1,31 @@
+# Compiler cleanup phase 3a: results (T5)
+Start sha 529a106; verified against the uncommitted worktree tree (T1, T2, T3, T4, T6 applied), using a fresh build in a separate CARGO_TARGET_DIR.
+## Wasm hashes
+`scripts/wasm-hashes.sh 529a106` compared with the current tree compiled by a fresh `plum` binary, one process per file: 25/25 examples compile in both, 0 FAIL, and `diff` is empty, so every hash is identical.
+## Tests
+- Workspace: `cargo build --workspace --tests`, then all 60 test executables run directly: 807 passed, 0 failed, 0 ignored.
+- plum-cli binaries: plum (unit) 5, assert_once_test 1, compile_tests 3, crash_test 2, game_web_test 3, host_stub_test 3, test_scope_test 2. All ok.
+- `plum test plum-std plum-examples`: 678 passed, 0 failed (63/63 files).
+- plum-game `host_test` (built inside plum-game/): 18 passed, 0 failed.
+## `thread_local!` blocks in plum-*/src
+| crate | before (529a106) | after |
+|---|---|---|
+| plum-checker | 9 (lib.rs 3, traits.rs 1, types.rs 2, unions.rs 3) | 3 |
+| plum-core | 3 (forms.rs 1, loader.rs 1, unions.rs 1) | 5 |
+| plum-wasm-codegen | 3 (lib.rs) | 1 |
+| total | 15 | 9 |
+These are the blocks that remain after the change:
+- plum-checker/src/state.rs:69 `CHECK: RefCell<CheckState>`: the new checker state holder.
+- plum-checker/src/types.rs:41 `FN_ERR_SETS` and types.rs:48 `NAMED_ERR_SETS`: not in scope for this phase. T1 listed only lib.rs, and T6 listed only unions/traits.
+- plum-wasm-codegen/src/lib.rs:591 `GEN: RefCell<GenState>`: the new codegen state holder.
+- plum-core/src/forms.rs:113 `NEXT_LOOP_ID` (new) and forms.rs:121 `SEQ_KINDS/REG/COUNTER/LOWERED/ERRORS/USES`: the forms session, reset by `session::begin`.
+- plum-core/src/simplify.rs:11 `FRESH` (new): reset by `session::begin`.
+- plum-core/src/loader.rs:511 `USER_PRIMS/MERGED_LIT_ERRORS`: reset by `session::begin`.
+- plum-core/src/unions.rs:516 `PLAN/FRESH`: reset by `session::begin`.
+plum-core went up by 2 blocks because T3 turned the process-global `static AtomicUsize` counters (forms `NEXT_LOOP_ID`, simplify `FRESH`) into thread-locals that reset at the start of each compile. That is what the plan asked for, not a regression.

plum-checker/src/lib.rs CHANGED Viewed

@@ -2,60 +2,19 @@
 // naming convention), not Rust's idiomatic snake_case — silence the resulting lint.
 #![allow(non_snake_case)]
+mod state;
 pub mod traits;
 pub mod types;
 pub mod unions;
 use plum_core::ast;
-use std::cell::{Cell, RefCell};
 use std::collections::{BTreeMap, BTreeSet, HashMap};
+use state::{resetCheck, withCheck};
 use types::{
     errSetNames, CheckError, CheckResult, ErrSet, PlumType, TypeEnv, TypeScheme, FN_ERR_SETS,
     NAMED_ERR_SETS,
 };
-thread_local! {
-    /// Param types for the closure literal about to be inferred as `name := |..| ..`,
-    /// taken from the first later call of `name` (see `closureHintFor`). `Some(vec![])`
-    /// means "assigned to a local, no call information"; the flag is whether an unresolved
-    /// param is an error (the local is never used as a plain value either).
-    static CLOSURE_HINT: RefCell<Option<(Vec<PlumType>, bool)>> = const { RefCell::new(None) };
-    /// Counter for the fresh `_t<N>` inference variables minted per generic call site.
-    static FRESH: Cell<u32> = const { Cell::new(0) };
-    /// When set, `inferExprWith` records every expression's type here (see `typedSource`).
-    static RECORD_BINDS: RefCell<Option<Binds>> = const { RefCell::new(None) };
-    static RECORD: RefCell<Option<HashMap<usize, PlumType>>> = const { RefCell::new(None) };
-    /// Generic-call sites seen while checking one body (see `CallSite`); `None` outside `checkSourceInner`.
-    static CALLS: RefCell<Option<Vec<CallSite>>> = const { RefCell::new(None) };
-    /// While checking a generic body for one instantiation: its generic parameter -> concrete type.
-    static TSUBST: RefCell<Option<BTreeMap<String, PlumType>>> = const { RefCell::new(None) };
-    /// True while checking an instantiated generic body (method lookups on declared types are strict).
-    static INST_MODE: Cell<bool> = const { Cell::new(false) };
-    /// Position (line, column) of the innermost call expression being inferred, or of the
-    /// declaration being checked outside any call: the "called at" site of recorded calls.
-    static CUR_POS: Cell<(usize, usize)> = const { Cell::new((0, 0)) };
-    /// Position of the innermost call whose inference failed, so a statement's
-    /// error points at that call rather than the enclosing fn/test header.
-    static ERR_POS: Cell<Option<(usize, usize)>> = const { Cell::new(None) };
-    /// Address of the expression `inferExprWith` is currently inferring (the innermost one).
-    static CUR_EXPR: Cell<usize> = const { Cell::new(0) };
-    /// While checking the last statement of a value-producing tail (an fn body's
-    /// final `if`/`match`/expression): the type that tail value must have, so its
-    /// generic arguments are pinned like a directly-returned expression's.
-    static TAIL: RefCell<Option<PlumType>> = const { RefCell::new(None) };
-    static MATCH_TAIL: RefCell<Option<PlumType>> = const { RefCell::new(None) };
-    /// Key of the fn whose inferred error set the pre-pass is collecting (`None` otherwise).
-    static CUR_FN: RefCell<Option<String>> = const { RefCell::new(None) };
-    /// Error names contributed to `CUR_FN`'s set by the body being checked.
-    static ERR_ACC: RefCell<BTreeSet<String>> = const { RefCell::new(BTreeSet::new()) };
-    /// Call edges `(caller key, callee key)` seen while collecting error sets.
-    static ERR_EDGES: RefCell<BTreeSet<(String, String)>> = const { RefCell::new(BTreeSet::new()) };
-    /// Error-union sites (`try`, `!`, `catch`, `?:`) recorded for codegen; `None` while collecting.
-    static ERR_SITES: RefCell<Option<HashMap<usize, ErrSite>>> = const { RefCell::new(None) };
-    /// Operator expressions (address) on non-primitive operands -> the synthetic method call
-    /// (`a + b` -> `a.add(b)`) they resolve to. Kept so the cloned arguments have stable addresses.
-    static OP_CALLS: RefCell<HashMap<usize, std::rc::Rc<ast::FnCall>>> = RefCell::new(HashMap::new());
-}
 /// A call to a generic fn/method seen in some body: callee identity plus the
 /// (possibly still unresolved) type bound to each of its generic parameters.
@@ -73,7 +32,7 @@ struct CallSite {
 }
 fn recordCall(recv: Option<&str>, name: &str, args: BTreeMap<String, PlumType>) {
-    recordCallAt(CUR_EXPR.with(|e| e.get()), false, recv, name, args);
+    recordCallAt(withCheck(|s| { let e = &s.cur_expr; e.get() }), false, recv, name, args);
 }
 fn recordCallAt(
@@ -86,8 +45,8 @@ fn recordCallAt(
     if args.is_empty() {
         return;
     }
-    let (line, column) = CUR_POS.with(|p| p.get());
+    let (line, column) = withCheck(|s| { let p = &s.cur_pos; p.get() });
-    CALLS.with(|c| {
+    withCheck(|s| { let c = &s.calls; {
         if let Some(v) = c.borrow_mut().as_mut() {
             v.push(CallSite {
                 recv: recv.map(|r| r.to_string()),
@@ -99,7 +58,7 @@ fn recordCallAt(
                 implicit,
             });
         }
-    });
+    } });
 }
 /// Which error-union operator an `ErrSite` is.
@@ -188,11 +147,11 @@ fn bindAcross(a: &PlumType, b: &PlumType) {
 }
 fn freshVar() -> PlumType {
-    FRESH.with(|c| {
+    withCheck(|s| { let c = &s.fresh; {
         let n = c.get();
         c.set(n + 1);
         PlumType::TVar(format!("_t{}", n))
-    })
+    } })
 }
 /// Binding of `_t<N>` inference variables to types, local to one call site.
@@ -348,7 +307,7 @@ pub fn plumTypeFromAstG(ty: &ast::Type) -> PlumType {
         );
     }
     if isGenericName(&ty.name) {
-        if let Some(t) = TSUBST.with(|s| s.borrow().as_ref().and_then(|m| m.get(&ty.name).cloned()))
+        if let Some(t) = withCheck(|s| { let s = &s.tsubst; s.borrow().as_ref().and_then(|m| m.get(&ty.name).cloned()) })
         {
             return t;
         }
@@ -484,18 +443,18 @@ fn freshOwner(generics: &[String]) -> BTreeMap<String, PlumType> {
 /// then `out.push(x)` bound `_t1`) to a type, so a later `.field` or method
 /// call on a still-variable-typed value (`out.at(0).x`) sees the real type.
 fn resolveRecorded(ty: &PlumType) -> PlumType {
-    RECORD_BINDS.with(|r| match r.borrow().as_ref() {
+    withCheck(|s| { let r = &s.record_binds; match r.borrow().as_ref() {
         Some(b) => substVars(ty, b),
         None => ty.clone(),
-    })
+    } })
 }
 fn recordBind(name: &str, ty: &PlumType) {
-    RECORD_BINDS.with(|r| {
+    withCheck(|s| { let r = &s.record_binds; {
         if let Some(m) = r.borrow_mut().as_mut() {
             m.insert(name.to_string(), ty.clone());
         }
-    });
+    } });
 }
 /// Key offsets (added to an expression's address, which is 8-aligned) under which
@@ -507,14 +466,14 @@ pub const ERR_WRAP: usize = 4;
 pub const ANNOTATED: usize = 3;
 fn recordAnnotation(value: &ast::Expr, declared: &PlumType) {
-    RECORD.with(|r| {
+    withCheck(|s| { let r = &s.record; {
         if let Some(m) = r.borrow_mut().as_mut() {
             m.insert(
                 value as *const ast::Expr as usize + ANNOTATED,
                 declared.clone(),
             );
         }
-    });
+    } });
 }
 /// `+8` (expected a `!T` / `T?`) an error value (`error.X`, `null`, or a variable
@@ -579,7 +538,7 @@ fn recordErrCoercion(
         _ => return,
     };
     let ptr = expr as *const ast::Expr as usize;
-    RECORD.with(|r| {
+    withCheck(|s| { let r = &s.record; {
         if let Some(m) = r.borrow_mut().as_mut() {
             for k in [ERR_WRAP, ERR_WRAP2, ERR_NULL_NESTED, ERR_FROM_NAME] {
                 m.remove(&(ptr + k));
@@ -588,7 +547,7 @@ fn recordErrCoercion(
                 m.insert(ptr + k, t);
             }
         }
-    });
+    } });
 }
 /// `T?` with a reference-type `T` is represented as a nullable reference to `T`
@@ -612,11 +571,11 @@ pub fn nullableErrPayload(ty: &PlumType) -> Option<&PlumType> {
 }
 fn recordType(expr: &ast::Expr, ty: &PlumType) {
-    RECORD.with(|r| {
+    withCheck(|s| { let r = &s.record; {
         if let Some(m) = r.borrow_mut().as_mut() {
             m.insert(expr as *const ast::Expr as usize, ty.clone());
         }
-    });
+    } });
 }
 /// Base name of a nominal type (`TNamed`/`TApp`).
@@ -762,8 +721,8 @@ fn addToErrSet(set: &ErrSet, names: &BTreeSet<String>) -> Result<(), String> {
             None => Ok(()),
         },
         ErrSet::Inferred(k) => {
-            if !k.is_empty() && CUR_FN.with(|c| c.borrow().as_deref() == Some(k.as_str())) {
+            if !k.is_empty() && withCheck(|s| { let c = &s.cur_fn; c.borrow().as_deref() == Some(k.as_str()) }) {
-                ERR_ACC.with(|a| a.borrow_mut().extend(names.iter().cloned()));
+                withCheck(|s| { let a = &s.err_acc; a.borrow_mut().extend(names.iter().cloned()) });
             }
             Ok(())
         }
@@ -1201,7 +1160,7 @@ pub fn checkSource(source: &ast::Source) -> CheckResult<()> {
 /// Type-checks the original source like `checkSource` and also returns the
 /// instantiated type of every expression (keyed by expression address) and the
 /// set of generic instantiations (see `TypedInfo`) for codegen.
-/// Switches for the supercompiler stage of `typedSource` (per thread).
+/// Switches for the supercompiler stage of `typedSource`.
 #[derive(Clone, Copy, Debug)]
 pub struct FusionOptions {
     /// Run the fusion stage (`--no-fusion` clears it).
@@ -1216,32 +1175,6 @@ impl Default for FusionOptions {
     }
 }
-thread_local! {
-    static FUSION_OPTIONS: Cell<FusionOptions> = Cell::new(FusionOptions::default());
-}
-pub fn setFusionOptions(o: FusionOptions) {
-    FUSION_OPTIONS.with(|c| c.set(o));
-}
-pub fn fusionOptions() -> FusionOptions {
-    FUSION_OPTIONS.with(|c| c.get())
-}
-/// Runs `f` with `o` as this thread's fusion options, restoring the previous ones after
-/// (also on panic).
-pub fn withFusionOptions<R>(o: FusionOptions, f: impl FnOnce() -> R) -> R {
-    struct Restore(FusionOptions);
-    impl Drop for Restore {
-        fn drop(&mut self) {
-            setFusionOptions(self.0);
-        }
-    }
-    let _restore = Restore(fusionOptions());
-    setFusionOptions(o);
-    f()
-}
 /// Whether `obj_ty.field` is declared immutable (a record or enum field without `mut`).
 /// `None` for structs (value-local assignment stays allowed) and unknown types.
 fn immutableFieldOwner(obj_ty: &PlumType, field: &str, ctx: &CheckCtx) -> Option<String> {
@@ -1266,7 +1199,7 @@ fn immutableFieldOwner(obj_ty: &PlumType, field: &str, ctx: &CheckCtx) -> Option
 }
 pub fn typedSource(source: &ast::Source) -> CheckResult<TypedInfo> {
-    typedSourceWith(source, fusionOptions())
+    typedSourceWith(source, FusionOptions::default())
 }
 /// Like `typedSource` with explicit fusion options (no thread-local read).
@@ -1578,11 +1511,13 @@ fn ioCapabilityErrors(source: &ast::Source) -> Vec<CheckError> {
 }
 fn checkSourceOnce(source: &ast::Source) -> (CheckResult<()>, TypedInfo) {
+    resetCheck();
+    withCheck(|s| {
+        *s.record.borrow_mut() = Some(HashMap::new());
+        *s.record_binds.borrow_mut() = Some(Binds::new());
+        *s.calls.borrow_mut() = Some(Vec::new());
-    RECORD.with(|r| *r.borrow_mut() = Some(HashMap::new()));
+        *s.err_sites.borrow_mut() = Some(HashMap::new());
-    RECORD_BINDS.with(|r| *r.borrow_mut() = Some(Binds::new()));
-    CALLS.with(|r| *r.borrow_mut() = Some(Vec::new()));
-    OP_CALLS.with(|r| r.borrow_mut().clear());
+    });
-    ERR_SITES.with(|r| *r.borrow_mut() = Some(HashMap::new()));
     let (result, mut info) = checkSourceInner(source);
     let result = {
         let own = ioCapabilityErrors(source);
@@ -1594,19 +1529,17 @@ fn checkSourceOnce(source: &ast::Source) -> (CheckResult<()>, TypedInfo) {
             Err(errs)
         }
     };
-    info.err_sites = ERR_SITES
-        .with(|r| r.borrow_mut().take())
+    info.err_sites = withCheck(|s| { let r = &s.err_sites; r.borrow_mut().take() })
         .unwrap_or_default();
     fillErrorTables(source, &mut info);
     let result = result.map_err(|errs| nameFormErrors(source, errs));
-    info.op_calls = OP_CALLS.with(|r| std::mem::take(&mut *r.borrow_mut()));
+    info.op_calls = withCheck(|s| { let r = &s.op_calls; std::mem::take(&mut *r.borrow_mut()) });
-    let mut recorded = RECORD.with(|r| r.borrow_mut().take()).unwrap_or_default();
+    let mut recorded = withCheck(|s| { let r = &s.record; r.borrow_mut().take() }).unwrap_or_default();
-    let binds = RECORD_BINDS
-        .with(|r| r.borrow_mut().take())
+    let binds = withCheck(|s| { let r = &s.record_binds; r.borrow_mut().take() })
         .unwrap_or_default();
-    CALLS.with(|r| r.borrow_mut().take());
+    withCheck(|s| { let r = &s.calls; r.borrow_mut().take() });
-    TSUBST.with(|s| *s.borrow_mut() = None);
+    withCheck(|s| { let s = &s.tsubst; *s.borrow_mut() = None });
-    INST_MODE.with(|m| m.set(false));
+    withCheck(|s| { let m = &s.inst_mode; m.set(false) });
     // Zonk: apply the final substitution; a variable nothing ever constrained
     // (an unused `None`, an empty literal, ...) is defaulted to `Unit`, since
     // no value of it can ever be observed.
@@ -2347,18 +2280,18 @@ fn checkSourceInner(source: &ast::Source) -> (CheckResult<()>, TypedInfo) {
         file,
     };
     drainCalls();
-    CALLS.with(|c| {
+    withCheck(|s| { let c = &s.calls; {
         if let Some(v) = c.borrow_mut().as_mut() {
             v.extend(const_calls);
         }
-    });
+    } });
     registerCalls(&mut inst, &fn_by_key, &ctx, None);
     // Roots: every non-generic fn and every test. A generic fn is only
     // name-resolved here (its body is type-checked per instantiation below).
     for item in &source.items {
         if let ast::Item::Fn(f) = item {
-            CUR_POS.with(|l| l.set((f.line, f.column)));
+            withCheck(|s| { let l = &s.cur_pos; l.set((f.line, f.column)) });
             if let Some(e) = exportFnError(f, &ctx) {
                 errors.push(e);
                 continue;
@@ -2376,7 +2309,7 @@ fn checkSourceInner(source: &ast::Source) -> (CheckResult<()>, TypedInfo) {
     for item in &source.items {
         if let ast::Item::Test(t) = item {
-            CUR_POS.with(|l| l.set((t.line, t.column)));
+            withCheck(|s| { let l = &s.cur_pos; l.set((t.line, t.column)) });
             let mut env = global_env.clone();
             // A test may use `io` when std/Io is loaded (the test wrapper passes it).
             if source.items.iter().any(|i| matches!(i, ast::Item::Enum(e) if e.name == "Io")) {
@@ -2418,14 +2351,14 @@ fn checkSourceInner(source: &ast::Source) -> (CheckResult<()>, TypedInfo) {
             .cloned()
             .zip(i.type_args.iter().cloned())
             .collect();
-        TSUBST.with(|s| *s.borrow_mut() = Some(subst));
+        withCheck(|s| { let s = &s.tsubst; *s.borrow_mut() = Some(subst) });
-        INST_MODE.with(|m| m.set(true));
+        withCheck(|s| { let m = &s.inst_mode; m.set(true) });
-        CUR_POS.with(|l| l.set((f.line, f.column)));
+        withCheck(|s| { let l = &s.cur_pos; l.set((f.line, f.column)) });
-        let saved = RECORD.with(|r| r.borrow_mut().replace(HashMap::new()));
+        let saved = withCheck(|s| { let r = &s.record; r.borrow_mut().replace(HashMap::new()) });
         let errs = checkFn(f, &global_env, &ctx);
-        let own = RECORD.with(|r| std::mem::replace(&mut *r.borrow_mut(), saved));
+        let own = withCheck(|s| { let r = &s.record; std::mem::replace(&mut *r.borrow_mut(), saved) });
-        TSUBST.with(|s| *s.borrow_mut() = None);
+        withCheck(|s| { let s = &s.tsubst; *s.borrow_mut() = None });
-        INST_MODE.with(|m| m.set(false));
+        withCheck(|s| { let m = &s.inst_mode; m.set(false) });
         for (ptr, t) in own.unwrap_or_default() {
             inst.info.inst_expr_types.insert((id, ptr), t);
         }
@@ -2481,21 +2414,21 @@ fn inferErrorSets(source: &ast::Source, global_env: &TypeEnv, ctx: &CheckCtx) ->
             m.borrow_mut().insert(fnErrKey(f), BTreeSet::new());
         }
     });
-    let saved_record = RECORD.with(|r| r.borrow_mut().take());
+    let saved_record = withCheck(|s| { let r = &s.record; r.borrow_mut().take() });
-    let saved_calls = CALLS.with(|r| r.borrow_mut().take());
+    let saved_calls = withCheck(|s| { let r = &s.calls; r.borrow_mut().take() });
-    let saved_sites = ERR_SITES.with(|r| r.borrow_mut().take());
+    let saved_sites = withCheck(|s| { let r = &s.err_sites; r.borrow_mut().take() });
-    ERR_EDGES.with(|e| e.borrow_mut().clear());
+    withCheck(|s| { let e = &s.err_edges; e.borrow_mut().clear() });
     for _ in 0..64 {
         let mut changed = false;
         for f in &fns {
             let key = fnErrKey(f);
-            CUR_FN.with(|c| *c.borrow_mut() = Some(key.clone()));
+            withCheck(|s| { let c = &s.cur_fn; *c.borrow_mut() = Some(key.clone()) });
-            ERR_ACC.with(|a| a.borrow_mut().clear());
+            withCheck(|s| { let a = &s.err_acc; a.borrow_mut().clear() });
-            RECORD.with(|r| *r.borrow_mut() = Some(HashMap::new()));
+            withCheck(|s| { let r = &s.record; *r.borrow_mut() = Some(HashMap::new()) });
-            CALLS.with(|r| *r.borrow_mut() = Some(Vec::new()));
+            withCheck(|s| { let r = &s.calls; *r.borrow_mut() = Some(Vec::new()) });
-            CUR_POS.with(|l| l.set((f.line, f.column)));
+            withCheck(|s| { let l = &s.cur_pos; l.set((f.line, f.column)) });
             let _ = checkFn(f, global_env, ctx);
-            let acc = ERR_ACC.with(|a| std::mem::take(&mut *a.borrow_mut()));
+            let acc = withCheck(|s| { let a = &s.err_acc; std::mem::take(&mut *a.borrow_mut()) });
             FN_ERR_SETS.with(|m| {
                 let mut m = m.borrow_mut();
                 if m.get(&key) != Some(&acc) {
@@ -2508,11 +2441,11 @@ fn inferErrorSets(source: &ast::Source, global_env: &TypeEnv, ctx: &CheckCtx) ->
             break;
         }
     }
-    CUR_FN.with(|c| *c.borrow_mut() = None);
+    withCheck(|s| { let c = &s.cur_fn; *c.borrow_mut() = None });
-    RECORD.with(|r| *r.borrow_mut() = saved_record);
+    withCheck(|s| { let r = &s.record; *r.borrow_mut() = saved_record });
-    CALLS.with(|r| *r.borrow_mut() = saved_calls);
+    withCheck(|s| { let r = &s.calls; *r.borrow_mut() = saved_calls });
-    ERR_SITES.with(|r| *r.borrow_mut() = saved_sites);
+    withCheck(|s| { let r = &s.err_sites; *r.borrow_mut() = saved_sites });
-    let edges = ERR_EDGES.with(|e| std::mem::take(&mut *e.borrow_mut()));
+    let edges = withCheck(|s| { let e = &s.err_edges; std::mem::take(&mut *e.borrow_mut()) });
     for f in &fns {
         let key = fnErrKey(f);
         if f.is_extern {
@@ -2575,12 +2508,12 @@ fn isResolutionError(msg: &str) -> bool {
 }
 fn drainCalls() -> Vec<CallSite> {
-    CALLS.with(|c| {
+    withCheck(|s| { let c = &s.calls; {
         c.borrow_mut()
             .as_mut()
             .map(std::mem::take)
             .unwrap_or_default()
-    })
+    } })
 }
 /// Generic parameter names of `f`: its owner type's generics, then the free
@@ -2625,8 +2558,7 @@ fn registerCalls(
     ctx: &CheckCtx,
     parent: Option<usize>,
 ) {
-    let binds = RECORD_BINDS
-        .with(|r| r.borrow().clone())
+    let binds = withCheck(|s| { let r = &s.record_binds; r.borrow().clone() })
         .unwrap_or_default();
     let parent_chain = parent.map(|p| st.chains[p].clone()).unwrap_or_default();
     let depth = parent_chain.matches("(called at").count();
@@ -2792,7 +2724,7 @@ fn checkFn(f: &ast::Fn, global_env: &TypeEnv, ctx: &CheckCtx) -> Vec<CheckError>
                     .collect(),
             )
         };
-        let self_ty = match TSUBST.with(|s| s.borrow().clone()) {
+        let self_ty = match withCheck(|s| { let s = &s.tsubst; s.borrow().clone() }) {
             Some(m) => types::substitute(&self_ty, &m),
             None => self_ty,
         };
@@ -2855,10 +2787,10 @@ fn checkFn(f: &ast::Fn, global_env: &TypeEnv, ctx: &CheckCtx) -> Vec<CheckError>
             let n_init = init.len();
             for (i, stmt) in init.iter().enumerate() {
                 if tail.is_none() && i + 1 == n_init && !matches!(declared_ret, PlumType::TUnit) {
-                    TAIL.with(|c| *c.borrow_mut() = Some(declared_ret.clone()));
+                    withCheck(|s| { let c = &s.tail; *c.borrow_mut() = Some(declared_ret.clone()) });
                 }
                 if let Some(hint) = closureHintFor(&block.stmts[i..], &env, ctx) {
-                    CLOSURE_HINT.with(|h| *h.borrow_mut() = Some(hint));
+                    withCheck(|s| { let h = &s.closure_hint; *h.borrow_mut() = Some(hint) });
                 }
                 errors.append(&mut checkStmt(
                     stmt,
@@ -2868,7 +2800,7 @@ fn checkFn(f: &ast::Fn, global_env: &TypeEnv, ctx: &CheckCtx) -> Vec<CheckError>
                     (f.line, f.column),
                     ctx,
                 ));
-                CLOSURE_HINT.with(|h| *h.borrow_mut() = None);
+                withCheck(|s| { let h = &s.closure_hint; *h.borrow_mut() = None });
             }
             if let Some((last_expr, line, column)) = tail {
                 match inferExprWith(last_expr, &env, ctx, Some(&declared_ret)) {
@@ -2904,16 +2836,16 @@ fn checkBlock(
     ctx: &CheckCtx,
 ) -> Vec<CheckError> {
     let mut errors = Vec::new();
-    let tail = TAIL.with(|t| t.borrow_mut().take());
+    let tail = withCheck(|s| { let t = &s.tail; t.borrow_mut().take() });
     for (i, stmt) in block.stmts.iter().enumerate() {
         if i + 1 == block.stmts.len() {
-            TAIL.with(|t| *t.borrow_mut() = tail.clone());
+            withCheck(|s| { let t = &s.tail; *t.borrow_mut() = tail.clone() });
         }
         if let Some(hint) = closureHintFor(&block.stmts[i..], env, ctx) {
-            CLOSURE_HINT.with(|h| *h.borrow_mut() = Some(hint));
+            withCheck(|s| { let h = &s.closure_hint; *h.borrow_mut() = Some(hint) });
         }
         let mut stmt_errors = checkStmt(stmt, env, declared_ret, fn_name, fn_pos, ctx);
-        CLOSURE_HINT.with(|h| *h.borrow_mut() = None);
+        withCheck(|s| { let h = &s.closure_hint; *h.borrow_mut() = None });
         errors.append(&mut stmt_errors);
     }
     errors
@@ -3092,9 +3024,9 @@ fn checkStmt(
     fn_pos: (usize, usize),
     ctx: &CheckCtx,
 ) -> Vec<CheckError> {
-    let saved = ERR_POS.with(|e| e.replace(None));
+    let saved = withCheck(|s| { let e = &s.err_pos; e.replace(None) });
     let mut errors = checkStmtInner(stmt, env, declared_ret, fn_name, fn_pos, ctx);
-    if let Some((l, c)) = ERR_POS.with(|e| e.replace(saved)) {
+    if let Some((l, c)) = withCheck(|s| { let e = &s.err_pos; e.replace(saved) }) {
         for e in errors.iter_mut().filter(|e| (e.line, e.column) == fn_pos) {
             e.line = l;
             e.column = c;
@@ -3112,8 +3044,8 @@ fn checkStmtInner(
     ctx: &CheckCtx,
 ) -> Vec<CheckError> {
     let mut errors = Vec::new();
-    let tail = TAIL.with(|t| t.borrow_mut().take());
+    let tail = withCheck(|s| { let t = &s.tail; t.borrow_mut().take() });
-    let set_tail = |t: &Option<PlumType>| TAIL.with(|c| *c.borrow_mut() = t.clone());
+    let set_tail = |t: &Option<PlumType>| withCheck(|s| { let c = &s.tail; *c.borrow_mut() = t.clone() });
     match stmt {
         // Lowered here, once the type of the source is known (`forms::lowerLoop`);
         // the lowering is checked in place. After `forms::finish` no loops are left.
@@ -3581,7 +3513,7 @@ fn checkStmtInner(
             )),
         },
         ast::Stmt::Match(m) => {
-            MATCH_TAIL.with(|c| *c.borrow_mut() = tail.clone());
+            withCheck(|s| { let c = &s.match_tail; *c.borrow_mut() = tail.clone() });
             errors.append(&mut checkMatch(m, env, declared_ret, fn_name, fn_pos, ctx));
         }
         ast::Stmt::Break | ast::Stmt::Continue | ast::Stmt::Todo => {}
@@ -3840,7 +3772,7 @@ fn checkMatch(
     fn_pos: (usize, usize),
     ctx: &CheckCtx,
 ) -> Vec<CheckError> {
-    let match_tail = MATCH_TAIL.with(|c| c.borrow_mut().take());
+    let match_tail = withCheck(|s| { let c = &s.match_tail; c.borrow_mut().take() });
     let mut errors = Vec::new();
     let mut subject_types: Vec<PlumType> = Vec::new();
@@ -3966,7 +3898,7 @@ fn checkMatch(
                 )),
             }
         }
-        TAIL.with(|c| *c.borrow_mut() = match_tail.clone());
+        withCheck(|s| { let c = &s.tail; *c.borrow_mut() = match_tail.clone() });
         errors.append(&mut checkBlock(
             &case.body,
             &mut case_env,
@@ -4190,18 +4122,13 @@ fn liftInlineVariant(
             ));
         }
     }
-    let addr = CUR_EXPR.with(|c| c.get());
+    let addr = withCheck(|s| { let c = &s.cur_expr; c.get() });
     if addr != 0 {
         plum_core::unions::recordWrap(addr, hidden);
     }
     Ok(lifted)
 }
-thread_local! {
-    /// Address of a top-level `if X := v` pattern, where a bare inline-variant name
-    /// narrows `v` instead of matching a value.
-    static ALLOW_BARE_TOP: std::cell::Cell<usize> = const { std::cell::Cell::new(0) };
-}
 /// A tag of the subject (enum variant, union member record, error name) that `n` equals
 /// case-insensitively. A lowercase pattern name that spells a tag is a mistake, not a binder.
@@ -4249,7 +4176,7 @@ pub(crate) fn checkPattern(
     // An inline variant with fields is never matched bare (Rust semantics): the bare
     // name would narrow to the hidden member and silently never match as written.
     if let ast::CasePattern::Name(n) = pat {
-        let allowed = ALLOW_BARE_TOP.with(|c| c.get()) == pat as *const ast::CasePattern as usize;
+        let allowed = withCheck(|s| { let c = &s.allow_bare_top; c.get() }) == pat as *const ast::CasePattern as usize;
         if let (false, Some(owner), Some(subject)) =
             (allowed, unions::inlineOwner(n), nominalName(subject_ty))
         {
@@ -4592,7 +4519,7 @@ fn inferMethodCall(
     ctx: &CheckCtx,
     expected: Option<&PlumType>,
 ) -> Result<PlumType, String> {
-    let call_addr = CUR_EXPR.with(|c| c.get());
+    let call_addr = withCheck(|s| { let c = &s.cur_expr; c.get() });
     // `e.name()` on an error value (`catch e`) is its text.
     if matches!(obj_ty, PlumType::TErrName(_)) && name == "name" && args.is_empty() {
         return Ok(types::strType());
@@ -4649,7 +4576,7 @@ fn inferMethodCall(
     let Some(class_name) = methodReceiverName(obj_ty) else {
         // Inside an instantiation a concrete receiver with no method table at
         // all (unit, error name, fn type) has no methods.
-        if INST_MODE.with(|m| m.get())
+        if withCheck(|s| { let m = &s.inst_mode; m.get() })
             && !hasFreeVars(obj_ty)
             && !matches!(obj_ty, PlumType::TVar(_))
         {
@@ -4703,7 +4630,7 @@ fn inferMethodCall(
         // erased pass too, so a typo'd method is a positioned checker error
         // rather than a late codegen failure.
         if !hasFreeVars(obj_ty)
-            && (INST_MODE.with(|m| m.get())
+            && (withCheck(|s| { let m = &s.inst_mode; m.get() })
                 || matches!(
                     obj_ty,
                     PlumType::TApp(..) | PlumType::TInt | PlumType::TBool
@@ -4844,7 +4771,7 @@ fn inferOperatorCall(
         ));
     }
     let addr = expr as *const ast::Expr as usize;
-    let call = OP_CALLS.with(|m| {
+    let call = withCheck(|s| { let m = &s.op_calls; {
         m.borrow_mut()
             .entry(addr)
             .or_insert_with(|| {
@@ -4860,7 +4787,7 @@ fn inferOperatorCall(
                 })
             })
             .clone()
-    });
+    } });
     inferMethodCall(lt, method, &call.args, env, ctx, expected)
 }
@@ -4887,7 +4814,7 @@ pub fn inferExprWith(
     ctx: &CheckCtx,
     expected: Option<&PlumType>,
 ) -> Result<PlumType, String> {
-    let prev = CUR_EXPR.with(|c| c.replace(expr as *const ast::Expr as usize));
+    let prev = withCheck(|s| { let c = &s.cur_expr; c.replace(expr as *const ast::Expr as usize) });
     let call_pos = match expr {
         ast::Expr::FnCall(c) => Some((c.line, c.column)),
         ast::Expr::Attribute(a) => match &a.attr {
@@ -4896,21 +4823,21 @@ pub fn inferExprWith(
         },
         _ => None,
     };
-    let prev_pos = CUR_POS.with(|p| p.get());
+    let prev_pos = withCheck(|s| { let p = &s.cur_pos; p.get() });
     if let Some(pos) = call_pos.filter(|p| p.0 != 0) {
-        CUR_POS.with(|p| p.set(pos));
+        withCheck(|s| { let p = &s.cur_pos; p.set(pos) });
     }
-    let entry_err_pos = ERR_POS.with(|e| e.get());
+    let entry_err_pos = withCheck(|s| { let e = &s.err_pos; e.get() });
     let r = inferExprInner(expr, env, ctx, expected);
     if r.is_ok() {
         // Any failure inside was recovered from; it must not mark the statement.
-        ERR_POS.with(|e| e.set(entry_err_pos));
+        withCheck(|s| { let e = &s.err_pos; e.set(entry_err_pos) });
     }
-    if r.is_err() && call_pos.is_some_and(|p| p.0 != 0) && ERR_POS.with(|e| e.get()).is_none() {
+    if r.is_err() && call_pos.is_some_and(|p| p.0 != 0) && withCheck(|s| { let e = &s.err_pos; e.get() }).is_none() {
-        ERR_POS.with(|e| e.set(call_pos));
+        withCheck(|s| { let e = &s.err_pos; e.set(call_pos) });
     }
-    CUR_POS.with(|p| p.set(prev_pos));
+    withCheck(|s| { let p = &s.cur_pos; p.set(prev_pos) });
-    CUR_EXPR.with(|c| c.set(prev));
+    withCheck(|s| { let c = &s.cur_expr; c.set(prev) });
     if let Ok(t) = &r {
         recordType(expr, t);
         recordErrCoercion(expr, t, expected, ctx);
@@ -4918,8 +4845,8 @@ pub fn inferExprWith(
         // A call returning another fn's inferred `!T` is an edge of the call graph.
         if let PlumType::TErr(_, ErrSet::Inferred(k)) = t {
             if !k.is_empty() {
-                if let Some(cur) = CUR_FN.with(|c| c.borrow().clone()) {
+                if let Some(cur) = withCheck(|s| { let c = &s.cur_fn; c.borrow().clone() }) {
-                    ERR_EDGES.with(|e| e.borrow_mut().insert((cur, k.clone())));
+                    withCheck(|s| { let e = &s.err_edges; e.borrow_mut().insert((cur, k.clone())) });
                 }
             }
         }
@@ -4933,7 +4860,7 @@ fn recordErrSite(expr: &ast::Expr, kind: ErrSiteKind, operand: &PlumType) {
         .and_then(|(_, s)| errSetNames(&s))
         .map(|n| n.into_iter().collect())
         .unwrap_or_default();
-    ERR_SITES.with(|m| {
+    withCheck(|s| { let m = &s.err_sites; {
         if let Some(m) = m.borrow_mut().as_mut() {
             m.insert(
                 expr as *const ast::Expr as usize,
@@ -4944,7 +4871,7 @@ fn recordErrSite(expr: &ast::Expr, kind: ErrSiteKind, operand: &PlumType) {
                 },
             );
         }
-    });
+    } });
 }
 /// The environment of the branch an `if`/`else if`/`while`/inline-`if`
@@ -4969,9 +4896,9 @@ fn bindCondEnv(cond: &ast::Expr, env: &TypeEnv, ctx: &CheckCtx) -> Result<TypeEn
         }
         pat => {
             let narrow = unions::narrowTarget(&b.value, pat, &ty, env, ctx);
-            ALLOW_BARE_TOP.with(|c| c.set(pat as *const ast::CasePattern as usize));
+            withCheck(|s| { let c = &s.allow_bare_top; c.set(pat as *const ast::CasePattern as usize) });
             let r = checkPattern(pat, &ty, &mut benv, ctx);
-            ALLOW_BARE_TOP.with(|c| c.set(0));
+            withCheck(|s| { let c = &s.allow_bare_top; c.set(0) });
             r?;
             unions::applyNarrow(narrow, &b.case, &mut benv, ctx);
         }
@@ -4996,7 +4923,7 @@ fn checkCatchBlock(
         .get(RETURN_KEY)
         .map(|s| (*s.body).clone())
         .unwrap_or_else(|| PlumType::TVar("_".to_string()));
-    let fn_pos = CUR_POS.with(|p| p.get());
+    let fn_pos = withCheck(|s| { let p = &s.cur_pos; p.get() });
     let n = body.stmts.len();
     for (i, stmt) in body.stmts.iter().enumerate() {
         if i + 1 == n {
@@ -5012,7 +4939,7 @@ fn checkCatchBlock(
                 | ast::Stmt::Continue
                 | ast::Stmt::Todo => {}
                 ast::Stmt::If(_) | ast::Stmt::Match(_) => {
-                    TAIL.with(|c| *c.borrow_mut() = Some(t.clone()));
+                    withCheck(|s| { let c = &s.tail; *c.borrow_mut() = Some(t.clone()) });
                 }
                 _ if matches!(t, PlumType::TUnit) => {}
                 _ => {
@@ -5241,7 +5168,7 @@ fn inferExprInner(
                 }
                 _ => (None, None),
             };
-            let (local_hint, strict_hint) = match CLOSURE_HINT.with(|h| h.borrow_mut().take()) {
+            let (local_hint, strict_hint) = match withCheck(|s| { let h = &s.closure_hint; h.borrow_mut().take() }) {
                 Some((v, strict)) => (Some(v), strict),
                 None => (None, false),
             };
@@ -5669,11 +5596,11 @@ fn inferExprInner(
 /// For `T.Name` the result is the concrete type's source name, for a bare `T`
 /// the type itself.
 fn typeParamBinding(n: &str) -> Option<PlumType> {
-    if !INST_MODE.with(|m| m.get()) {
+    if !withCheck(|s| { let m = &s.inst_mode; m.get() }) {
         return None;
     }
     let owner = n.split_once(ast::MEMBER_SEP).map(|(o, _)| o).unwrap_or(n);
-    TSUBST.with(|s| s.borrow().as_ref().and_then(|m| m.get(owner).cloned()))
+    withCheck(|s| { let s = &s.tsubst; s.borrow().as_ref().and_then(|m| m.get(owner).cloned()) })
 }
 /// `Type.f()` must name a static (a `fun` without `self`) and `x.f()` a

plum-checker/src/state.rs ADDED Viewed

@@ -0,0 +1,126 @@
+//! All per-check mutable state of the checker, in one value. It lives in a single
+//! thread-local, reached only through `withCheck`; `resetCheck` returns it to its
+//! initial value. `withCheck` borrows the state shared (all fields are cells), so
+//! nested `withCheck` calls are safe.
+use crate::types::PlumType;
+use crate::{Binds, CallSite, ErrSite};
+use plum_core::ast;
+use std::cell::{Cell, RefCell};
+use std::collections::{BTreeMap, BTreeSet, HashMap};
+#[derive(Default)]
+pub(crate) struct CheckState {
+    /// Param types for the closure literal about to be inferred as `name := |..| ..`,
+    /// taken from the first later call of `name` (see `closureHintFor`). `Some(vec![])`
+    /// means "assigned to a local, no call information"; the flag is whether an unresolved
+    /// param is an error (the local is never used as a plain value either).
+    pub(crate) closure_hint: RefCell<Option<(Vec<PlumType>, bool)>>,
+    /// Counter for the fresh `_t<N>` inference variables minted per generic call site.
+    pub(crate) fresh: Cell<u32>,
+    /// When set, `inferExprWith` records every expression's type here (see `typedSource`).
+    pub(crate) record_binds: RefCell<Option<Binds>>,
+    pub(crate) record: RefCell<Option<HashMap<usize, PlumType>>>,
+    /// Generic-call sites seen while checking one body (see `CallSite`); `None` outside `checkSourceInner`.
+    pub(crate) calls: RefCell<Option<Vec<CallSite>>>,
+    /// While checking a generic body for one instantiation: its generic parameter -> concrete type.
+    pub(crate) tsubst: RefCell<Option<BTreeMap<String, PlumType>>>,
+    /// True while checking an instantiated generic body (method lookups on declared types are strict).
+    pub(crate) inst_mode: Cell<bool>,
+    /// Position (line, column) of the innermost call expression being inferred, or of the
+    /// declaration being checked outside any call: the "called at" site of recorded calls.
+    pub(crate) cur_pos: Cell<(usize, usize)>,
+    /// Position of the innermost call whose inference failed, so a statement's
+    /// error points at that call rather than the enclosing fn/test header.
+    pub(crate) err_pos: Cell<Option<(usize, usize)>>,
+    /// Address of the expression `inferExprWith` is currently inferring (the innermost one).
+    pub(crate) cur_expr: Cell<usize>,
+    /// While checking the last statement of a value-producing tail: the type that tail
+    /// value must have, so its generic arguments are pinned like a returned expression's.
+    pub(crate) tail: RefCell<Option<PlumType>>,
+    pub(crate) match_tail: RefCell<Option<PlumType>>,
+    /// Key of the fn whose inferred error set the pre-pass is collecting (`None` otherwise).
+    pub(crate) cur_fn: RefCell<Option<String>>,
+    /// Error names contributed to `cur_fn`'s set by the body being checked.
+    pub(crate) err_acc: RefCell<BTreeSet<String>>,
+    /// Call edges `(caller key, callee key)` seen while collecting error sets.
+    pub(crate) err_edges: RefCell<BTreeSet<(String, String)>>,
+    /// Error-union sites (`try`, `!`, `catch`, `?:`) recorded for codegen; `None` while collecting.
+    pub(crate) err_sites: RefCell<Option<HashMap<usize, ErrSite>>>,
+    /// Operator expressions (address) on non-primitive operands -> the synthetic method call
+    /// (`a + b` -> `a.add(b)`) they resolve to. Kept so the cloned arguments have stable addresses.
+    pub(crate) op_calls: RefCell<HashMap<usize, std::rc::Rc<ast::FnCall>>>,
+    /// Trait name -> declared method names (required first, then defaults); filled by `traits::register`.
+    pub(crate) traits: RefCell<BTreeMap<String, Vec<String>>>,
+    /// Trait name -> declared fields `(name, is mut)`.
+    pub(crate) trait_fields: RefCell<BTreeMap<String, Vec<(String, bool)>>>,
+    /// Set while a member field is being unified, so union conversions do not nest.
+    pub(crate) in_wrap: Cell<bool>,
+    /// Nesting depth inside type arguments / fn types: conversion applies only at depth 0.
+    pub(crate) depth: Cell<usize>,
+    /// Inline-variant record name -> the enum it is a variant of.
+    pub(crate) inline: RefCell<BTreeMap<String, String>>,
+    /// Address of a top-level pattern that narrows (it records a narrowing, not a pattern).
+    pub(crate) narrow_top: Cell<usize>,
+    /// Address of the one case pattern whose bare payload-variant form is allowed.
+    pub(crate) allow_bare_top: Cell<usize>,
+}
+thread_local! {
+    static CHECK: RefCell<CheckState> = RefCell::new(CheckState::default());
+}
+/// Run `f` with the checker state. Every field is a `Cell`/`RefCell`, so the state is
+/// borrowed shared: a `withCheck` inside `f` (a nested call through inference) is fine;
+/// only a second `borrow_mut` of the same field panics, as with separate thread-locals.
+pub(crate) fn withCheck<R>(f: impl FnOnce(&CheckState) -> R) -> R {
+    CHECK.with(|c| f(&c.borrow()))
+}
+/// Return every field to its initial value. Must not run inside `withCheck`.
+pub(crate) fn resetCheck() {
+    CHECK.with(|c| *c.borrow_mut() = CheckState::default());
+}
+#[cfg(test)]
+mod tests {
+    use super::*;
+    #[test]
+    fn resetZeroesFresh() {
+        withCheck(|s| s.fresh.set(7));
+        resetCheck();
+        assert_eq!(withCheck(|s| s.fresh.get()), 0);
+    }
+    #[test]
+    fn nestedWithCheckDoesNotPanic() {
+        // a borrow held across a call that itself reaches the state (e.g. through
+        // inference) must not double-borrow the whole state
+        let n = withCheck(|outer| {
+            outer.depth.set(1);
+            withCheck(|inner| inner.depth.get() + 1)
+        });
+        assert_eq!(n, 2);
+        resetCheck();
+    }
+    #[test]
+    fn typedSourceIsRepeatable() {
+        let src = plum_test_support::parse(
+            "fun id(x: T) -> T = x\nfun main() -> Int =\n  a := id(1)\n  b := id(true)\n  a\n",
+        );
+        let first = crate::typedSource(&src).expect("checks");
+        let second = crate::typedSource(&src).expect("checks");
+        // generated names (closure copies, `_t<N>` vars) must not depend on earlier checks
+        let names = |i: &crate::TypedInfo| format!("{:?}", i.lowered.as_ref().map(|l| l.items.len()));
+        assert_eq!(names(&first), names(&second));
+        assert_eq!(first.instantiations, second.instantiations);
+        let sorted = |i: &crate::TypedInfo| {
+            let mut v: Vec<_> = i.inst_index.iter().map(|(k, v)| (format!("{:?}", k), *v)).collect();
+            v.sort();
+            v
+        };
+        assert_eq!(sorted(&first), sorted(&second));
+    }
+}

plum-checker/src/traits.rs CHANGED Viewed

@@ -1,15 +1,10 @@
 //! Trait rules in the checker. A trait is a union enum (`Enum.isTrait`) whose
 //! members are the embedding records; the declared methods come from `Source.traits`.
+use crate::state::withCheck;
 use crate::CheckCtx;
 use plum_core::ast;
-use std::cell::RefCell;
 use std::collections::BTreeMap;
-thread_local! {
-    static TRAITS: RefCell<BTreeMap<String, Vec<String>>> = const { RefCell::new(BTreeMap::new()) };
-    static TRAIT_FIELDS: RefCell<BTreeMap<String, Vec<(String, bool)>>> = const { RefCell::new(BTreeMap::new()) };
-}
 /// Records the traits of `source` (called while the global tables are built).
 pub fn register(source: &ast::Source) {
     let mut out: BTreeMap<String, Vec<String>> = BTreeMap::new();
@@ -29,31 +24,31 @@ pub fn register(source: &ast::Source) {
             .collect();
         out.insert(t.name.clone(), names);
     }
-    TRAITS.with(|c| *c.borrow_mut() = out);
+    withCheck(|s| { let c = &s.traits; *c.borrow_mut() = out });
     let fields = source
         .traits
         .iter()
         .map(|t| (t.name.clone(), t.fields.iter().map(|f| (f.name.clone(), f.isMut)).collect()))
         .collect();
-    TRAIT_FIELDS.with(|c| *c.borrow_mut() = fields);
+    withCheck(|s| { let c = &s.trait_fields; *c.borrow_mut() = fields });
 }
 /// `Some(false)` when `trait_` declares `field` without `mut`; `Some(true)` when `mut`.
 pub fn traitFieldIsMut(trait_: &str, field: &str) -> Option<bool> {
-    TRAIT_FIELDS.with(|c| {
+    withCheck(|s| { let c = &s.trait_fields; {
         c.borrow()
             .get(trait_)
             .and_then(|fs| fs.iter().find(|(n, _)| n == field).map(|(_, m)| *m))
-    })
+    } })
 }
 pub fn isTrait(name: &str, _ctx: &CheckCtx) -> bool {
-    TRAITS.with(|c| c.borrow().contains_key(name))
+    withCheck(|s| { let c = &s.traits; c.borrow().contains_key(name) })
 }
 /// The trait's declared methods: required first, then defaults, declaration order.
 pub fn traitMethods(name: &str, _ctx: &CheckCtx) -> Vec<String> {
-    TRAITS.with(|c| c.borrow().get(name).cloned().unwrap_or_default())
+    withCheck(|s| { let c = &s.traits; c.borrow().get(name).cloned().unwrap_or_default() })
 }
 /// The error for calling `method` on a value of trait type `ty`, if it is not declared.

plum-checker/src/unions.rs CHANGED Viewed

@@ -1,25 +1,12 @@
 //! Union enums in the checker: a member value converts to its enum, and
 //! branches of different members join to their common enum.
+use crate::state::withCheck;
 use crate::types::{self, PlumType};
 use crate::{unify, CheckCtx};
 use plum_core::ast;
 use plum_core::unions as plan;
-use std::cell::Cell;
 use std::collections::{BTreeMap, BTreeSet};
-thread_local! {
-    /// Set while a member field is being unified, so conversions do not nest.
-    static IN_WRAP: Cell<bool> = const { Cell::new(false) };
-    /// Nesting depth inside type arguments / fn types: conversion applies only at depth 0.
-    static DEPTH: Cell<usize> = const { Cell::new(0) };
-}
-thread_local! {
-    /// Inline-variant record name -> the enum it is a variant of.
-    static INLINE: std::cell::RefCell<BTreeMap<String, String>> =
-        const { std::cell::RefCell::new(BTreeMap::new()) };
-}
 /// Remembers the inline-variant records of `source` (called while the global tables are built).
 pub fn registerInline(source: &ast::Source) {
     let mut out = BTreeMap::new();
@@ -30,19 +17,19 @@ pub fn registerInline(source: &ast::Source) {
             }
         }
     }
-    INLINE.with(|c| *c.borrow_mut() = out);
+    withCheck(|s| { let c = &s.inline; *c.borrow_mut() = out });
 }
 /// The enum that declares `record` inline, if it is an inline-variant record.
 pub fn inlineOwner(record: &str) -> Option<String> {
-    INLINE.with(|c| c.borrow().get(record).cloned())
+    withCheck(|s| { let c = &s.inline; c.borrow().get(record).cloned() })
 }
 /// Runs `f` (a unify of a nested type position), where no member conversion applies.
 pub fn nested<R>(f: impl FnOnce() -> R) -> R {
-    DEPTH.with(|d| d.set(d.get() + 1));
+    withCheck(|s| { let d = &s.depth; d.set(d.get() + 1) });
     let r = f();
-    DEPTH.with(|d| d.set(d.get() - 1));
+    withCheck(|s| { let d = &s.depth; d.set(d.get() - 1) });
     r
 }
@@ -50,9 +37,9 @@ pub fn nested<R>(f: impl FnOnce() -> R) -> R {
 /// member converts to a union enum there, though the error union itself is a
 /// nested position for everything else.
 pub fn atTop<R>(f: impl FnOnce() -> R) -> R {
-    let saved = DEPTH.with(|d| d.replace(0));
+    let saved = withCheck(|s| { let d = &s.depth; d.replace(0) });
     let r = f();
-    DEPTH.with(|d| d.set(saved));
+    withCheck(|s| { let d = &s.depth; d.set(saved) });
     r
 }
@@ -101,7 +88,7 @@ pub fn isUnion(enumName: &str, ctx: &CheckCtx) -> bool {
 /// The hidden variant that converts `actual` into the union enum `expected`.
 pub fn wrapVariantFor(expected: &PlumType, actual: &PlumType, ctx: &CheckCtx) -> Option<String> {
-    if IN_WRAP.with(|c| c.get()) || DEPTH.with(|d| d.get()) > 0 {
+    if withCheck(|s| { let c = &s.in_wrap; c.get() }) || withCheck(|s| { let d = &s.depth; d.get() }) > 0 {
         return None;
     }
     if matches!(
@@ -118,9 +105,9 @@ pub fn wrapVariantFor(expected: &PlumType, actual: &PlumType, ctx: &CheckCtx) ->
     if ms.is_empty() {
         return None;
     }
-    IN_WRAP.with(|c| c.set(true));
+    withCheck(|s| { let c = &s.in_wrap; c.set(true) });
     let found = ms.into_iter().find(|(_, t)| unify(t, actual, ctx).is_ok());
-    IN_WRAP.with(|c| c.set(false));
+    withCheck(|s| { let c = &s.in_wrap; c.set(false) });
     found.map(|(v, _)| v)
 }
@@ -258,11 +245,6 @@ pub fn joinBranches(
 use crate::types::{TypeEnv, TypeScheme};
 use crate::{checkPattern, EnumVariantInfo};
-thread_local! {
-    /// Address of a top-level pattern that narrows (it records a narrowing, not a pattern).
-    static NARROW_TOP: Cell<usize> = const { Cell::new(0) };
-}
 const COPY_KEY: &str = "$union-copy:";
 /// The member base name of a hidden variant (`Shape__Circle` -> `Circle`).
@@ -296,7 +278,7 @@ pub fn checkMemberPattern(
     match pat {
         ast::CasePattern::Name(n) if n.chars().next().is_some_and(|c| c.is_uppercase()) => {
             let (v, _) = memberNamed(subject, n, ctx)?;
-            if NARROW_TOP.with(|c| c.get()) != addr {
+            if withCheck(|s| { let c = &s.narrow_top; c.get() }) != addr {
                 plan::recordPattern(addr, v);
             }
             Some(Ok(()))
@@ -361,7 +343,7 @@ pub fn narrowTarget(
     };
     let (variant, ty) = memberNamed(subject_ty, n, ctx)?;
     let addr = pat as *const ast::CasePattern as usize;
-    NARROW_TOP.with(|c| c.set(addr));
+    withCheck(|s| { let c = &s.narrow_top; c.set(addr) });
     Some(Narrow {
         subject: name,
         variant,
@@ -374,11 +356,11 @@ pub fn narrowTarget(
 /// After a pattern check: records the narrowing and retypes the subject.
 pub fn applyNarrow(n: Option<Narrow>, case: &ast::Case, env: &mut TypeEnv, ctx: &CheckCtx) {
     let Some(n) = n else { return };
-    NARROW_TOP.with(|c| {
+    withCheck(|s| { let c = &s.narrow_top; {
         if c.get() == n.pat {
             c.set(0)
         }
-    });
+    } });
     plan::recordNarrow(
         case as *const ast::Case as usize,
         n.subject.clone(),

plum-cli/src/game.rs CHANGED Viewed

@@ -227,9 +227,10 @@ pub fn cmdGame(
     port: Option<u16>,
     noOpen: bool,
     lib_path: Option<PathBuf>,
+    fusion: plum_checker::FusionOptions,
 ) -> Result<()> {
     let lib_path = lib_path.unwrap_or_else(repoRoot);
-    let wasm = crate::compileToWasm(&file, &lib_path)?;
+    let wasm = crate::compileToWasm(&file, &lib_path, fusion)?;
     let assets = assetRoot(&file, assets);
     if assets.exists() && !assets.is_dir() {
         bail!("{} is not a directory", assets.display());

plum-cli/src/main.rs CHANGED Viewed

@@ -137,12 +137,9 @@ fn main() {
     }
 }
-/// The `--no-fusion` / `--explain-fusion` flags of the running command, set once in `run`
+/// The `--no-fusion` / `--explain-fusion` flags of a command, as explicit fusion options.
-/// 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) {
+fn fusionFlags(explain: bool, no_fusion: bool) -> plum_checker::FusionOptions {
-    let _ = FUSION.set(plum_checker::FusionOptions { enabled: !no_fusion, explain });
+    plum_checker::FusionOptions { enabled: !no_fusion, explain }
 }
 /// `compile` reports positioned type errors without a file name; name `file` in them
@@ -151,10 +148,6 @@ 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<()> {
     let cli = Cli::parse();
     match cli.command {
@@ -165,8 +158,7 @@ fn run() -> Result<()> {
             lib_path,
         } => cmdCompile(file, output, lib_path),
         Command::Run { file, lib_path, explain_fusion, no_fusion } => {
-            setFusion(explain_fusion, no_fusion);
+            cmdRun(file, lib_path, fusionFlags(explain_fusion, no_fusion))
-            cmdRun(file, lib_path)
         }
         Command::Build {
             file,
@@ -175,12 +167,10 @@ fn run() -> Result<()> {
             explain_fusion,
             no_fusion,
         } => {
-            setFusion(explain_fusion, no_fusion);
+            cmdBuild(file, output, lib_path, fusionFlags(explain_fusion, no_fusion))
-            cmdBuild(file, output, lib_path)
         }
         Command::Test { paths, lib_path, explain_fusion, no_fusion } => {
-            setFusion(explain_fusion, no_fusion);
+            cmdTest(paths, lib_path, fusionFlags(explain_fusion, no_fusion))
-            cmdTest(paths, lib_path)
         }
         Command::Game {
             file,
@@ -192,8 +182,7 @@ fn run() -> Result<()> {
             explain_fusion,
             no_fusion,
         } => {
-            setFusion(explain_fusion, no_fusion);
-            game::cmdGame(file, output, assets, port, no_open, lib_path)
+            game::cmdGame(file, output, assets, port, no_open, lib_path, fusionFlags(explain_fusion, no_fusion))
         }
         Command::Editor { editor, insiders } => editor::install(editor, insiders),
     }
@@ -233,10 +222,14 @@ fn cmdFormat(file: Option<std::path::PathBuf>, check: bool, use_stdin: bool) ->
     Ok(())
 }
+fn compileToWasm(
+    file: &std::path::Path,
+    lib_path: &std::path::Path,
+    fusion: plum_checker::FusionOptions,
-fn compileToWasm(file: &std::path::Path, lib_path: &std::path::Path) -> Result<Vec<u8>> {
+) -> Result<Vec<u8>> {
     let ast = plum_core::loadAndMerge(file, lib_path).map_err(|e| anyhow::anyhow!("{e}"))?;
-    plum_wasm_codegen::compile(&ast, &compileOptions(false)).map(|o| o.wasm).map_err(|e| {
+    plum_wasm_codegen::compile(&ast, &plum_wasm_codegen::CompileOptions { tests: false, fusion }).map(|o| o.wasm).map_err(|e| {
         if e.starts_with("type error") {
             eprintln!("{}", nameFileInErrors(&e, file));
             process::exit(1);
@@ -248,6 +241,7 @@ fn compileToWasm(file: &std::path::Path, lib_path: &std::path::Path) -> Result<V
 fn compileToTestWasm(
     file: &std::path::Path,
     lib_path: &std::path::Path,
+    fusion: plum_checker::FusionOptions,
 ) -> Result<(Vec<u8>, Vec<String>)> {
     let ast = plum_core::loadAndMerge(file, lib_path).map_err(|e| anyhow::anyhow!("{e}"))?;
@@ -258,7 +252,7 @@ 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 out = plum_wasm_codegen::compile(&ast, &compileOptions(true)).map_err(|e| {
+    let out = plum_wasm_codegen::compile(&ast, &plum_wasm_codegen::CompileOptions { tests: true, fusion }).map_err(|e| {
         if e.starts_with("type error") {
             anyhow::anyhow!(nameFileInErrors(&e, file))
         } else {
@@ -278,7 +272,7 @@ fn cmdCompile(
     output: Option<std::path::PathBuf>,
     lib_path: std::path::PathBuf,
 ) -> Result<()> {
-    let wasm_bytes = compileToWasm(&file, &lib_path)?;
+    let wasm_bytes = compileToWasm(&file, &lib_path, plum_checker::FusionOptions::default())?;
     let out_path = output.unwrap_or_else(|| file.with_extension("wasm"));
     fs::write(&out_path, &wasm_bytes)
@@ -288,8 +282,12 @@ fn cmdCompile(
     Ok(())
 }
+fn cmdRun(
+    file: std::path::PathBuf,
-fn cmdRun(file: std::path::PathBuf, lib_path: std::path::PathBuf) -> Result<()> {
+    lib_path: std::path::PathBuf,
+    fusion: plum_checker::FusionOptions,
+) -> Result<()> {
-    let wasm_bytes = compileToWasm(&file, &lib_path)?;
+    let wasm_bytes = compileToWasm(&file, &lib_path, fusion)?;
     // GC + typed function references are required to load modules containing
     // Plum's structs/enums/strings/closures (see docs/superpowers/plans/2026-07-25-wasm-gc-migration.md).
@@ -355,7 +353,11 @@ fn collectPlumFiles(path: &std::path::Path) -> Result<Vec<std::path::PathBuf>> {
     Ok(files)
 }
+fn cmdTest(
-fn cmdTest(paths: Vec<std::path::PathBuf>, lib_path: std::path::PathBuf) -> Result<()> {
+    paths: Vec<std::path::PathBuf>,
+    lib_path: std::path::PathBuf,
+    fusion: plum_checker::FusionOptions,
+) -> Result<()> {
     // A single plain file keeps the exact original single-file UX (no
     // `=== path ===` header, no aggregate summary line, no "N/1 files
     // passed" — just that one file's own test tree). Anything else (a
@@ -363,7 +365,7 @@ fn cmdTest(paths: Vec<std::path::PathBuf>, lib_path: std::path::PathBuf) -> Resu
     // matching `scripts/test-plum.sh`'s old find-and-loop shell logic.
     if let [only] = paths.as_slice() {
         if only.is_file() {
-            let (_, failed) = runTestFile(only, &lib_path)?;
+            let (_, failed) = runTestFile(only, &lib_path, fusion)?;
             if failed > 0 {
                 process::exit(1);
             }
@@ -380,7 +382,7 @@ fn cmdTest(paths: Vec<std::path::PathBuf>, lib_path: std::path::PathBuf) -> Resu
     let mut files_failed = 0usize;
     for file in &files {
         println!("=== {} ===", file.display());
-        match runTestFile(file, &lib_path) {
+        match runTestFile(file, &lib_path, fusion) {
             Ok((passed, failed)) => {
                 total_passed += passed;
                 total_failed += failed;
@@ -433,8 +435,12 @@ fn cmdTest(paths: Vec<std::path::PathBuf>, lib_path: std::path::PathBuf) -> Resu
 /// Runs every `test` block in one file, printing the Spock-flavored per-test
 /// tree as it goes, and returns `(passed, failed)` counts — shared by both
 /// the single-file and directory-recursive paths of `cmdTest`.
+fn runTestFile(
+    file: &std::path::Path,
+    lib_path: &std::path::Path,
+    fusion: plum_checker::FusionOptions,
-fn runTestFile(file: &std::path::Path, lib_path: &std::path::Path) -> Result<(usize, usize)> {
+) -> Result<(usize, usize)> {
-    let (wasm_bytes, names) = compileToTestWasm(file, lib_path)?;
+    let (wasm_bytes, names) = compileToTestWasm(file, lib_path, fusion)?;
     if let Ok(path) = std::env::var("PLUM_DUMP_WASM") {
         let _ = std::fs::write(path, &wasm_bytes);
     }
@@ -556,8 +562,9 @@ fn cmdBuild(
     file: std::path::PathBuf,
     output: Option<std::path::PathBuf>,
     lib_path: std::path::PathBuf,
+    fusion: plum_checker::FusionOptions,
 ) -> Result<()> {
-    let wasm_bytes = compileToWasm(&file, &lib_path)?;
+    let wasm_bytes = compileToWasm(&file, &lib_path, fusion)?;
     let stem = file
         .file_stem()

plum-core/src/forms.rs CHANGED Viewed

@@ -54,7 +54,6 @@
 use std::cell::{Cell, RefCell};
 use std::collections::{HashMap, HashSet};
 use std::rc::Rc;
-use std::sync::atomic::{AtomicUsize, Ordering};
 use crate::ast::*;
 use crate::generics::isGenericName;
@@ -111,10 +110,12 @@ impl Registry {
     }
 }
+thread_local! {
-static NEXT_LOOP_ID: AtomicUsize = AtomicUsize::new(1);
+    static NEXT_LOOP_ID: Cell<usize> = const { Cell::new(1) };
+}
 fn nextLoopId() -> usize {
-    NEXT_LOOP_ID.fetch_add(1, Ordering::Relaxed)
+    NEXT_LOOP_ID.with(|n| { let v = n.get(); n.set(v + 1); v })
 }
 thread_local! {
@@ -517,6 +518,17 @@ impl Prep<'_> {
 // ---- typed lowering -----------------------------------------------------------
+/// Resets the loop-id counter and every session table (see `session::begin`).
+pub fn resetCounters() {
+    NEXT_LOOP_ID.with(|n| n.set(1));
+    SEQ_KINDS.with(|k| k.borrow_mut().clear());
+    REG.with(|r| *r.borrow_mut() = None);
+    COUNTER.with(|c| c.set(0));
+    LOWERED.with(|l| l.borrow_mut().clear());
+    ERRORS.with(|l| l.borrow_mut().clear());
+    USES.with(|l| l.borrow_mut().clear());
+}
 /// Starts a lowering session for `source` (see [`lowerLoop`], [`finish`]).
 pub fn begin(source: &Source) {
     let reg = Registry::of(&source.stars);

plum-core/src/lib.rs CHANGED Viewed

@@ -18,6 +18,7 @@ pub mod parser;
 pub mod purity;
 pub mod rename;
 pub mod reuse;
+pub mod session;
 pub mod simplify;
 pub mod tail;
 pub mod tests_lower;

plum-core/src/loader.rs CHANGED Viewed

@@ -517,6 +517,12 @@ thread_local! {
         std::cell::RefCell::new(Vec::new());
 }
+/// Clears the per-compile loader state (see `session::begin`).
+pub fn resetSession() {
+    MERGED_LIT_ERRORS.with(|e| e.borrow_mut().clear());
+    USER_PRIMS.with(|u| u.borrow_mut().clear());
+}
 fn mergeItems(
     file: &Path,
     source: &Source,

plum-core/src/lower.rs CHANGED Viewed

@@ -19,6 +19,7 @@ pub fn perFile(source: &mut Source) -> Result<(), String> {
 /// type checks, union members, then forms. The first failing stage returns its
 /// errors joined with "\n".
 pub fn frontEnd(source: &mut Source) -> Result<(), String> {
+    crate::session::begin();
     let traitErrors = crate::traits::lowerTraits(source);
     if !traitErrors.is_empty() {
         return Err(traitErrors.join("\n"));

plum-core/src/session.rs ADDED Viewed

@@ -0,0 +1,15 @@
+//! Per-compile counters: everything process-global the front end numbers or
+//! accumulates, reset in one place at the start of a compile.
+/// Resets the forms, simplify, unions and loader counters/registries so two
+/// compiles in one process produce identical generated names. Called only at
+/// the start of `lower::frontEnd`; a forms session already running (the checker
+/// is mid-check) is left alone.
+pub fn begin() {
+    if !crate::forms::active() {
+        crate::forms::resetCounters();
+    }
+    crate::simplify::resetFresh();
+    crate::unions::beginPlan();
+    crate::loader::resetSession();
+}

plum-core/src/simplify.rs CHANGED Viewed

@@ -8,14 +8,19 @@ use crate::ast::*;
 use crate::rename::{renameStmts, Name};
 use crate::visit::{argRef, isTag, walkBlockRef, walkRef, childExprs, childRefs, stmtBlocks, stmtExprs, visitBlock};
 use std::collections::{HashMap, HashSet};
-use std::sync::atomic::{AtomicUsize, Ordering};
+thread_local! {
-static FRESH: AtomicUsize = AtomicUsize::new(0);
+    static FRESH: std::cell::Cell<usize> = const { std::cell::Cell::new(0) };
+}
 const MAX_SIZE: usize = 30;
 const MAX_DEPTH: usize = 8;
+/// Restarts the fresh-name counter (see `session::begin`).
+pub fn resetFresh() {
+    FRESH.with(|f| f.set(0));
+}
 fn fresh() -> usize {
-    FRESH.fetch_add(1, Ordering::Relaxed)
+    FRESH.with(|f| { let v = f.get(); f.set(v + 1); v })
 }
 pub fn simplifyExpr(e: Expr, src: &Source, pure: &HashSet<String>) -> Expr {

plum-core/tests/session_test.rs ADDED Viewed

@@ -0,0 +1,50 @@
+#![allow(non_snake_case)]
+use plum_core::lower::frontEnd;
+const SRC: &str = "\
+enum Shape =
+  | Circle(r: Int)
+  | Square(s: Int)
+fun main() =
+  for x := range 3
+    x
+";
+fn lowered() -> String {
+    let mut s = plum_test_support::parseRawSource(SRC);
+    frontEnd(&mut s).unwrap();
+    format!("{:?}", s.items)
+}
+#[test]
+fn frontEndTwiceInOneProcessIsIdentical() {
+    let a = lowered();
+    let b = lowered();
+    assert_eq!(a, b);
+}
+#[test]
+fn beginResetsFreshNames() {
+    plum_core::session::begin();
+    plum_core::unions::recordNarrow(1, "x".into(), "V".into());
+    let a = plum_core::unions::takePlan().narrowings[&1].2.clone();
+    plum_core::session::begin();
+    plum_core::unions::recordNarrow(1, "x".into(), "V".into());
+    let b = plum_core::unions::takePlan().narrowings[&1].2.clone();
+    assert_eq!(a, b);
+}
+#[test]
+fn otherThreadsBeginDoesNotDisturbThisCompile() {
+    let expected = lowered();
+    let h = std::thread::spawn(|| {
+        for _ in 0..200 {
+            plum_core::session::begin();
+        }
+    });
+    for _ in 0..50 {
+        assert_eq!(lowered(), expected);
+    }
+    h.join().unwrap();
+}

plum-core/tests/trmc_test.rs CHANGED Viewed

@@ -2,24 +2,25 @@
 //! Tail recursion modulo cons (`plum_core::trmc`): which fns are rewritten, and
 //! that the rewrite computes what the recursion would (compiled and run through
 //! the real pipeline, which is where `trmc::rewrite` is wired in).
-use plum_checker::{withFusionOptions, FusionOptions};
+use plum_checker::FusionOptions;
+use plum_wasm_codegen::CompileOptions;
-/// The fusion option is thread-local: each test compiles on its own thread.
-fn withFusion<R>(fusion: bool, f: impl FnOnce() -> R) -> R {
+fn compileWith(source: &plum_core::ast::Source, fusion: bool) -> Result<Vec<u8>, String> {
-    withFusionOptions(FusionOptions { enabled: fusion, explain: false }, f)
+    let opts = CompileOptions { fusion: FusionOptions { enabled: fusion, explain: false }, ..Default::default() };
+    plum_wasm_codegen::compile(source, &opts).map(|o| o.wasm)
 }
 fn compileSource(source: &plum_core::ast::Source) -> Result<Vec<u8>, String> {
-    withFusion(true, || plum_wasm_codegen::compileSource(source))
+    compileWith(source, true)
 }
 /// Compiles without the fusion stage, for tests that inspect an unfused fn by name.
 fn compileUnfused(source: &plum_core::ast::Source) -> Result<Vec<u8>, String> {
-    withFusion(false, || plum_wasm_codegen::compileSource(source))
+    compileWith(source, false)
 }
 fn typedSource(source: &plum_core::ast::Source) -> plum_checker::types::CheckResult<plum_checker::TypedInfo> {
-    withFusion(true, || plum_checker::typedSource(source))
+    plum_checker::typedSourceWith(source, FusionOptions::default())
 }
 fn gcEngine() -> wasmtime::Engine {

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

@@ -551,25 +551,49 @@ fn fnKey(f: &ast::Fn) -> String {
     }
 }
-thread_local! {
-    /// The current `compileSource` call's wasm-gc type registry. `compileSource` is
+/// Everything one `compile` call accumulates and later reads from anywhere in codegen
+/// (the wasm-gc type registry, top-level consts, value-enum facts, checker error
-    /// the sole entry point and is never re-entrant/concurrent within one thread, so
+/// info). One thread-local, reset at the start of `compile`; not reentrant, so
+/// `withGen` closures must not call back into `withGen`.
+#[derive(Default)]
+struct GenState {
-    /// a thread-local avoids threading an explicit `&GcTypeRegistry` parameter through
+    /// The wasm-gc type registry; set once `buildGcTypeRegistry` has run.
-    /// every one of `plumTypeToValtype`/`astTypeToWasm`'s ~25 call sites (many several
-    /// functions removed from anywhere a `CompileCtx`/`LocalCtx` is in scope, e.g.
+    gc_types: Option<std::rc::Rc<GcTypeRegistry>>,
-    /// function-signature registration that runs before any `LocalCtx` exists). Set
+    /// Top-level `NAME = literal` const values. A bare `NAME` always lexes as a
+    /// type_identifier, so `Expr::TypeName` consults this before enum-variant handling.
+    consts: HashMap<String, ast::Expr>,
+    /// `value enum` name -> its fields `(name, type)` in declaration order. A value enum
+    /// is flattened into one wasm local / param / result per leaf field and only boxed
+    /// (into its variant's GC struct) when stored in a heap object.
+    value_enums: HashMap<String, Vec<(String, PlumType)>>,
+    /// Box struct type index of a value enum -> the multi-value block type `[] -> leaves`
+    /// used when an `if`/`match`/inline if produces that value enum.
+    value_block_types: HashMap<u32, u32>,
+    /// Helper function indices: `unbox:Vec2`, `eq:Vec2`, `proj:Vec2.x`.
+    value_helpers: HashMap<String, u32>,
-    /// once near the top of `compileSource`, before anything below reads it.
+    /// Error-union facts from the checker for the program being compiled.
+    err_info: ErrInfo,
+}
+impl GenState {
+}
+/// The registry, shared out so callers can read it while calling other `withGen` users
-    static CURRENT_GC_TYPES: RefCell<Option<GcTypeRegistry>> = const { RefCell::new(None) };
+/// (e.g. `flatValtypes` -> `valueFieldsOf`) without a nested borrow.
+fn gcTypes() -> std::rc::Rc<GcTypeRegistry> {
+    withGen(|s| {
+        s.gc_types.clone().expect(
+            "internal codegen error: GC type registry read before compileSource initialized it",
+        )
+    })
 }
 thread_local! {
-    /// Top-level `NAME = literal` const values, keyed by name — set once near the
-    /// top of `compileSource`, alongside `CURRENT_GC_TYPES` (same non-reentrancy
-    /// rationale). A bare `NAME` reference always lexes as a type_identifier (any
-    /// uppercase-leading name does, there's no separate "constant" token — see
-    /// `plum-checker`'s `inferExpr`'s matching `TypeName` comment), so `Expr::TypeName`
-    /// consults this map before falling back to enum-variant/unmodeled-type handling.
-    static CURRENT_CONSTS: RefCell<HashMap<String, ast::Expr>> = RefCell::new(HashMap::new());
+    static GEN: RefCell<GenState> = RefCell::new(GenState::default());
+}
+fn withGen<R>(f: impl FnOnce(&mut GenState) -> R) -> R {
+    GEN.with(|g| f(&mut g.borrow_mut()))
 }
 /// A variant's payload field types as instantiated by `subject_ty`'s type
@@ -700,23 +724,13 @@ fn declaredType(value: &ast::Expr, types: &HashMap<usize, PlumType>) -> Option<P
         .cloned()
 }
-fn withGcTypes<R>(f: impl FnOnce(&GcTypeRegistry) -> R) -> R {
-    CURRENT_GC_TYPES.with(|c| {
-        let borrow = c.borrow();
-        let registry = borrow.as_ref().expect(
-            "internal codegen error: GC type registry read before compileSource initialized it",
-        );
-        f(registry)
-    })
-}
 /// Wasm type of a pattern/`?`/re-layout scratch local: a nullable `T?` is held as
 /// its payload reference, anything else as the GC struct `scratchTypeIdx` names.
 fn scratchValtype(ty: &PlumType, vname: &str) -> ValType {
     if vname.is_empty() && nullableErr(ty).is_some() {
         return plumTypeToValtype(ty);
     }
-    gcRef(withGcTypes(|r| scratchTypeIdx(r, ty, vname)))
+    gcRef({ let r = gcTypes(); scratchTypeIdx(&r, ty, vname) })
 }
 /// GC type index of a pattern/`?` scratch local: variant `vname` of enum type `ty`,
@@ -761,21 +775,6 @@ fn pushSelfPlaceholder(vt: ValType, body: &mut Vec<u8>) {
     }
 }
-thread_local! {
-    /// `value enum` name -> its fields `(name, type)` in declaration order. Set once near
-    /// the top of `compileSourceInner`. A value enum is flattened into one wasm local /
-    /// param / result per leaf field and only boxed (into its variant's GC struct, whose
-    /// fields are the same flat leaves) when stored in a heap object.
-    static VALUE_ENUMS: RefCell<HashMap<String, Vec<(String, PlumType)>>> = RefCell::new(HashMap::new());
-    /// Box struct type index of a value enum -> the multi-value block type `[] -> leaves`
-    /// used when an `if`/`match`/inline if produces that value enum.
-    static VALUE_BLOCK_TYPES: RefCell<HashMap<u32, u32>> = RefCell::new(HashMap::new());
-    /// Helper function indices: `unbox:Vec2`, `eq:Vec2`, `proj:Vec2.x`.
-    static VALUE_HELPERS: RefCell<HashMap<String, u32>> = RefCell::new(HashMap::new());
-    /// Error-union facts from the checker for the program being compiled.
-    static ERR_INFO: RefCell<ErrInfo> = RefCell::new(ErrInfo::default());
-}
 #[derive(Default)]
 struct ErrInfo {
     /// File of the fn being compiled (`expr!` crash messages name it).
@@ -787,13 +786,13 @@ struct ErrInfo {
 /// Records `file` as the source file of the fn about to be compiled (when known).
 fn setCurrentFile(file: &str) {
     if !file.is_empty() {
-        ERR_INFO.with(|e| e.borrow_mut().file = file.to_string());
+        withGen(|s| s.err_info.file = file.to_string());
     }
 }
 fn errSite(expr: &ast::Expr) -> Option<plum_checker::ErrSite> {
-    ERR_INFO.with(|e| {
+    withGen(|s| {
-        e.borrow()
+        s.err_info
             .sites
             .get(&(expr as *const ast::Expr as usize))
             .cloned()
@@ -801,8 +800,7 @@ fn errSite(expr: &ast::Expr) -> Option<plum_checker::ErrSite> {
 }
 fn errCode(name: &str) -> Result<i32, String> {
-    ERR_INFO
-        .with(|e| e.borrow().codes.get(name).copied())
+    withGen(|s| s.err_info.codes.get(name).copied())
         .ok_or_else(|| format!("internal codegen error: no error code for '{}'", name))
 }
@@ -817,14 +815,14 @@ fn emitZeroLeaf(vt: ValType, body: &mut Vec<u8>) {
 }
 fn emitZeros(ty: &PlumType, body: &mut Vec<u8>) {
-    for vt in withGcTypes(|g| flatValtypes(ty, g)) {
+    for vt in flatValtypes(ty, &gcTypes()) {
         emitZeroLeaf(vt, body);
     }
 }
 fn valueFieldsOf(ty: &PlumType) -> Option<Vec<(String, PlumType)>> {
     match ty {
-        PlumType::TNamed(n) => VALUE_ENUMS.with(|v| v.borrow().get(n).cloned()),
+        PlumType::TNamed(n) => withGen(|s| s.value_enums.get(n).cloned()),
         // `!T` is `(T leaves..., code: i32)`; a Unit success has only the code.
         PlumType::TErr(t, _) if nullableErr(ty).is_none() => {
             let mut f = Vec::new();
@@ -909,14 +907,14 @@ fn emitDrops(ty: &PlumType, body: &mut Vec<u8>) {
 /// Flat leaves on the stack -> the value's heap box (its variant struct).
 fn emitBox(ty: &PlumType, body: &mut Vec<u8>) {
-    let idx = withGcTypes(|r| r.classIdx(ty))
+    let idx = { let r = gcTypes(); r.classIdx(ty) }
         .expect("internal codegen error: value enum box type missing");
     Instruction::StructNew(idx).encode(body);
 }
 fn valueHelper(key: &str) -> u32 {
-    VALUE_HELPERS.with(|h| {
+    withGen(|s| {
-        *h.borrow()
+        *s.value_helpers
             .get(key)
             .unwrap_or_else(|| panic!("internal codegen error: missing helper {key}"))
     })
@@ -973,7 +971,7 @@ fn strType() -> PlumType {
 }
 fn plumTypeToValtype(t: &PlumType) -> ValType {
-    withGcTypes(|r| plumTypeToGcValtype(t, r))
+    plumTypeToGcValtype(t, &gcTypes())
 }
 /// Type-section indices for every wasm-gc composite type this program's
@@ -1638,13 +1636,13 @@ fn buildGcTypeRegistry(
 fn blockTypeFor(result_vt: Option<ValType>) -> BlockType {
     // A value enum's block result is its flat leaves; its box reference type stands in
-    // for it as the `result_vt` marker (see `VALUE_BLOCK_TYPES`).
+    // for it as the `result_vt` marker (see `GenState::value_block_types`).
     if let Some(ValType::Ref(RefType {
         heap_type: HeapType::Concrete(i),
         ..
     })) = result_vt
     {
-        if let Some(t) = VALUE_BLOCK_TYPES.with(|m| m.borrow().get(&i).copied()) {
+        if let Some(t) = withGen(|s| s.value_block_types.get(&i).copied()) {
             return BlockType::FunctionType(t);
         }
     }
@@ -1728,7 +1726,7 @@ 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())
+    typeCheckWith(source, file, plum_checker::FusionOptions::default())
 }
 fn typeCheckWith(
@@ -1799,12 +1797,8 @@ pub fn compile(source: &ast::Source, opts: &CompileOptions) -> Result<Output, St
     }
 }
-fn threadLocalOptions(tests: bool) -> CompileOptions {
-    CompileOptions { tests, fusion: plum_checker::fusionOptions() }
-}
 pub fn compileSource(source: &ast::Source) -> Result<Vec<u8>, String> {
-    compile(source, &threadLocalOptions(false)).map(|o| o.wasm)
+    compile(source, &CompileOptions::default()).map(|o| o.wasm)
 }
 pub use plum_core::tests_lower::{TestProgram, ASSERT_REPORT_MARK};
@@ -1830,6 +1824,14 @@ mod compileEntryTests {
         assert_eq!(out.wasm, compileSource(&src).expect("compiles"));
     }
+    #[test]
+    fn compilingTwiceInOneProcessGivesIdenticalBytes() {
+        let src = load();
+        let first = compile(&src, &CompileOptions::default()).expect("compiles").wasm;
+        let second = compile(&src, &CompileOptions::default()).expect("compiles").wasm;
+        assert_eq!(first, second);
+    }
     #[test]
     fn testsOptionNamesTests() {
         let src = load();
@@ -2162,11 +2164,15 @@ fn compileSourceInner(
         error_codes,
         ..
     } = typed;
+    // A fresh state for this compile: nothing carries over from a previous one.
-    ERR_INFO.with(|e| {
+    withGen(|s| {
+        *s = GenState {
-        *e.borrow_mut() = ErrInfo {
+            err_info: ErrInfo {
-            file: source.file.clone(),
+                file: source.file.clone(),
-            sites: err_sites,
+                sites: err_sites,
-            codes: error_codes,
+                codes: error_codes,
+            },
+            ..GenState::default()
         }
     });
     // The types are keyed by the addresses of the checker's lowered program.
@@ -2281,9 +2287,8 @@ fn compileSourceInner(
     }
     // ---- collect the concrete generic types the program uses ----
-    VALUE_ENUMS.with(|v| {
+    withGen(|s| {
-        let mut v = v.borrow_mut();
+        let v = &mut s.value_enums;
-        v.clear();
         for item in &source.items {
             if let ast::Item::Enum(e) = item {
                 if e.isValue && e.variants.len() == 1 && e.generics.is_empty() {
@@ -2357,9 +2362,7 @@ fn compileSourceInner(
     let mut module = WasmModule::new();
-    VALUE_BLOCK_TYPES.with(|m| m.borrow_mut().clear());
-    VALUE_HELPERS.with(|m| m.borrow_mut().clear());
     let mut gc_types = buildGcTypeRegistry(
         &mut module,
         source,
@@ -2368,9 +2371,9 @@ fn compileSourceInner(
         &tc.apps,
         &tc.errs,
     );
-    CURRENT_GC_TYPES.with(|c| *c.borrow_mut() = Some(gc_types.clone()));
+    withGen(|s| s.gc_types = Some(std::rc::Rc::new(gc_types.clone())));
     let value_names: Vec<String> = {
-        let mut v: Vec<String> = VALUE_ENUMS.with(|v| v.borrow().keys().cloned().collect());
+        let mut v: Vec<String> = withGen(|s| s.value_enums.keys().cloned().collect());
         v.sort();
         v
     };
@@ -2381,7 +2384,7 @@ fn compileSourceInner(
             .expect("value enum box type registered");
         let leaves = flatValtypes(&ty, &gc_types);
         let bt = module.addType(&[], &leaves);
-        VALUE_BLOCK_TYPES.with(|m| m.borrow_mut().insert(box_idx, bt));
+        withGen(|s| s.value_block_types.insert(box_idx, bt));
     }
     let mut err_boxes: Vec<(PlumType, u32)> = gc_types
         .err_box
@@ -2396,11 +2399,11 @@ fn compileSourceInner(
         );
         let leaves = flatValtypes(&ty, &gc_types);
         let bt = module.addType(&[], &leaves);
-        VALUE_BLOCK_TYPES.with(|m| m.borrow_mut().insert(*box_idx, bt));
+        withGen(|s| s.value_block_types.insert(*box_idx, bt));
     }
-    CURRENT_CONSTS.with(|c| {
+    withGen(|s| {
-        let mut consts = c.borrow_mut();
+        let consts = &mut s.consts;
         for item in &source.items {
             if let ast::Item::Const(cst) = item {
                 consts.insert(cst.name.clone(), cst.value.clone());
@@ -2435,7 +2438,7 @@ fn compileSourceInner(
         for (vt, idx) in variadic_elem_vts.iter().zip(indices) {
             gc_types.variadic_array_type_idx.insert(*vt, idx);
         }
-        CURRENT_GC_TYPES.with(|c| *c.borrow_mut() = Some(gc_types.clone()));
+        withGen(|s| s.gc_types = Some(std::rc::Rc::new(gc_types.clone())));
     }
     // Register every `extern fun` as a genuine wasm import BEFORE any function.
@@ -2572,7 +2575,7 @@ fn compileSourceInner(
         let t = module.addType(&[gcRef(box_idx)], &leaves);
         let f = module.addFunction(t, &b);
         module.nameFunction(f, &format!("unbox.{name}"));
-        VALUE_HELPERS.with(|h| h.borrow_mut().insert(format!("unbox:{name}"), f));
+        withGen(|s| s.value_helpers.insert(format!("unbox:{name}"), f));
         // eq
         let mut b = vec![0u8];
         let n = leaves.len() as u32;
@@ -2596,7 +2599,7 @@ fn compileSourceInner(
         let t = module.addType(&both, &[ValType::I32]);
         let f = module.addFunction(t, &b);
         module.nameFunction(f, &format!("eq.{name}"));
-        VALUE_HELPERS.with(|h| h.borrow_mut().insert(format!("eq:{name}"), f));
+        withGen(|s| s.value_helpers.insert(format!("eq:{name}"), f));
         // proj
         for (fname, fty) in valueFieldsOf(&ty).unwrap_or_default() {
             let (off, _) = valueFieldRange(&ty, &fname).unwrap();
@@ -2609,7 +2612,7 @@ fn compileSourceInner(
             let t = module.addType(&leaves, &fleaves);
             let f = module.addFunction(t, &b);
             module.nameFunction(f, &format!("proj.{name}.{fname}"));
-            VALUE_HELPERS.with(|h| h.borrow_mut().insert(format!("proj:{name}.{fname}"), f));
+            withGen(|s| s.value_helpers.insert(format!("proj:{name}.{fname}"), f));
         }
     }
@@ -2632,7 +2635,7 @@ fn compileSourceInner(
         let ft = module.addType(&[gcRef(*box_idx)], &leaves);
         let f = module.addFunction(ft, &b);
         module.nameFunction(f, &format!("unbox.!{t}"));
-        VALUE_HELPERS.with(|h| h.borrow_mut().insert(unboxKey(&ty), f));
+        withGen(|s| s.value_helpers.insert(unboxKey(&ty), f));
     }
     // Pre-allocate one instance of every payload-free variant of every enum instance.
@@ -2678,7 +2681,7 @@ fn compileSourceInner(
         let t = module.addType(&[gcRef(gc_types.byte_array_type_idx)], &[gcRef(str_idx)]);
         gc_types.mk_str_fn = Some(module.addFunction(t, &b));
     }
-    CURRENT_GC_TYPES.with(|c| *c.borrow_mut() = Some(gc_types.clone()));
+    withGen(|s| s.gc_types = Some(std::rc::Rc::new(gc_types.clone())));
     // Closure ABI: one `call_indirect` type per Plum function signature,
     // `(env: anyref, params...) -> result`, with every value in its own representation.
@@ -2800,7 +2803,7 @@ fn compileSourceInner(
     }
     let closure_type_indices = module.addGcTypes(closure_subtypes);
     gc_types.closure_type_idx = closure_type_indices[0];
-    CURRENT_GC_TYPES.with(|c| *c.borrow_mut() = Some(gc_types.clone()));
+    withGen(|s| s.gc_types = Some(std::rc::Rc::new(gc_types.clone())));
     let mut closures: HashMap<(usize, usize), ClosureInfo> = HashMap::new();
     let mut closure_asts: HashMap<(usize, usize), &ast::Closure> = HashMap::new();
@@ -3256,7 +3259,8 @@ fn compileMemIntrinsicFnBody(f: &ast::Fn) -> Option<Vec<u8>> {
 /// through this.
 fn wrapBytesAsStr(body: &mut Vec<u8>) {
     // No real `Str` registered at all — a raw `array<i8>` already IS this program's "Str".
+    let mk_str_fn = gcTypes().mk_str_fn;
-    let Some(mk) = withGcTypes(|r| r.mk_str_fn) else {
+    let Some(mk) = mk_str_fn else {
         return;
     };
     Instruction::Call(mk).encode(body);
@@ -3276,7 +3280,7 @@ fn compileArrayIntrinsicFnBody(f: &ast::Fn, subst: &Subst) -> Option<Vec<u8>> {
     let elem = subst.get("T")?.clone();
     let array_elem = elem.clone();
     let array_ty = PlumType::TApp("Array".to_string(), vec![elem]);
-    let array_type_idx = withGcTypes(|r| r.superIdx(&array_ty))?;
+    let array_type_idx = { let r = gcTypes(); r.superIdx(&array_ty) }?;
     if isSoaElem(&array_elem) {
         return compileSoaArrayIntrinsic(f.name.as_str(), &array_elem, array_type_idx);
     }
@@ -3510,9 +3514,9 @@ fn compileArrayIntrinsicFnBody(f: &ast::Fn, subst: &Subst) -> Option<Vec<u8>> {
 /// is one GC struct whose field `k` is the native array of leaf `k`. `get`/`set`
 /// read/write each leaf array directly (no allocation, no box).
 fn compileSoaArrayIntrinsic(name: &str, elem: &PlumType, soa_idx: u32) -> Option<Vec<u8>> {
-    let leaves = withGcTypes(|r| flatValtypes(elem, r));
+    let leaves = flatValtypes(elem, &gcTypes());
     let leaf_arrs: Vec<u32> =
-        withGcTypes(|r| leaves.iter().map(|vt| r.leaf_array_idx[vt]).collect());
+        { let r = gcTypes(); leaves.iter().map(|vt| r.leaf_array_idx[vt]).collect() };
     let n = leaves.len() as u32;
     let mut body = Vec::new();
     // Locals: declared groups, one entry per local (all single).
@@ -4662,12 +4666,12 @@ fn compileFnBodyImpl(
         idx += leafCount(ty);
     }
     for (name, ty) in &collector.named {
-        let vts = withGcTypes(|g| flatValtypes(ty, g));
+        let vts = flatValtypes(ty, &gcTypes());
         // `s = T(..s, ...)` on a param reassigns the param's own slot (F-T6-3): a
         // fresh local would shadow the param for the whole body, so every read of
         // `s` (the right-hand side included) would see the unset local.
         if let Some(pty) = decl_types.get(name).filter(|_| locals.contains_key(name)) {
-            if withGcTypes(|g| flatValtypes(pty, g)) == vts {
+            if flatValtypes(pty, &gcTypes()) == vts {
                 continue;
             }
         }
@@ -6849,7 +6853,7 @@ fn compileErrBang(
         .get(CRASH_FN_KEY)
         .ok_or_else(|| "internal codegen error: crash import missing".to_string())?;
     let callee = calleeText(&b.value);
-    let file = ERR_INFO.with(|e| e.borrow().file.clone());
+    let file = withGen(|s| s.err_info.file.clone());
     let file = if file.is_empty() {
         "main.plum".to_string()
     } else {
@@ -7100,7 +7104,7 @@ fn compileTagName(
     // An open set (a `!T` parameter's) can be any error of the program.
     let all: std::collections::BTreeSet<String>;
     let names = if names.is_empty() {
-        all = ERR_INFO.with(|e| e.borrow().codes.keys().cloned().collect());
+        all = withGen(|s| s.err_info.codes.keys().cloned().collect());
         &all
     } else {
         names
@@ -7528,7 +7532,7 @@ fn compileExprCore(
                 }
                 None => {
                     let n = &typeParamConstName(n, ctx);
-                    let const_value = CURRENT_CONSTS.with(|c| c.borrow().get(n).cloned());
+                    let const_value = withGen(|s| s.consts.get(n).cloned());
                     match const_value {
                         Some(_) if ctx.func_ids.contains_key(&format!("const#{n}")) => {
                             Instruction::Call(ctx.func_ids[&format!("const#{n}")]).encode(body);
@@ -8381,7 +8385,7 @@ fn compileStaticString(text: &str, body: &mut Vec<u8>, state: &mut ModuleState)
     let bytes = text.as_bytes();
     let data_index = state.passive_segments.len() as u32;
     state.passive_segments.push(bytes.to_vec());
-    let byte_array_type_idx = withGcTypes(|r| r.byte_array_type_idx);
+    let byte_array_type_idx = { let r = gcTypes(); r.byte_array_type_idx };
     Instruction::I32Const(0).encode(body);
     Instruction::I32Const(bytes.len() as i32).encode(body);
     Instruction::ArrayNewData {
@@ -8443,7 +8447,7 @@ fn compileInterpolatedString(
                         Instruction::Call(func_idx).encode(body);
                     }
                     PlumType::TBool => {
-                        let str_ref = withGcTypes(|r| plumTypeToGcValtype(&strType(), r));
+                        let str_ref = plumTypeToGcValtype(&strType(), &gcTypes());
                         compileBoolConditionAsI32(expr, body, ctx, state)?;
                         Instruction::If(BlockType::Result(str_ref)).encode(body);
                         compileStaticString("true", body, state);
@@ -8704,7 +8708,7 @@ fn compileClosureBody(
     }
     for (name, ty) in &info.free_vars {
         locals.insert(name.clone(), idx);
-        let vts = withGcTypes(|g| flatValtypes(ty, g));
+        let vts = flatValtypes(ty, &gcTypes());
         idx += vts.len() as u32;
         groups.extend(vts);
     }
@@ -8714,7 +8718,7 @@ fn compileClosureBody(
             continue;
         }
         locals.insert(name.clone(), idx);
-        let vts = withGcTypes(|g| flatValtypes(ty, g));
+        let vts = flatValtypes(ty, &gcTypes());
         idx += vts.len() as u32;
         groups.extend(vts);
     }

plum-wasm-codegen/tests/e2e_mem/reuse.rs CHANGED Viewed

@@ -27,8 +27,21 @@ fn runInt(name: &str, src: &str, reuse: bool) -> i64 {
 /// Number of `struct.new` instructions in the whole module.
 fn structNewCount(name: &str, src: &str, reuse: bool) -> usize {
+    structNewCountWith(name, src, reuse, true)
+}
+/// `structNewCount` with the fusion stage on or off, so reuse is measured on its own: with
+/// fusion on, the `sum(bump(..))` pipeline is fused away entirely (fewer allocations for
+/// another reason), and a program pre-marked by hand is not what the real pipeline sees.
+fn structNewCountWith(name: &str, src: &str, reuse: bool, fusion: bool) -> usize {
     let source = load(name, src, reuse).expect("load");
+    let opts = plum_wasm_codegen::CompileOptions {
+        fusion: plum_checker::FusionOptions { enabled: fusion, explain: false },
+        ..Default::default()
+    };
+    let bytes = plum_wasm_codegen::compile(&source, &opts)
+        .map(|o| o.wasm)
-    let bytes = plum_wasm_codegen::compileSource(&source).unwrap_or_else(|e| panic!("compile failed: {e}"));
+        .unwrap_or_else(|e| panic!("compile failed: {e}"));
     wasmparser::validate(&bytes).expect("valid wasm");
     let mut n = 0;
     for payload in wasmparser::Parser::new(0).parse_all(&bytes) {
@@ -68,20 +81,13 @@ fun bump(xs: Link) -> Link = match xs
 fun main2() -> Int = sum(bump(Cons(head: 1, tail: Cons(head: 2, tail: Nil))))
 ";
-/// Runs `f` with the fusion stage off, so reuse is measured on its own: with fusion on, the
-/// `sum(bump(..))` pipeline is fused away entirely (fewer allocations for another reason),
-/// and a program pre-marked by hand is not what the real pipeline sees.
-fn withoutFusion<R>(f: impl FnOnce() -> R) -> R {
-    plum_checker::withFusionOptions(plum_checker::FusionOptions { enabled: false, explain: false }, f)
-}
 /// The recursive `inc` is rewritten by TRMC (which builds its own cell), so the
 /// struct.new count is checked on a non-recursive rebuild; `inc` is checked for results.
 #[test]
 fn bump_reuses_cells() {
     let p = format!("{PRE}{INC}{BUMP}");
-    let a = withoutFusion(|| structNewCount("bump_off", &p, false));
+    let a = structNewCountWith("bump_off", &p, false, false);
-    let b = withoutFusion(|| structNewCount("bump_on", &p, true));
+    let b = structNewCountWith("bump_on", &p, true, false);
     assert_eq!(a, b + 1, "off {a} struct.new, on {b}");
 }
@@ -104,7 +110,7 @@ fn pipeline_marks_bump_reuse() {
     assert!(bump.contains("reuse: Some(\"xs\")"), "{bump}");
     // The fused pipeline allocates less than the unfused one.
     let fused = structNewCount("bump_fused", &p, false);
-    let plain = withoutFusion(|| structNewCount("bump_plain", &p, false));
+    let plain = structNewCountWith("bump_plain", &p, false, false);
     assert!(fused < plain, "fused {fused} vs unfused {plain}");
 }

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

@@ -1,7 +1,6 @@
 #![allow(non_snake_case)]
 //! Fusion allocation checks: compile through the real pipeline (checker `typedSource`
 //! runs the supercompiler stage) and count `struct.new` of cell types per function.
-use plum_wasm_codegen::compileSource;
 use plum_test_support::repoRoot;
 use std::collections::HashMap;
 use std::collections::HashSet;
@@ -15,11 +14,11 @@ fn load(name: &str, src: &str) -> plum_core::ast::Source {
 }
 fn compile(source: &plum_core::ast::Source, fusion: bool) -> Vec<u8> {
-    let r = plum_checker::withFusionOptions(
+    let opts = plum_wasm_codegen::CompileOptions {
-        plum_checker::FusionOptions { enabled: fusion, explain: false },
+        fusion: plum_checker::FusionOptions { enabled: fusion, explain: false },
-        || compileSource(source),
+        ..Default::default()
-    );
+    };
-    let bytes = r.unwrap_or_else(|e| panic!("compile failed: {e}"));
+    let bytes = plum_wasm_codegen::compile(source, &opts).map(|o| o.wasm).unwrap_or_else(|e| panic!("compile failed: {e}"));
     wasmparser::validate(&bytes).expect("valid wasm");
     bytes
 }
@@ -121,9 +120,9 @@ const PRE: &str = "import std/Str\nimport std/Int\nimport std/List\nimport std/S
 /// The fusion notes for `source` (what `--explain-fusion` prints): the stage is run
 /// by hand on the checker's lowered program, built without fusion.
 fn notes(source: &plum_core::ast::Source) -> Vec<String> {
-    let info = plum_checker::withFusionOptions(
+    let info = plum_checker::typedSourceWith(
+        source,
         plum_checker::FusionOptions { enabled: false, explain: false },
-        || plum_checker::typedSource(source),
     )
     .unwrap_or_else(|e| panic!("check: {e:?}"));
     let mut copy = match info.lowered.as_ref() {