b3aeaba | plum | pyrossh

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

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

b3aeaba — Peter John 2026-11-04T09:40:55+05:30

plum: --no-fusion and --explain-fusion flags replace the env vars

Files changed (7) hide show

README.md +1 -1
plum-checker/src/lib.rs +44 -3
plum-checker/tests/fusion_pipeline_test.rs +1 -1
plum-cli/src/main.rs +23 -11
plum-core/tests/trmc_test.rs +3 -14
plum-wasm-codegen/tests/fusion_alloc_test.rs +11 -18
plum-wasm-codegen/tests/own_inplace_e2e_test.rs +1 -5

README.md CHANGED Viewed

@@ -891,7 +891,7 @@ What it does:
 - **Uniqueness to in-place spreads.** `markUnique` proves that a spread source (`T(..x, f: v)`) is not used afterwards and not shared, and marks the construction `unique`: codegen then writes the fields into `x` instead of copying it. Records declared `own` are already treated this way.
 - **Reuse.** A same-shape rebuild of a value that is dead afterwards (a `match` arm that rebuilds the constructor it matched) reuses the old cell.
-Switches: `PLUM_NO_FUSION=1` skips the whole stage; `plum run|test --explain-fusion` (or `PLUM_EXPLAIN_FUSION=1`) prints each decision to stderr (`fusion: ...`, `unique spread at fn:line`, and why a call was not specialised).
+Switches: `plum build|run|test|game --no-fusion` skips the whole stage; `--explain-fusion` prints each decision to stderr (`fusion: ...`, `unique spread at fn:line`, and why a call was not specialised).
 Limits:

plum-checker/src/lib.rs CHANGED Viewed

@@ -1178,6 +1178,47 @@ 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).
+#[derive(Clone, Copy, Debug)]
+pub struct FusionOptions {
+    /// Run the fusion stage (`--no-fusion` clears it).
+    pub enabled: bool,
+    /// Print each fusion decision to stderr (`--explain-fusion`).
+    pub explain: bool,
+}
+impl Default for FusionOptions {
+    fn default() -> Self {
+        FusionOptions { enabled: true, explain: false }
+    }
+}
+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()
+}
 pub fn typedSource(source: &ast::Source) -> CheckResult<TypedInfo> {
     let (mut result, mut info) = checkSourceFull(source);
     // Closure specialisation: copies of callees with the closure argument inlined. Same
@@ -1202,8 +1243,8 @@ pub fn typedSource(source: &ast::Source) -> CheckResult<TypedInfo> {
         }
     }
     // Supercompiler stage: purity -> simplify -> drive -> uniqueness -> reuse. Same
-    // re-check discipline; PLUM_NO_FUSION=1 skips it.
+    // re-check discipline; `--no-fusion` skips it.
-    if result.is_ok() && std::env::var_os("PLUM_NO_FUSION").is_none() {
+    if result.is_ok() && fusionOptions().enabled {
         {
             // Programs with no loops or unions have no lowered program: start from the source.
             let mut copy = match info.lowered.as_ref() {
@@ -1211,7 +1252,7 @@ pub fn typedSource(source: &ast::Source) -> CheckResult<TypedInfo> {
                 None => source.clone(),
             };
             let notes = fusionRewrite(&mut copy);
-            if std::env::var("PLUM_EXPLAIN_FUSION").map(|v| v == "1").unwrap_or(false) {
+            if fusionOptions().explain {
                 for n in &notes {
                     eprintln!("fusion: {n}");
                 }

plum-checker/tests/fusion_pipeline_test.rs CHANGED Viewed

@@ -89,7 +89,7 @@ fn runTest(fusion: bool, file: &str) -> String {
     let mut cmd = std::process::Command::new(bin);
     cmd.current_dir(&root).args(["test", file]);
     if !fusion {
-        cmd.env("PLUM_NO_FUSION", "1");
+        cmd.arg("--no-fusion");
     }
     let out = cmd.output().unwrap();
     format!("{}{}", String::from_utf8_lossy(&out.stdout), out.status.success())

plum-cli/src/main.rs CHANGED Viewed

@@ -53,6 +53,9 @@ enum Command {
         /// Print the fusion/uniqueness decisions to stderr
         #[arg(long)]
         explain_fusion: bool,
+        /// Skip the fusion (supercompiler) stage
+        #[arg(long)]
+        no_fusion: bool,
         /// Root directory `import <path>` is resolved against (`import std/x` -> `<lib-path>/std/x.plum`)
         #[arg(long, default_value = ".")]
         lib_path: std::path::PathBuf,
@@ -65,6 +68,9 @@ enum Command {
         /// Print the fusion/uniqueness decisions to stderr
         #[arg(long)]
         explain_fusion: bool,
+        /// Skip the fusion (supercompiler) stage
+        #[arg(long)]
+        no_fusion: bool,
         /// Output executable path (default: input file's name, no extension)
         #[arg(short, long)]
         output: Option<std::path::PathBuf>,
@@ -81,6 +87,9 @@ enum Command {
         /// Print the fusion/uniqueness decisions to stderr
         #[arg(long)]
         explain_fusion: bool,
+        /// Skip the fusion (supercompiler) stage
+        #[arg(long)]
+        no_fusion: bool,
         /// Root directory `import <path>` is resolved against (`import std/x` -> `<lib-path>/std/x.plum`)
         #[arg(long, default_value = ".")]
         lib_path: std::path::PathBuf,
@@ -92,6 +101,9 @@ enum Command {
         /// Print the fusion/uniqueness decisions to stderr
         #[arg(long)]
         explain_fusion: bool,
+        /// Skip the fusion (supercompiler) stage
+        #[arg(long)]
+        no_fusion: bool,
         /// Write the static build (index.html, plum_bridge.js, plum.wasm, preload.txt, assets/) here and exit
         #[arg(short, long)]
         output: Option<std::path::PathBuf>,
@@ -125,11 +137,9 @@ fn main() {
     }
 }
-/// `--explain-fusion` is the env switch `plum-checker` reads.
+/// `--no-fusion` / `--explain-fusion` set the checker's fusion options.
-fn setExplain(on: bool) {
+fn setFusion(explain: bool, no_fusion: bool) {
-    if on {
-        std::env::set_var("PLUM_EXPLAIN_FUSION", "1");
+    plum_checker::setFusionOptions(plum_checker::FusionOptions { enabled: !no_fusion, explain });
-    }
 }
 fn run() -> Result<()> {
@@ -141,8 +151,8 @@ fn run() -> Result<()> {
             output,
             lib_path,
         } => cmdCompile(file, output, lib_path),
-        Command::Run { file, lib_path, explain_fusion } => {
+        Command::Run { file, lib_path, explain_fusion, no_fusion } => {
-            setExplain(explain_fusion);
+            setFusion(explain_fusion, no_fusion);
             cmdRun(file, lib_path)
         }
         Command::Build {
@@ -150,12 +160,13 @@ fn run() -> Result<()> {
             output,
             lib_path,
             explain_fusion,
+            no_fusion,
         } => {
-            setExplain(explain_fusion);
+            setFusion(explain_fusion, no_fusion);
             cmdBuild(file, output, lib_path)
         }
-        Command::Test { paths, lib_path, explain_fusion } => {
+        Command::Test { paths, lib_path, explain_fusion, no_fusion } => {
-            setExplain(explain_fusion);
+            setFusion(explain_fusion, no_fusion);
             cmdTest(paths, lib_path)
         }
         Command::Game {
@@ -166,8 +177,9 @@ fn run() -> Result<()> {
             no_open,
             lib_path,
             explain_fusion,
+            no_fusion,
         } => {
-            setExplain(explain_fusion);
+            setFusion(explain_fusion, no_fusion);
             game::cmdGame(file, output, assets, port, no_open, lib_path)
         }
         Command::Editor { editor, insiders } => editor::install(editor, insiders),

plum-core/tests/trmc_test.rs CHANGED Viewed

@@ -2,22 +2,11 @@
 //! 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 std::sync::Mutex;
-/// `PLUM_NO_FUSION` is process-wide and the checker reads it on every `typedSource`:
-/// every check or compile in this file takes this lock.
-static ENV: Mutex<()> = Mutex::new(());
+use plum_checker::{withFusionOptions, FusionOptions};
+/// The fusion option is thread-local: each test compiles on its own thread.
 fn withFusion<R>(fusion: bool, f: impl FnOnce() -> R) -> R {
-    let _g = ENV.lock().unwrap_or_else(|e| e.into_inner());
+    withFusionOptions(FusionOptions { enabled: fusion, explain: false }, f)
-    if fusion {
-        std::env::remove_var("PLUM_NO_FUSION");
-    } else {
-        std::env::set_var("PLUM_NO_FUSION", "1");
-    }
-    let r = f();
-    std::env::remove_var("PLUM_NO_FUSION");
-    r
 }
 fn compileSource(source: &plum_core::ast::Source) -> Result<Vec<u8>, String> {

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

@@ -3,12 +3,8 @@
 //! runs the supercompiler stage) and count `struct.new` of cell types per function.
 use plum_wasm_codegen::compileSource;
 use std::collections::HashMap;
-use std::sync::Mutex;
 use std::collections::HashSet;
-/// `PLUM_NO_FUSION` is process-wide: every compile takes this lock.
-static ENV: Mutex<()> = Mutex::new(());
 fn repoRoot() -> std::path::PathBuf {
     std::path::Path::new(env!("CARGO_MANIFEST_DIR")).join("..")
 }
@@ -28,14 +24,10 @@ fn load(name: &str, src: &str) -> plum_core::ast::Source {
 }
 fn compile(source: &plum_core::ast::Source, fusion: bool) -> Vec<u8> {
-    let _g = ENV.lock().unwrap_or_else(|e| e.into_inner());
+    let r = plum_checker::withFusionOptions(
-    if fusion {
-        std::env::remove_var("PLUM_NO_FUSION");
-    } else {
-        std::env::set_var("PLUM_NO_FUSION", "1");
+        plum_checker::FusionOptions { enabled: fusion, explain: false },
-    }
-    let r = compileSource(source);
+        || compileSource(source),
-    std::env::remove_var("PLUM_NO_FUSION");
+    );
     let bytes = r.unwrap_or_else(|e| panic!("compile failed: {e}"));
     wasmparser::validate(&bytes).expect("valid wasm");
     bytes
@@ -135,13 +127,14 @@ fn say(line: String) {
 const PRE: &str = "import std/Str\nimport std/Int\nimport std/List\nimport std/Slice\n\n";
-/// The fusion notes for `source` (what `PLUM_EXPLAIN_FUSION=1` prints): the stage is run
+/// 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 _g = ENV.lock().unwrap_or_else(|e| e.into_inner());
+    let info = plum_checker::withFusionOptions(
-    std::env::set_var("PLUM_NO_FUSION", "1");
+        plum_checker::FusionOptions { enabled: false, explain: false },
+        || plum_checker::typedSource(source),
+    )
-    let info = plum_checker::typedSource(source).unwrap_or_else(|e| panic!("check: {e:?}"));
+    .unwrap_or_else(|e| panic!("check: {e:?}"));
-    std::env::remove_var("PLUM_NO_FUSION");
     let mut copy = match info.lowered.as_ref() {
         Some(l) => (**l).clone(),
         None => source.clone(),
@@ -222,7 +215,7 @@ fn list_pipeline_loop_has_no_cons_alloc() {
     let eng = engine(false);
     let (a, _) = runInt(&eng, &fused);
     let (b, _) = runInt(&eng, &plain);
-    assert_eq!(a, b, "fused result differs from PLUM_NO_FUSION");
+    assert_eq!(a, b, "fused result differs from the unfused build");
     assert_eq!(a, expected(100));
 }

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

@@ -1,9 +1,6 @@
 #![allow(non_snake_case)]
 use plum_wasm_codegen::compileSource;
-/// Env vars are process-wide; serialise tests that depend on PLUM_NO_FUSION.
-static ENV: std::sync::Mutex<()> = std::sync::Mutex::new(());
 fn gcEngine() -> wasmtime::Engine {
     let mut config = wasmtime::Config::new();
     config.wasm_gc(true);
@@ -230,10 +227,9 @@ fun main() -> Int =
     assert_eq!(runInt("reassign_param", &own), 41000 + 207);
     let plain = prog(&body.replace("own record", "record").replace("own s", "s"));
     assert_eq!(runInt("reassign_param_plain", &plain), 41000 + 207);
-    let _g = ENV.lock().unwrap_or_else(|e| e.into_inner());
     let p = structNewCount("reassign_param_p", &plain);
     let o = structNewCount("reassign_param_o", &own);
-    if std::env::var_os("PLUM_NO_FUSION").is_some() {
+    if !plum_checker::fusionOptions().enabled {
         assert_eq!(p, o + 1);
     } else {
         // Uniqueness proves the plain reassignment unique, so it is written in place too.