77038a2 | plum | pyrossh

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

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

77038a2 — Peter John 2026-11-01T20:41:40+05:30

T7: pipeline wiring + e2e

Files changed (3) hide show

plum-checker/src/lib.rs +73 -6
plum-examples/unions.plum +118 -0
plum-wasm-codegen/tests/unions_e2e_test.rs +189 -0

plum-checker/src/lib.rs CHANGED Viewed

@@ -732,7 +732,7 @@ fn unifyErr(t1: &PlumType, t2: &PlumType, ctx: &CheckCtx) -> Result<(), String>
             }
             Ok(())
         }
-        (Some((et, _)), None) => unify(&et, t2, ctx)
+        (Some((et, _)), None) => unions::atTop(|| unify(&et, t2, ctx))
             .map_err(|_| format!("type mismatch: expected {}, found {}", t1, t2)),
         _ => Err(format!(
             "type mismatch: expected {}, found {}: {}",
@@ -1146,7 +1146,7 @@ pub fn typedSource(source: &ast::Source) -> CheckResult<TypedInfo> {
 fn checkSourceFull(source: &ast::Source) -> (CheckResult<()>, TypedInfo) {
     if !source.formLoops {
-        return checkSourceOnce(source);
+        return checkUnions(source, |s| checkSourceOnce(s));
     }
     // `for` loops are lowered by the checker, because how a loop iterates depends
     // on the type of its source. Pass 1 checks the program and lowers each loop as
@@ -1155,12 +1155,63 @@ fn checkSourceFull(source: &ast::Source) -> (CheckResult<()>, TypedInfo) {
     // address) and codegen compiles (`TypedInfo::lowered`).
     plum_core::forms::begin(source);
     let _ = checkSourceOnce(source);
-    let lowered = std::rc::Rc::new(plum_core::forms::finish(source));
+    let lowered = plum_core::forms::finish(source);
-    let (result, mut info) = checkSourceOnce(&lowered);
+    let (result, mut info) = checkUnions(&lowered, |s| checkSourceOnce(s));
+    if info.lowered.is_none() {
+        // No union rewrite happened: `lowered` itself was checked.
-    info.lowered = Some(lowered);
+        info.lowered = Some(std::rc::Rc::new(lowered));
+    }
     (result, info)
 }
+/// Whether the program declares a union enum (a hidden `Enum__Member` variant).
+fn hasUnions(source: &ast::Source) -> bool {
+    source.items.iter().any(|i| match i {
+        ast::Item::Enum(e) => e.variants.iter().any(|v| v.name.starts_with(&format!("{}__", e.name))),
+        _ => false,
+    })
+}
+/// Checks `source` and, when the check recorded union uses, rewrites an owned
+/// copy of exactly the checked program (`plum_core::union_lower::applyPlan`),
+/// checks that again and returns it as `TypedInfo::lowered`. A program with no
+/// union enum is checked as is.
+fn checkUnions(
+    source: &ast::Source,
+    check: impl Fn(&ast::Source) -> (CheckResult<()>, TypedInfo),
+) -> (CheckResult<()>, TypedInfo) {
+    if !hasUnions(source) {
+        return check(source);
+    }
+    // Addresses are recorded against the program that is checked, so check a
+    // clone and mutate that same clone.
+    let mut copy = source.clone();
+    plum_core::unions::beginPlan();
+    let (result, info) = check(&copy);
+    let plan = plum_core::unions::takePlan();
+    let empty = plan.wraps.is_empty()
+        && plan.patterns.is_empty()
+        && plan.narrowings.is_empty()
+        && plan.dispatches.is_empty();
+    let out = if result.is_err() {
+        // Report errors against the original, whose addresses codegen never sees.
+        (result, info)
+    } else if empty {
+        check(source)
+    } else {
+        plum_core::union_lower::applyPlan(&mut copy, &plan);
+        plum_core::unions::beginPlan();
+        let (result, mut info) = check(&copy);
+        plum_core::unions::takePlan();
+        info.lowered = Some(std::rc::Rc::new(copy));
+        (result, info)
+    };
+    // Leave the plan of the checked program in the recorder, so a caller that
+    // began one can inspect what the check found.
+    unions::restorePlan(&plan);
+    out
+}
 fn checkSourceOnce(source: &ast::Source) -> (CheckResult<()>, TypedInfo) {
     RECORD.with(|r| *r.borrow_mut() = Some(HashMap::new()));
     RECORD_BINDS.with(|r| *r.borrow_mut() = Some(Binds::new()));
@@ -2460,6 +2511,8 @@ struct CoverCtor {
     fields: Vec<PlumType>,
     /// A union member: covered by `Name` or `Name(..)` with irrefutable sub-patterns.
     member: bool,
+    /// The hidden variant's full name (`Shape__Circle`), which lowered patterns use.
+    full: String,
 }
 static COVER_WILDCARD: ast::CasePattern = ast::CasePattern::Wildcard;
@@ -2496,6 +2549,7 @@ fn coverCtors(ty: &PlumType, ctx: &CheckCtx) -> Option<(String, Vec<CoverCtor>)>
                     name: n.to_string(),
                     fields: Vec::new(),
                     member: false,
+                    full: n.to_string(),
                 })
                 .collect(),
         )),
@@ -2507,6 +2561,7 @@ fn coverCtors(ty: &PlumType, ctx: &CheckCtx) -> Option<(String, Vec<CoverCtor>)>
                     name: n.clone(),
                     fields: Vec::new(),
                     member: false,
+                    full: n.clone(),
                 })
                 .collect(),
         )),
@@ -2524,9 +2579,10 @@ fn coverCtors(ty: &PlumType, ctx: &CheckCtx) -> Option<(String, Vec<CoverCtor>)>
                 enum_name.to_string(),
                 vs.into_iter()
                     .map(|(k, i)| match unions::memberBase(k, i) {
-                        Some(base) => CoverCtor { name: base, fields: Vec::new(), member: true },
+                        Some(base) => CoverCtor { name: base, fields: variantFields(i, ty), member: true, full: k.to_string() },
                         None => CoverCtor {
                         member: false,
+                        full: k.to_string(),
                         name: k.to_string(),
                         // A discriminant enum's field types are its shared
                         // params, which patterns never destructure.
@@ -2584,6 +2640,16 @@ fn coverRows<'a>(
             if patCatchAll(r[0]) {
                 row.extend(std::iter::repeat(&COVER_WILDCARD).take(c.fields.len()));
             } else if let Some((n, fs)) = patCtor(r[0]) {
+                if c.member && n == c.full {
+                    // A lowered member pattern `Shape__Circle(inner)`.
+                    if fs.len() != 1 {
+                        continue;
+                    }
+                    row.extend(fs.iter());
+                    row.extend(r[1..].iter().copied());
+                    sub.push(row);
+                    continue;
+                }
                 if n != c.name {
                     continue;
                 }
@@ -2591,6 +2657,7 @@ fn coverRows<'a>(
                     if !fs.iter().all(patCatchAll) {
                         continue;
                     }
+                    row.extend(std::iter::repeat(&COVER_WILDCARD).take(c.fields.len()));
                 } else if let ast::CasePattern::Name(_) = r[0] {
                     // Bare `Circle` against a payload variant: tag check only.
                     row.extend(std::iter::repeat(&COVER_WILDCARD).take(c.fields.len()));

plum-examples/unions.plum ADDED Viewed

@@ -0,0 +1,118 @@
+# Union enums: `enum Shape = Circle | Rectangle` lists existing types as members.
+# A member converts to the enum where one is expected, a bare member name in a
+# pattern narrows the subject, and a method every member defines is callable on
+# the enum (auto-dispatch). Members can be structs, records, primitives
+# (`Int | Float | Str`), generic instances (`List[Jv]`) or bare tags.
+module unions
+import std/Str
+import std/Int
+import std/Float
+import std/List
+struct Circle(r: Float) =
+  fun area(self) -> Float = self.r * self.r * 3.0
+  fun toStr(self) -> Str = "circle"
+record Rectangle(w: Float, h: Float) =
+  fun area(self) -> Float = self.w * self.h
+  fun toStr(self) -> Str = "rect"
+enum Shape = Circle | Rectangle
+enum Round = Circle | Oval
+record Oval(a: Float)
+enum Tree[T] = Leaf | Node[T]
+record Leaf(v: Int)
+record Node[T](left: Tree[T], right: Tree[T])
+enum Jv = JvNull | Int | Float | Str | List[Jv]
+fun total(t: Tree[Int]) -> Int =
+  match t
+    Leaf(v) => v
+    Node(l, r) => total(l) + total(r)
+fun leaf(v: Int) -> Tree[Int] = Leaf(v: v)
+fun node(l: Tree[Int], r: Tree[Int]) -> Tree[Int] = Node[Int](left: l, right: r)
+fun describe(j: Jv) -> Str =
+  match j
+    JvNull => "null"
+    Int => "int"
+    Float => "float"
+    Str => "str {j}"
+    List => "list"
+fun areaOf(s: Shape) -> Float = s.area()
+fun roundName(r: Round) -> Str =
+  match r
+    Circle => "circle"
+    Oval => "oval"
+fun make(big: Bool) -> Shape =
+  if big
+    Rectangle(w: 10.0, h: 10.0)
+  else
+    Circle(r: 1.0)
+test "struct_member_copy"
+  s := make(false)
+  if Circle := s
+    c := s
+    c.r = 5.0
+    assert c.r == 5.0
+    assert s.area() == 3.0
+  else
+    assert false
+test "list_of_shapes"
+  xs := List[Shape]()
+  xs.push(Circle(r: 1.0))
+  xs.push(Rectangle(w: 2.0, h: 3.0))
+  sum := 0.0
+  for x := range xs
+    sum = sum + x.area()
+  assert sum == 9.0
+test "push_converts"
+  xs := List[Shape]()
+  xs.push(Circle(r: 2.0))
+  xs.push(Rectangle(w: 1.0, h: 1.0))
+  assert xs.length() == 2
+test "tree_generic"
+  assert total(node(leaf(1), node(leaf(2), leaf(3)))) == 6
+test "json_like_primitives"
+  assert describe(JvNull) == "null"
+  assert describe(7) == "int"
+  assert describe(1.5) == "float"
+  assert describe("hi") == "str hi"
+  js := List[Jv]()
+  js.push(1.0)
+  js.push(7)
+  assert describe(js) == "list"
+test "two_enums_one_type"
+  c := Circle(r: 2.0)
+  assert areaOf(c) == 12.0
+  assert roundName(c) == "circle"
+  assert roundName(Oval(a: 1.0)) == "oval"
+test "if_narrow"
+  s := make(true)
+  if Circle := s
+    assert false
+  else if Rectangle := s
+    assert s.w == 10.0
+test "auto_dispatch"
+  assert make(true).area() == 100.0
+  assert make(false).area() == 3.0
+  assert "{make(false)}" == "circle"

plum-wasm-codegen/tests/unions_e2e_test.rs ADDED Viewed

@@ -0,0 +1,189 @@
+#![allow(non_snake_case)]
+use plum_wasm_codegen::compileSource;
+fn gcEngine() -> wasmtime::Engine {
+    let mut config = wasmtime::Config::new();
+    config.wasm_gc(true);
+    config.wasm_function_references(true);
+    wasmtime::Engine::new(&config).expect("engine with GC config should construct")
+}
+fn repoRoot() -> std::path::PathBuf {
+    std::path::Path::new(env!("CARGO_MANIFEST_DIR")).join("..")
+}
+fn load(name: &str, src: &str) -> Result<plum_core::ast::Source, String> {
+    let dir = std::env::temp_dir().join(format!("plum_unions_{}_{}", name, std::process::id()));
+    std::fs::create_dir_all(&dir).unwrap();
+    let path = dir.join("main.plum");
+    std::fs::write(&path, src).unwrap();
+    let r = plum_core::loadAndMerge(&path, &repoRoot());
+    let _ = std::fs::remove_dir_all(&dir);
+    r.map_err(|e| format!("{e}"))
+}
+/// Compiles `src` through the real pipeline and runs its `main() -> Int`.
+fn runInt(name: &str, src: &str) -> i64 {
+    let source = load(name, src).expect("load");
+    let bytes = compileSource(&source).unwrap_or_else(|e| panic!("compile failed: {e}"));
+    wasmparser::validate(&bytes).expect("valid wasm");
+    let engine = gcEngine();
+    let module = wasmtime::Module::new(&engine, &bytes).unwrap();
+    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).unwrap();
+    let main = instance.get_typed_func::<(), i64>(&mut store, "main").unwrap();
+    main.call(&mut store, ()).unwrap()
+}
+fn checkErrors(name: &str, src: &str) -> Vec<String> {
+    let source = load(name, src).expect("load");
+    match plum_checker::checkSource(&source) {
+        Ok(()) => Vec::new(),
+        Err(e) => e.into_iter().map(|x| x.message).collect(),
+    }
+}
+const DEFS: &str = "\
+import std/Str
+import std/Int
+import std/Float
+import std/List
+struct Circle(r: Float) =
+  fun area(self) -> Float = self.r * self.r * 3.0
+record Rectangle(w: Float, h: Float) =
+  fun area(self) -> Float = self.w * self.h
+enum Shape = Circle | Rectangle
+";
+fn withDefs(body: &str) -> String {
+    format!("{DEFS}{body}")
+}
+#[test]
+fn list_of_shapes() {
+    let src = withDefs(
+        "\
+fun main() -> Int =
+  xs := List[Shape]()
+  xs.push(Circle(r: 1.0))
+  xs.push(Rectangle(w: 2.0, h: 3.0))
+  sum := 0.0
+  for x := range xs
+    sum = sum + x.area()
+  Int(sum)
+",
+    );
+    assert_eq!(runInt("list", &src), 9);
+}
+#[test]
+fn struct_member_copy() {
+    let src = withDefs(
+        "\
+fun make() -> Shape = Circle(r: 1.0)
+fun main() -> Int =
+  s := make()
+  r := 0.0
+  if Circle := s
+    c := s
+    c.r = 5.0
+    r = c.r + s.r
+  Int(r)
+",
+    );
+    assert_eq!(runInt("copy", &src), 6);
+}
+#[test]
+fn narrow_and_dispatch() {
+    let src = withDefs(
+        "\
+fun pick(big: Bool) -> Shape =
+  if big
+    Rectangle(w: 10.0, h: 10.0)
+  else
+    Circle(r: 1.0)
+fun wide(s: Shape) -> Float =
+  match s
+    Circle => 0.0
+    Rectangle => s.w
+fun main() -> Int =
+  a := pick(true)
+  b := pick(false)
+  Int(a.area() + b.area() + wide(a))
+",
+    );
+    assert_eq!(runInt("narrow", &src), 113);
+}
+#[test]
+fn member_into_optional_and_error_unions() {
+    let src = withDefs(
+        "\
+fun opt() -> Shape? =
+  Circle(r: 2.0)
+fun bang() -> !Shape =
+  Rectangle(w: 2.0, h: 2.0)
+fun typed() -> ParseError!Shape =
+  Circle(r: 1.0)
+fun main() -> Int =
+  a := opt() ?: Rectangle(w: 0.0, h: 0.0)
+  b := bang() catch Rectangle(w: 0.0, h: 0.0)
+  c := typed() catch Rectangle(w: 0.0, h: 0.0)
+  Int(a.area() + b.area() + c.area())
+",
+    );
+    let src = src.replace("import std/List\n", "import std/List\n\nerror ParseError = Bad | Worse\n");
+    assert_eq!(runInt("optional", &src), 19);
+}
+#[test]
+fn invariant_list_rejected() {
+    let src = withDefs(
+        "\
+fun take(xs: List[Shape]) -> Int =
+  1
+fun go(cs: List[Circle]) -> Int =
+  take(cs)
+",
+    );
+    assert!(!checkErrors("invariant", &src).is_empty());
+}
+#[test]
+fn variadic_dispatch_is_an_error() {
+    let src = "\
+import std/Str
+import std/Int
+import std/Float
+record Pa(v: Int) =
+  fun sum(self, xs: ...Int) -> Int = self.v
+record Pb(v: Int) =
+  fun sum(self, xs: ...Int) -> Int = self.v
+enum Pair = Pa | Pb
+fun go(p: Pair) -> Int =
+  p.sum(1, 2)
+";
+    let errs = checkErrors("variadic", src);
+    assert!(
+        errs.iter().any(|e| e.contains("Pair.sum: auto-dispatch can't forward a variadic parameter; define sum on Pair")),
+        "{errs:?}"
+    );
+}