ec115b0 | plum | pyrossh

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

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

ec115b0 — Peter John 2026-10-26T18:56:27+05:30

fix: stateful host RNG; evaluate assert operands once in test blocks

Files changed (4) hide show

plum-cli/src/main.rs +39 -17
plum-cli/tests/assert_once_test.rs +54 -0
plum-runtime/src/main.rs +37 -9
plum-wasm-codegen/src/lib.rs +52 -23

plum-cli/src/main.rs CHANGED Viewed

@@ -626,24 +626,33 @@ fn performHttpRequest(method: &str, url: &str, headers: &str, body: &str) -> Str
     }
 }
-/// A pseudo-random `i64` seeded from the wall clock — `xorshift64*`, cheap and
+/// A pseudo-random `i64`: splitmix64 over process-wide state seeded once. Cheap,
-/// dependency-free (no `rand` crate in this workspace). Not cryptographically
+/// dependency-free, not cryptographically secure.
-/// secure; fine for `Int.random`/`List.shuffle`/`Uuid.v4`, none of which need
-/// that. Re-seeded from the clock on every call rather than keeping PRNG state
-/// across calls — simpler than threading mutable state through `Store<()>`'s
-/// otherwise-stateless `()` data, at the cost of needing enough clock
-/// resolution between calls to avoid repeats (nanosecond resolution is ample
-/// for this use).
 fn randomI64() -> i64 {
+    use std::sync::atomic::{AtomicU64, Ordering};
+    // splitmix64 over a process-wide counter: seeded once from the clock and
+    // an address, then advanced by a fixed odd increment per call, so
+    // back-to-back calls can never repeat.
+    static STATE: AtomicU64 = AtomicU64::new(0);
+    let mut cur = STATE.load(Ordering::Relaxed);
+    if cur == 0 {
-    let nanos = std::time::SystemTime::now()
+        let nanos = std::time::SystemTime::now()
-        .duration_since(std::time::UNIX_EPOCH)
+            .duration_since(std::time::UNIX_EPOCH)
-        .map(|d| d.as_nanos() as u64)
+            .map(|d| d.as_nanos() as u64)
-        .unwrap_or(0);
+            .unwrap_or(0);
+        let seed = (nanos ^ (&STATE as *const AtomicU64 as u64)) | 1;
+        cur = match STATE.compare_exchange(0, seed, Ordering::Relaxed, Ordering::Relaxed) {
+            Ok(_) => seed,
+            Err(v) => v,
+        };
+    }
+    let _ = cur;
+    let mut z = STATE
+        .fetch_add(0x9E3779B97F4A7C15, Ordering::Relaxed)
-    let mut x = nanos ^ 0x9E3779B97F4A7C15;
+        .wrapping_add(0x9E3779B97F4A7C15);
+    z = (z ^ (z >> 30)).wrapping_mul(0xBF58476D1CE4E5B9);
-    x ^= x << 13;
+    z = (z ^ (z >> 27)).wrapping_mul(0x94D049BB133111EB);
-    x ^= x >> 7;
+    (z ^ (z >> 31)) as i64
-    x ^= x << 17;
-    x as i64
 }
 /// `Str` is now a real two-level wasm-gc struct — `Str{data: Buffer{data:
@@ -1083,3 +1092,16 @@ fn cmdBuild(
     eprintln!("built {} → {}", file.display(), out_path.display());
     Ok(())
 }
+#[cfg(test)]
+mod rng_tests {
+    #[test]
+    fn random_i64_never_repeats_back_to_back() {
+        let mut prev = super::randomI64();
+        for _ in 0..100_000 {
+            let next = super::randomI64();
+            assert_ne!(prev, next);
+            prev = next;
+        }
+    }
+}

plum-cli/tests/assert_once_test.rs ADDED Viewed

@@ -0,0 +1,54 @@
+#![allow(non_snake_case)]
+use std::process::Command;
+fn plumBin() -> std::path::PathBuf {
+    let mut path = std::env::current_exe().unwrap();
+    path.pop();
+    if path.ends_with("deps") {
+        path.pop();
+    }
+    path.push("plum");
+    path
+}
+/// A failing `assert a == b` must evaluate each operand exactly once, and
+/// report the very values it compared.
+#[test]
+fn assert_operands_evaluated_once() {
+    let dir = std::env::temp_dir().join(format!("plum_assert_once_{}", std::process::id()));
+    std::fs::create_dir_all(&dir).unwrap();
+    let src = dir.join("once.plum");
+    std::fs::write(
+        &src,
+        r#"import std/Str
+import std/Number
+enum Counter =
+  | Counter(n: Int)
+  fun bump(self) -> Int =
+    self.n = self.n + 1
+    return self.n
+test "operands once"
+  a := Counter(n: 0)
+  b := Counter(n: 100)
+  assert a.bump() == b.bump()
+  assert a.n == 1
+  assert b.n == 101
+"#,
+    )
+    .unwrap();
+    let root = std::path::Path::new(env!("CARGO_MANIFEST_DIR")).parent().unwrap();
+    let out = Command::new(plumBin())
+        .current_dir(root)
+        .args(["test", src.to_str().unwrap()])
+        .output()
+        .expect("failed to run plum");
+    let stdout = String::from_utf8_lossy(&out.stdout);
+    // Only the first assert (1 vs 101) fails; the counters advanced once each.
+    assert!(stdout.contains("Expected: 101"), "stdout was: {}", stdout);
+    assert!(stdout.contains("Actual:   1"), "stdout was: {}", stdout);
+    assert!(!stdout.contains("a.n == 1"), "counter advanced more than once: {}", stdout);
+    assert!(!stdout.contains("b.n == 101"), "counter advanced more than once: {}", stdout);
+}

plum-runtime/src/main.rs CHANGED Viewed

@@ -259,15 +259,30 @@ fn performHttpRequest(method: &str, url: &str, headers: &str, body: &str) -> Str
 /// fresh per `plum build` invocation, not linked against `plum-cli`, so the
 /// logic is duplicated rather than shared.
 fn randomI64() -> i64 {
+    use std::sync::atomic::{AtomicU64, Ordering};
+    // splitmix64 over a process-wide counter: seeded once from the clock and
+    // an address, then advanced by a fixed odd increment per call, so
+    // back-to-back calls can never repeat.
+    static STATE: AtomicU64 = AtomicU64::new(0);
+    let mut cur = STATE.load(Ordering::Relaxed);
+    if cur == 0 {
-    let nanos = std::time::SystemTime::now()
+        let nanos = std::time::SystemTime::now()
-        .duration_since(std::time::UNIX_EPOCH)
+            .duration_since(std::time::UNIX_EPOCH)
-        .map(|d| d.as_nanos() as u64)
+            .map(|d| d.as_nanos() as u64)
-        .unwrap_or(0);
+            .unwrap_or(0);
+        let seed = (nanos ^ (&STATE as *const AtomicU64 as u64)) | 1;
+        cur = match STATE.compare_exchange(0, seed, Ordering::Relaxed, Ordering::Relaxed) {
+            Ok(_) => seed,
+            Err(v) => v,
+        };
+    }
+    let _ = cur;
+    let mut z = STATE
+        .fetch_add(0x9E3779B97F4A7C15, Ordering::Relaxed)
-    let mut x = nanos ^ 0x9E3779B97F4A7C15;
+        .wrapping_add(0x9E3779B97F4A7C15);
+    z = (z ^ (z >> 30)).wrapping_mul(0xBF58476D1CE4E5B9);
-    x ^= x << 13;
+    z = (z ^ (z >> 27)).wrapping_mul(0x94D049BB133111EB);
-    x ^= x >> 7;
+    (z ^ (z >> 31)) as i64
-    x ^= x << 17;
-    x as i64
 }
 /// See the identical helpers in `plum-cli/src/main.rs` — this crate is built
@@ -390,3 +405,16 @@ fn main() {
         std::process::exit(1);
     }
 }
+#[cfg(test)]
+mod rng_tests {
+    #[test]
+    fn random_i64_never_repeats_back_to_back() {
+        let mut prev = super::randomI64();
+        for _ in 0..100_000 {
+            let next = super::randomI64();
+            assert_ne!(prev, next);
+            prev = next;
+        }
+    }
+}

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

@@ -1492,17 +1492,17 @@ fn strLit(s: String) -> ast::Expr {
 /// special-casing out here any more. A non-comparison condition (`assert
 /// isEven(4)`) has no meaningful actual/expected split — a boolean condition
 /// is always false by the time this fires — so it's just the bare text.
-fn assertFailureMessage(c: &ast::Check) -> ast::Expr {
+fn assertFailureMessage(c: &ast::Check, lhs: &ast::Expr, rhs: &ast::Expr) -> ast::Expr {
-    let ast::Expr::Compare(cmp) = &c.cond else {
+    if !matches!(&c.cond, ast::Expr::Compare(_)) {
         return strLit(format!("{}\n", c.text));
-    };
+    }
     ast::Expr::String(ast::StringExpr {
         parts: vec![
             ast::StringPart::Text(format!("{}\n", c.text)),
             ast::StringPart::Text("      Expected: ".to_string()),
-            ast::StringPart::Interp(cmp.right.clone()),
+            ast::StringPart::Interp(rhs.clone()),
             ast::StringPart::Text("\n      Actual:   ".to_string()),
-            ast::StringPart::Interp(cmp.left.clone()),
+            ast::StringPart::Interp(lhs.clone()),
             ast::StringPart::Text("\n".to_string()),
         ],
     })
@@ -1526,7 +1526,7 @@ fn desugarTestsToFns(source: &ast::Source) -> (ast::Source, Vec<(String, String)
                     values: vec![strLit(String::new())],
                     declare: true,
                 }));
-                stmts.extend(t.body.stmts.iter().map(desugarAssertStmt));
+                stmts.extend(desugarAssertStmts(&t.body.stmts));
                 stmts.push(ast::Stmt::Expr(
                     ast::Expr::Var("__report".to_string()),
                     0,
@@ -1571,31 +1571,60 @@ fn desugarTestsToFns(source: &ast::Source) -> (ast::Source, Vec<(String, String)
 /// `if !cond { __report = __report + "<text>\n" }`, descending into nested
 /// control-flow blocks so an `assert` inside a `test`'s own
 /// `if`/`while`/`for`/`match` still records into the same hidden accumulator.
+fn desugarAssertStmts(stmts: &[ast::Stmt]) -> Vec<ast::Stmt> {
+    stmts.iter().flat_map(desugarAssertStmt).collect()
+}
-fn desugarAssertStmt(stmt: &ast::Stmt) -> ast::Stmt {
+fn desugarAssertStmt(stmt: &ast::Stmt) -> Vec<ast::Stmt> {
     match stmt {
         ast::Stmt::Assert(c) => {
+            // A comparison evaluates each operand exactly once into a
+            // temporary (left first), then compares and reports the temporaries.
+            static ASSERT_TMP: std::sync::atomic::AtomicUsize = std::sync::atomic::AtomicUsize::new(0);
+            let mut pre = Vec::new();
+            let mut cond = c.cond.clone();
+            let (mut lhs, mut rhs) = (ast::Expr::Var(String::new()), ast::Expr::Var(String::new()));
+            if let ast::Expr::Compare(cmp) = &c.cond {
+                let n = ASSERT_TMP.fetch_add(1, std::sync::atomic::Ordering::Relaxed);
+                let (l, r) = (format!("__lhs_{}", n), format!("__rhs_{}", n));
+                for (name, e) in [(&l, &cmp.left), (&r, &cmp.right)] {
+                    pre.push(ast::Stmt::Assign(ast::Assign {
+                        targets: vec![ast::AssignTarget::Var(name.clone())],
+                        values: vec![e.clone()],
+                        declare: true,
+                    }));
+                }
+                lhs = ast::Expr::Var(l);
+                rhs = ast::Expr::Var(r);
+                cond = ast::Expr::Compare(Box::new(ast::CompareExpr {
+                    op: cmp.op.clone(),
+                    left: lhs.clone(),
+                    right: rhs.clone(),
+                }));
+            }
             let appendReport = ast::Stmt::Assign(ast::Assign {
                 targets: vec![ast::AssignTarget::Var("__report".to_string())],
                 values: vec![ast::Expr::Binary(Box::new(ast::BinaryExpr {
                     op: ast::BinOp::Add,
                     left: ast::Expr::Var("__report".to_string()),
-                    right: assertFailureMessage(c),
+                    right: assertFailureMessage(c, &lhs, &rhs),
                 }))],
                 declare: false,
             });
-            ast::Stmt::If(ast::If {
+            pre.push(ast::Stmt::If(ast::If {
-                condition: ast::Expr::Not(Box::new(c.cond.clone())),
+                condition: ast::Expr::Not(Box::new(cond)),
                 body: ast::Block {
                     stmts: vec![appendReport],
                 },
                 else_ifs: vec![],
                 else_: None,
-            })
+            }));
+            pre
         }
-        ast::Stmt::If(i) => ast::Stmt::If(ast::If {
+        ast::Stmt::If(i) => vec![ast::Stmt::If(ast::If {
             condition: i.condition.clone(),
             body: ast::Block {
-                stmts: i.body.stmts.iter().map(desugarAssertStmt).collect(),
+                stmts: desugarAssertStmts(&i.body.stmts),
             },
             else_ifs: i
                 .else_ifs
@@ -1603,21 +1632,21 @@ fn desugarAssertStmt(stmt: &ast::Stmt) -> ast::Stmt {
                 .map(|ei| ast::ElseIf {
                     condition: ei.condition.clone(),
                     body: ast::Block {
-                        stmts: ei.body.stmts.iter().map(desugarAssertStmt).collect(),
+                        stmts: desugarAssertStmts(&ei.body.stmts),
                     },
                 })
                 .collect(),
             else_: i.else_.as_ref().map(|b| ast::Block {
-                stmts: b.stmts.iter().map(desugarAssertStmt).collect(),
+                stmts: desugarAssertStmts(&b.stmts),
             }),
-        }),
+        })],
-        ast::Stmt::While(w) => ast::Stmt::While(ast::While {
+        ast::Stmt::While(w) => vec![ast::Stmt::While(ast::While {
             condition: w.condition.clone(),
             body: ast::Block {
-                stmts: w.body.stmts.iter().map(desugarAssertStmt).collect(),
+                stmts: desugarAssertStmts(&w.body.stmts),
             },
-        }),
+        })],
-        ast::Stmt::Match(m) => ast::Stmt::Match(ast::Match {
+        ast::Stmt::Match(m) => vec![ast::Stmt::Match(ast::Match {
             subjects: m.subjects.clone(),
             cases: m
                 .cases
@@ -1626,12 +1655,12 @@ fn desugarAssertStmt(stmt: &ast::Stmt) -> ast::Stmt {
                     patterns: c.patterns.clone(),
                     guard: c.guard.clone(),
                     body: ast::Block {
-                        stmts: c.body.stmts.iter().map(desugarAssertStmt).collect(),
+                        stmts: desugarAssertStmts(&c.body.stmts),
                     },
                 })
                 .collect(),
-        }),
+        })],
-        other => other.clone(),
+        other => vec![other.clone()],
     }
 }