7a7fd58 | plum | pyrossh

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

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

7a7fd58 — Peter John 2026-11-01T22:57:09+05:30

feat: Byte struct fields; assert report falls back without toStr; plum test runs only the named files' tests; MapPoint test moved out of std

Files changed (11) hide show

README.md +2 -2
plum-checker/src/lib.rs +2 -2
plum-checker/tests/checker_tests.rs +1 -1
plum-cli/tests/test_scope_test.rs +66 -0
plum-core/src/ast.rs +7 -2
plum-core/src/parser.rs +1 -0
plum-examples/map_struct_values.plum +21 -0
plum-examples/struct_arrays.plum +24 -0
plum-std/Map.plum +0 -15
plum-wasm-codegen/src/lib.rs +28 -1
plum-wasm-codegen/tests/codegen_tests.rs +66 -0

README.md CHANGED Viewed

@@ -418,7 +418,7 @@ u2 := u
 u2.age = 4         # u.age is now 4: a record is a heap object, shared on assignment
 ```
-A `struct` has no generics; its fields are only `Int`, `Float`, `Bool` or other structs, and a struct can't contain itself. Values are copied on assignment and when passed, and are boxed inside `T?` and other generic slots. Arrays of structs (`Array[Vec2]`, and so `List[Vec2]` and `Grid[Tile]`) are stored field by field, one native array per field, with no per-element allocation. A `record` may have any field types and may be generic (`record Pair[K, V](key: K, val: V)`). Methods and `match` work as for any enum. See [`plum-examples/values.plum`](plum-examples/values.plum).
+A `struct` has no generics; its fields are only `Int`, `Float`, `Bool`, `Byte` or other structs, and a struct can't contain itself. Values are copied on assignment and when passed, and are boxed inside `T?` and other generic slots. Arrays of structs (`Array[Vec2]`, and so `List[Vec2]` and `Grid[Tile]`) are stored field by field, one native array per field, with no per-element allocation. A `record` may have any field types and may be generic (`record Pair[K, V](key: K, val: V)`). Methods and `match` work as for any enum. See [`plum-examples/values.plum`](plum-examples/values.plum).
 ### Enums
@@ -965,7 +965,7 @@ Each error name gets a global `i32` code, interned in sorted order from 1 (0 mea
 ## Testing
-Zig-style `test` blocks are a native language feature, compiled and run only by `plum test`. `plum test` takes files and directories (searched recursively):
+Zig-style `test` blocks are a native language feature, compiled and run only by `plum test`. `plum test` takes files and directories (searched recursively) and runs only the tests declared in those files, not the ones in their imports:
 ```plum
 fun add(a: Int, b: Int) -> Int =

plum-checker/src/lib.rs CHANGED Viewed

@@ -1315,13 +1315,13 @@ fn checkValueEnums(source: &ast::Source) -> Vec<CheckError> {
         let v = &e.variants[0];
         for (i, fty) in v.fields.iter().enumerate() {
             let ok = fty.generics.is_empty()
-                && (matches!(fty.name.as_str(), "Int" | "Float" | "Bool") || values.contains_key(fty.name.as_str()));
+                && (matches!(fty.name.as_str(), "Int" | "Float" | "Bool" | "Byte") || values.contains_key(fty.name.as_str()));
             if !ok {
                 let name = v.field_names.get(i).cloned().unwrap_or_else(|| i.to_string());
                 errors.push(CheckError::at(
                     e.line,
                     e.column,
-                    format!("struct field '{}' must be Int, Float, Bool or a struct", name),
+                    format!("struct field '{}' must be Int, Float, Bool, Byte or a struct", name),
                 ));
             }
         }

plum-checker/tests/checker_tests.rs CHANGED Viewed

@@ -1581,7 +1581,7 @@ fn valueErrors(src: &str) -> Vec<String> {
 fn value_enum_str_field_rejected() {
     let errs = valueErrors("struct Named(label: Str, n: Int)\n");
     assert!(
-        errs.iter().any(|e| e.contains("struct field 'label' must be Int, Float, Bool or a struct")),
+        errs.iter().any(|e| e.contains("struct field 'label' must be Int, Float, Bool, Byte or a struct")),
         "{errs:?}"
     );
 }

plum-cli/tests/test_scope_test.rs ADDED Viewed

@@ -0,0 +1,66 @@
+#![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
+}
+fn runPlum(args: &[&str]) -> (String, bool) {
+    let root = std::path::Path::new(env!("CARGO_MANIFEST_DIR")).parent().unwrap();
+    let out = Command::new(plumBin())
+        .current_dir(root)
+        .arg("test")
+        .args(args)
+        .output()
+        .expect("failed to run plum");
+    (String::from_utf8_lossy(&out.stdout).to_string(), out.status.success())
+}
+fn scratch(name: &str) -> std::path::PathBuf {
+    let dir = std::env::temp_dir().join(format!("plum_scope_{}_{}", name, std::process::id()));
+    std::fs::create_dir_all(&dir).unwrap();
+    dir
+}
+const TWO: &str = "import std/Str\nimport std/Int\n\ntest \"one\"\n  assert 1 == 1\n\ntest \"two\"\n  assert 2 == 2\n";
+#[test]
+fn fileRunsOnlyItsOwnTests() {
+    let dir = scratch("file");
+    let f = dir.join("two.plum");
+    std::fs::write(&f, TWO).unwrap();
+    let (out, ok) = runPlum(&[f.to_str().unwrap()]);
+    assert!(ok, "{out}");
+    assert!(out.contains("2 passed, 0 failed"), "{out}");
+}
+#[test]
+fn directoryRunsSumOfOwnTests() {
+    let dir = scratch("dir");
+    std::fs::write(dir.join("a.plum"), TWO).unwrap();
+    std::fs::write(dir.join("b.plum"), "import std/Str\nimport std/Int\n\ntest \"only\"\n  assert 3 == 3\n").unwrap();
+    let (out, ok) = runPlum(&[dir.to_str().unwrap()]);
+    assert!(ok, "{out}");
+    assert!(out.contains("3 passed, 0 failed"), "{out}");
+}
+#[test]
+fn failingImportedTestDoesNotFailImporter() {
+    // Imports resolve relative to the repo root (the lib path), so place the files under it.
+    let root = std::path::Path::new(env!("CARGO_MANIFEST_DIR")).parent().unwrap();
+    let dir = root.join("target").join(format!("scope_imp_{}", std::process::id()));
+    std::fs::create_dir_all(&dir).unwrap();
+    let rel = format!("target/scope_imp_{}/lib", std::process::id());
+    std::fs::write(dir.join("lib.plum"), "module lib\n\nimport std/Int\n\nfun one() -> Int =\n  return 1\n\ntest \"bad\"\n  assert 1 == 2\n").unwrap();
+    let f = dir.join("main.plum");
+    std::fs::write(&f, format!("import std/Int\nimport {rel}\n\ntest \"good\"\n  assert one() == 1\n")).unwrap();
+    let (out, ok) = runPlum(&[f.to_str().unwrap()]);
+    assert!(ok, "{out}");
+    assert!(out.contains("1 passed, 0 failed"), "{out}");
+}

plum-core/src/ast.rs CHANGED Viewed

@@ -57,8 +57,10 @@ impl Source {
     pub fn stampFile(&mut self, file: &str) {
         self.file = file.to_string();
         for item in &mut self.items {
-            if let Item::Fn(f) = item {
+            match item {
-                f.file = file.to_string();
+                Item::Fn(f) => f.file = file.to_string(),
+                Item::Test(t) => t.file = file.to_string(),
+                _ => {}
             }
         }
     }
@@ -225,6 +227,9 @@ pub struct Const {
 /// rest of the block) alongside the ordinary `assert` (fatal trap).
 #[derive(Debug, Clone, PartialEq)]
 pub struct Test {
+    /// Declaring file (stamped by the loader); `plum test` runs a test only
+    /// when this is the file it was asked to test.
+    pub file: String,
     pub name: String,
     pub body: Block,
     /// 1-based source position of the `test` keyword. 0 if unknown.

plum-core/src/parser.rs CHANGED Viewed

@@ -537,6 +537,7 @@ impl<'a> AstParser<'a> {
             .unwrap_or(Block { stmts: vec![] });
         let pos = node.start_position();
         Test {
+            file: String::new(),
             name,
             body,
             line: pos.row + 1,

plum-examples/map_struct_values.plum ADDED Viewed

@@ -0,0 +1,21 @@
+# Map with struct values (moved out of plum-std/Map.plum so MapPoint
+# does not become a global type for every importer of std/Map).
+import std/Map
+import std/Int
+import std/Float
+import std/Str
+struct MapPoint(x: Float, y: Float)
+test "Map[Int, MapPoint] struct values"
+  m := Map[Int, MapPoint]()
+  i := 0
+  while i < 500
+    m.set(i, MapPoint(x: Float(i), y: Float(i) * 2.0))
+    i = i + 1
+  v := m.get(499)!
+  assert v.x == 499.0
+  assert v.y == 998.0
+  m.set(499, MapPoint(x: 1.0, y: 2.0))
+  assert m.get(499)!.y == 2.0
+  assert m.length() == 500

plum-examples/struct_arrays.plum CHANGED Viewed

@@ -35,6 +35,11 @@ fun first(a: Array[T]) -> T =
 fun mk() -> !Array[Vec2] =
   Array[Vec2]().push(Vec2(x: 1.0, y: 2.0))
+struct Px(r: Byte, g: Byte, b: Byte, a: Byte)
+fun mkPx(v: Int) -> Px =
+  Px(r: Byte(v), g: Byte(v + 1), b: Byte(v + 2), a: Byte(255))
 test "List[Vec2] push/get/set round-trips across growth"
   l := List[Vec2]()
   for i := range 100
@@ -187,3 +192,22 @@ test "probe Str leaf"
   a := Array[Named]()
   a = a.push(Named(label: "hi", v: Vec2(x: 1.0, y: 2.0)))
   assert a.get(0).label == "hi"
+test "Byte struct fields: copy, compare, store"
+  p := mkPx(10)
+  q := p
+  assert p == q
+  assert p.r == Byte(10)
+  assert p.a == Byte(255)
+  assert p != mkPx(11)
+  a := Array[Px]().push(p).push(mkPx(20))
+  assert a.get(1).g == Byte(21)
+  assert a.get(0) == q
+  l := List[Px]()
+  for i := range 50
+    l.push(mkPx(i))
+  assert l.get(37)!.b == Byte(39)
+  assert l.get(49)! == mkPx(49)
+test "assert == on structs without toStr"
+  assert Vec2(x: 1.0, y: 2.0) == Vec2(x: 1.0, y: 2.0)

plum-std/Map.plum CHANGED Viewed

@@ -196,8 +196,6 @@ record Map[K, V](index: Array[Int], hashes: Array[Int], keys: Array[K], vals: Ar
     for k, v := range self
       yield v
-struct MapPoint(x: Float, y: Float)
 test "get/set/has round-trip and set replaces an existing key in place"
   m := Map[Str, Int]()
   assert m.has("a") == false
@@ -476,19 +474,6 @@ test "Map[Str, Int] with Buffer-built keys"
   assert m.get("k1999")! == 1999
   assert m.has("k2000") == false
-test "Map[Int, MapPoint] struct values"
-  m := Map[Int, MapPoint]()
-  i := 0
-  while i < 500
-    m.set(i, MapPoint(x: Float(i), y: Float(i) * 2.0))
-    i = i + 1
-  v := m.get(499)!
-  assert v.x == 499.0
-  assert v.y == 998.0
-  m.set(499, MapPoint(x: 1.0, y: 2.0))
-  assert m.get(499)!.y == 2.0
-  assert m.length() == 500
 test "iteration is insertion order, skipping removed entries"
   m := Map[Int, Int]()
   m.set(30, 1)

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

@@ -1514,6 +1514,11 @@ 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.
+/// First part of an assert report string: tells `compileInterpolatedString`
+/// that if any interpolated side has no renderable type (no `toStr`), only the
+/// plain condition-text line (the next part) is emitted.
+const ASSERT_REPORT_MARK: &str = "\u{1}assert-report";
 fn assertFailureMessage(c: &ast::Check, lhs: &ast::Expr, rhs: &ast::Expr) -> ast::Expr {
     let isNullLit = |e: &ast::Expr| matches!(e, ast::Expr::ErrorValue(v) if v.name == ast::NULL_ERR_NAME);
     let plain = match &c.cond {
@@ -1525,6 +1530,7 @@ fn assertFailureMessage(c: &ast::Check, lhs: &ast::Expr, rhs: &ast::Expr) -> ast
     }
     ast::Expr::String(ast::StringExpr {
         parts: vec![
+            ast::StringPart::Text(ASSERT_REPORT_MARK.to_string()),
             ast::StringPart::Text(format!("{}\n", c.text)),
             ast::StringPart::Text("      Expected: ".to_string()),
             ast::StringPart::Interp(rhs.clone()),
@@ -1541,6 +1547,8 @@ fn desugarTestsToFns(source: &ast::Source) -> (ast::Source, Vec<(String, String)
     let mut test_idx = 0usize;
     for item in &source.items {
         match item {
+            // Tests declared in imported files are not run: only the entry file's own.
+            ast::Item::Test(t) if !t.file.is_empty() && t.file != source.file => {}
             ast::Item::Test(t) => {
                 // Leading "__" can never collide with a real Plum-declared name —
                 // `fn_identifier`/`var_identifier` must start with a lowercase letter.
@@ -7278,7 +7286,26 @@ fn compileInterpolatedString(
     state: &mut ModuleState,
 ) -> Result<(), String> {
     let mut first = true;
+    let mut parts: &[ast::StringPart] = &s.parts;
+    if let Some(ast::StringPart::Text(m)) = parts.first() {
+        if m == ASSERT_REPORT_MARK {
+            parts = &parts[1..];
+            let renderable = |e: &ast::Expr| match inferLocalType(e, ctx) {
+                PlumType::TInt | PlumType::TBool | PlumType::TFloat => true,
+                PlumType::TNamed(ref n) if n == ast::STR_TYPE => true,
+                other => plum_checker::nominalName(&other)
+                    .is_some_and(|n| ctx.func_ids.contains_key(&format!("{}::toStr", n))),
+            };
+            let all = parts.iter().all(|p| match p {
+                ast::StringPart::Interp(e) => renderable(e),
+                _ => true,
+            });
+            if !all {
+                parts = &parts[..1];
+            }
+        }
+    }
-    for part in &s.parts {
+    for part in parts {
         match part {
             ast::StringPart::Text(t) => {
                 compileStaticString(t, body, state);

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

@@ -174,6 +174,72 @@ test \"hard assert traps\"
     );
 }
+/// A failing top-level `assert a == b` on values with no `toStr` (struct,
+/// record, tag-less enum, optional) falls back to the plain condition-text
+/// report instead of failing to compile; Int still shows Expected/Actual.
+#[test]
+fn assertReportFallsBackWithoutToStr() {
+    let src = "\
+import std/Str
+import std/Int
+import std/Float
+struct V2(x: Float, y: Float)
+record Rec(a: Int)
+enum Shape = Circle | Square\n\nfun maybe() -> Int? =\n  3
+test \"fb pass\"
+  assert V2(x: 1.0, y: 2.0) == V2(x: 1.0, y: 2.0)
+test \"fb struct\"
+  assert V2(x: 1.0, y: 2.0) == V2(x: 1.0, y: 3.0)
+test \"fb record\"
+  r := Rec(a: 1)
+  assert r.a == 1
+  assert Rec(a: 1) == Rec(a: 2)
+test \"fb enum\"
+  assert Circle == Square
+test \"fb opt\"
+  o := maybe()
+  assert o == null
+test \"fb int\"
+  assert 1 + 1 == 3
+";
+    let dir = std::env::temp_dir().join(format!("plum_assert_fallback_{}", std::process::id()));
+    std::fs::create_dir_all(&dir).unwrap();
+    let path = dir.join("main.plum");
+    std::fs::write(&path, src).unwrap();
+    let source = plum_core::loadAndMerge(&path, &repoRoot()).expect("load");
+    let (bytes, _names) = compileTestSource(&source).expect("test source should compile");
+    let engine = gcEngine();
+    let module = wasmtime::Module::new(&engine, &bytes).expect("module should be loadable");
+    let mut store = wasmtime::Store::new(&engine, ());
+    let mut linker = wasmtime::Linker::new(&engine);
+    linker.define_unknown_imports_as_default_values(&mut store, &module).unwrap();
+    let instance = linker.instantiate(&mut store, &module).expect("instantiate");
+    let mut run = |name: &str| {
+        let f = instance.get_func(&mut store, &format!("test#{name}")).expect("export");
+        let mut results = [wasmtime::Val::I32(0)];
+        f.call(&mut store, &[], &mut results).expect("no trap");
+        readStrResult(&mut store, &results[0])
+    };
+    assert_eq!(run("fb pass"), "");
+    let r = run("fb struct");
+    assert!(r.contains("V2(x: 1.0, y: 2.0) == V2(x: 1.0, y: 3.0)") && !r.contains("Expected"), "got: {r}");
+    let r = run("fb record");
+    assert!(r.contains("Rec(a: 1) == Rec(a: 2)") && !r.contains("Expected"), "got: {r}");
+    let r = run("fb enum");
+    assert!(r.contains("Circle == Square") && !r.contains("Expected"), "got: {r}");
+    let r = run("fb opt");
+    assert!(r.contains("o == null"), "got: {r}");
+    let r = run("fb int");
+    assert!(r.contains("Expected: 3") && r.contains("Actual:   2"), "got: {r}");
+}
 /// Normal `compileSource` (used by `plum run`/`build`/`compile`) must ignore
 /// `test` blocks entirely — no `test#`-prefixed export should ever appear
 /// outside `plum test`.