98bcd99 | plum | pyrossh

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

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

98bcd99 — Peter John 2026-09-04T20:50:43+05:30

chore: fix stale Bool/Str doc comments and test fixture breakage

Files changed (3) hide show

examples/io.plum +6 -3
plum-cli/tests/compile_tests.rs +28 -9
plum-wasm-codegen/src/lib.rs +9 -6

examples/io.plum CHANGED Viewed

@@ -1,9 +1,12 @@
 import std/Str
 import std/Bool
-# `printLn` mirrors `libs/std/os.plum`'s declaration; redeclared locally (rather
+# `printLn` mirrors `libs/std/os.plum`'s declaration; redeclared locally
-# than `import std/os`) so this stays a self-contained example for the
+# (rather than `import std/os`) so this stays the SMALLEST possible example
+# — `import std/os` pulls in every other filesystem extern os.plum declares
-# single-file test harnesses in `plum-checker`/`plum-wasm-codegen`.
+# too, which the Rust-level `ioExampleCompilesAndRunsCorrectly` test (which
+# actually RUNS this module under wasmtime, providing real host imports)
+# would then all need stubs for.
 extern fun printLn(s: Str)
 fun main() =

plum-cli/tests/compile_tests.rs CHANGED Viewed

@@ -11,13 +11,24 @@ fn plumBin() -> std::path::PathBuf {
     path
 }
+/// A fresh subdirectory under the system temp dir, named for this test run
+/// (so parallel test binaries don't collide) — these tests write their own
+/// minimal fixture files here rather than depending on anything checked into
+/// the repo, so they stay self-contained regardless of what `test/` holds.
+fn freshTempDir(name: &str) -> std::path::PathBuf {
+    let dir = std::env::temp_dir().join(format!("plum_{}_{}", name, std::process::id()));
+    std::fs::create_dir_all(&dir).expect("failed to create temp dir");
+    dir
+}
 #[test]
 fn compileSimpleAddProducesWasm() {
+    let dir = freshTempDir("simple_add");
-    let src_path = concat!(env!("CARGO_MANIFEST_DIR"), "/../test/simple_add.plum");
+    let src_path = dir.join("simple_add.plum");
+    std::fs::write(&src_path, "fun add(a: Int, b: Int) -> Int =\n  a + b\n").unwrap();
-    let out_path = std::env::temp_dir().join(format!("plum_test_{}.wasm", std::process::id()));
+    let out_path = dir.join("simple_add.wasm");
-    let out_path_str = out_path.to_str().unwrap();
     let status = Command::new(plumBin())
-        .args(["compile", src_path, "-o", out_path_str])
+        .args(["compile", src_path.to_str().unwrap(), "-o", out_path.to_str().unwrap()])
         .status()
         .expect("failed to run plum compile");
     assert!(status.success(), "plum compile exited with: {}", status);
@@ -27,12 +38,20 @@ fn compileSimpleAddProducesWasm() {
 #[test]
 fn compileWithImportResolvesViaLibPath() {
-    let src_path = concat!(env!("CARGO_MANIFEST_DIR"), "/../test/import_fixtures/main.plum");
+    let dir = freshTempDir("import_fixtures");
-    let lib_path = concat!(env!("CARGO_MANIFEST_DIR"), "/../test/import_fixtures");
+    std::fs::write(dir.join("helper.plum"), "fun helperValue() -> Int =\n  42\n").unwrap();
-    let out_path = std::env::temp_dir().join(format!("plum_test_import_{}.wasm", std::process::id()));
+    let src_path = dir.join("main.plum");
+    std::fs::write(&src_path, "module fixtures\n\nimport helper\n\nfun main() -> Int =\n  helperValue()\n").unwrap();
-    let out_path_str = out_path.to_str().unwrap();
+    let out_path = dir.join("main.wasm");
     let status = Command::new(plumBin())
+        .args([
+            "compile",
+            src_path.to_str().unwrap(),
-        .args(["compile", src_path, "--lib-path", lib_path, "-o", out_path_str])
+            "--lib-path",
+            dir.to_str().unwrap(),
+            "-o",
+            out_path.to_str().unwrap(),
+        ])
         .status()
         .expect("failed to run plum compile");
     assert!(status.success(), "plum compile exited with: {}", status);

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

@@ -614,14 +614,16 @@ pub struct GcTypeRegistry {
     /// Concrete class/struct name -> its one wasm-gc `struct` type index.
     pub class_type_idx: HashMap<String, u32>,
     /// Enum name -> its abstract supertype `struct` type index (every variant
-    /// subtypes this) — includes the built-in `Bool` enum, which has no
+    /// subtypes this) — including `Bool` (`enum Bool = | True | False` in
-    /// `ast::Item::Enum` of its own (`buildGlobalTables` hardcodes its
-    /// `True`/`False` variants directly into `EnumVariants`).
+    /// `libs/std/Bool.plum`), an ordinary enum like any other, present only
+    /// if actually imported.
     pub enum_super_type_idx: HashMap<String, u32>,
     /// Variant name (flat namespace, matching `EnumVariants`) -> its concrete
     /// subtype `struct` type index.
     pub variant_type_idx: HashMap<String, u32>,
-    /// The single shared `array<i8>` type index every `Str` value uses.
+    /// The single shared `array<i8>` type index `[]Byte`/`Buffer`'s own
+    /// `data` field use — NOT `Str`'s own representation (`Str` is an
+    /// ordinary class, `data: Buffer`; see `libs/std/Str.plum`'s header).
     pub byte_array_type_idx: u32,
     /// The single shared closure-value struct type index — `{table_idx: i32, env:
     /// anyref}` — every closure (and zero-capture "trampoline") uses regardless of
@@ -694,8 +696,9 @@ fn plumTypeToGcValtype(t: &PlumType, registry: &GcTypeRegistry) -> ValType {
     }
 }
-/// Builds the wasm-gc type registry for every concrete class/enum in `source`, plus
+/// Builds the wasm-gc type registry for every concrete class/enum actually declared
+/// in `source` (`Bool`/`Str`/etc included, but only if imported — no builtin is
-/// the built-in `Bool` enum and the shared `Str` array type, and declares them all as
+/// hardcoded here), plus the shared raw byte-array type, and declares them all as
 /// ONE `rec` group via `module.addGcTypes` — a single group sidesteps every ordering
 /// question about mutual/self-references (a class field of another class's type, an
 /// enum variant field referencing its own enum, `Node.next: Option[Node]`, etc.),