0dc0e16 | plum | pyrossh

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

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

0dc0e16 — Peter John 2026-10-27T00:48:57+05:30

fix: error sets don't split GC types; match arms must be in the error set

Files changed (4) hide show

plum-checker/src/lib.rs +14 -2
plum-checker/tests/error_union_tests.rs +57 -0
plum-wasm-codegen/src/lib.rs +46 -27
plum-wasm-codegen/tests/codegen_tests.rs +49 -0

plum-checker/src/lib.rs CHANGED Viewed

@@ -591,6 +591,8 @@ pub fn plumTypeFromName(name: &str) -> PlumType {
 /// Reserved `TypeEnv` key holding the enclosing function's declared return type.
 const RETURN_KEY: &str = "$return";
+/// Reserved env key set (to a `TNamed(fn name)`) while checking a `fun*` body.
+const STAR_KEY: &str = "$star";
 /// `TypeEnv` key prefix marking a name as a top-level function (a local of the
 /// same name shadows it instead of being a redeclaration).
 const GLOBAL_KEY: &str = "$global:";
@@ -1867,6 +1869,9 @@ fn checkFn(
         .unwrap_or(PlumType::TUnit);
     // Reserved env key read by `?` (see `inferExpr`'s `Try` arm); closures remove it.
     env.insert(RETURN_KEY.to_string(), TypeScheme::mono(declared_ret.clone()));
+    if f.is_star {
+        env.insert(STAR_KEY.to_string(), TypeScheme::mono(PlumType::TNamed(f.name.clone())));
+    }
     match &f.body {
         ast::FnBody::Expr(e) => match inferExprWith(e, &env, ctx, Some(&declared_ret)) {
@@ -2739,10 +2744,11 @@ fn checkPattern(
         let is_upper = |n: &str| n.chars().next().is_some_and(|c| c.is_uppercase());
         if let ast::CasePattern::Name(n) = pat {
             if is_upper(n) {
-                return if names.is_empty() || names.contains(n) {
+                return if names.contains(n) {
                     Ok(())
                 } else {
+                    let set: Vec<&str> = names.iter().map(|s| s.as_str()).collect();
-                    Err(format!("error '{}' is not part of {}", n, subject_ty))
+                    Err(format!("'{}' is not in the error set [{}]", n, set.join(", ")))
                 };
             }
         }
@@ -3535,6 +3541,12 @@ fn inferExprInner(
         ast::Expr::Paren(inner) => inferExprWith(inner, env, ctx, successExpected(expected)),
         // `expr?`: the operand's error set must fit the enclosing fn's set.
         ast::Expr::Try(inner) => {
+            if let (Some(star), true) = (env.get(STAR_KEY), env.contains_key(RETURN_KEY)) {
+                return Err(format!(
+                    "'?' inside fun* '{}': propagation isn't supported in iterators; handle the error with catch",
+                    star.body.to_string().trim_start_matches("__star_")
+                ));
+            }
             let inner_ty = resolveRecorded(&inferExpr(inner, env, ctx)?);
             let Some((success, iset)) = errView(&inner_ty) else {
                 return Err(format!("'?' requires an error union (!T or T?), found {}", inner_ty));

plum-checker/tests/error_union_tests.rs CHANGED Viewed

@@ -398,3 +398,60 @@ fun f() -> Int =
 ";
     assert!(check(bad).unwrap_err().contains("declare `-> !T`"));
 }
+#[test]
+fn match_arm_names_must_be_in_the_error_set() {
+    let base = "\
+fun f(n: Int) -> !Int =
+  if n < 0
+    fail Negative
+  if n > 9
+    fail TooBig
+  n
+";
+    let bad = format!("{}{}", base, "\
+fun g(n: Int) -> Int =
+  f(n) catch e
+    match e
+      Negative => 0
+      TooBig => 9
+      Bogus => 1
+");
+    let msg = check(&bad).unwrap_err();
+    assert!(msg.contains("'Bogus' is not in the error set [Negative, TooBig]"), "{}", msg);
+    // An empty set (a union that can't fail) accepts no arm names either.
+    let empty = "\
+fun safe(n: Int) -> !Int =
+  n
+fun g(n: Int) -> Int =
+  safe(n) catch e
+    match e
+      Anything => 0
+      _ => 1
+";
+    let msg = check(empty).unwrap_err();
+    assert!(msg.contains("'Anything' is not in the error set []"), "{}", msg);
+}
+#[test]
+fn try_inside_star_fn_has_a_specific_message() {
+    let src = "\
+fun f(n: Int) -> !Int =
+  if n < 0
+    fail Negative
+  n
+fun* gen(n: Int) *Int =
+  x := f(n)?
+  yield x
+";
+    let msg = check(src).unwrap_err();
+    assert!(
+        msg.contains("'?' inside fun* 'gen': propagation isn't supported in iterators; handle the error with catch"),
+        "{}",
+        msg
+    );
+    assert!(!msg.contains("declare `-> !T`"), "{}", msg);
+}

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

@@ -870,10 +870,27 @@ fn valueHelper(key: &str) -> u32 {
     VALUE_HELPERS.with(|h| *h.borrow().get(key).unwrap_or_else(|| panic!("internal codegen error: missing helper {key}")))
 }
+/// Error sets don't change a type's runtime shape (a `!T` is `(T leaves, code)`
+/// whatever its set), so GC-type registry keys and instantiation keys erase them:
+/// `List[!Int [A]]` and `List[!Int]` are one wasm type family. The checker keeps
+/// the precise sets; only codegen identity canonicalizes.
+fn canonTy(ty: &PlumType) -> PlumType {
+    use PlumType::*;
+    match ty {
+        // `T?` over a reference type is a nullable ref (a different shape): keep it.
+        TErr(t, set) if nullableErr(ty).is_some() => TErr(Box::new(canonTy(t)), set.clone()),
+        TErr(t, _) => TErr(Box::new(canonTy(t)), plum_checker::types::ErrSet::Inferred(String::new())),
+        TApp(n, args) => TApp(n.clone(), args.iter().map(canonTy).collect()),
+        TFun(ps, r) => TFun(ps.iter().map(canonTy).collect(), Box::new(canonTy(r))),
+        TVariadic(i) => TVariadic(Box::new(canonTy(i))),
+        _ => ty.clone(),
+    }
+}
 fn unboxKey(ty: &PlumType) -> String {
     match ty {
         PlumType::TNamed(n) => format!("unbox:{n}"),
-        PlumType::TErr(t, _) => format!("unbox:!{t}"),
+        PlumType::TErr(t, _) => format!("unbox:!{}", canonTy(t)),
         _ => unreachable!("emitUnbox on non-value type"),
     }
 }
@@ -959,7 +976,7 @@ impl GcTypeRegistry {
                 .get(n)
                 .or_else(|| self.class_type_idx.get(n))
                 .copied(),
-            PlumType::TApp(..) => self.app_super.get(ty).copied(),
+            PlumType::TApp(..) => self.app_super.get(&canonTy(ty)).copied(),
             _ => None,
         }
     }
@@ -967,15 +984,15 @@ impl GcTypeRegistry {
     pub fn classIdx(&self, ty: &PlumType) -> Option<u32> {
         match ty {
             PlumType::TNamed(n) => self.class_type_idx.get(n).copied(),
-            PlumType::TApp(..) => self.app_class.get(ty).copied(),
+            PlumType::TApp(..) => self.app_class.get(&canonTy(ty)).copied(),
-            PlumType::TErr(t, _) => self.err_box.get(&**t).copied(),
+            PlumType::TErr(t, _) => self.err_box.get(&canonTy(t)).copied(),
             _ => None,
         }
     }
     /// Struct index of variant `vname` of enum type `ty`.
     pub fn variantIdx(&self, ty: &PlumType, vname: &str) -> Option<u32> {
         match ty {
-            PlumType::TApp(..) => self.app_variant.get(&(ty.clone(), vname.to_string())).copied(),
+            PlumType::TApp(..) => self.app_variant.get(&(canonTy(ty), vname.to_string())).copied(),
             _ => self.variant_type_idx.get(vname).copied(),
         }
     }
@@ -1025,7 +1042,7 @@ fn plumTypeToGcValtype(t: &PlumType, registry: &GcTypeRegistry) -> ValType {
         // An error value (`catch e`) is its i32 code.
         PlumType::TErrName(_) => ValType::I32,
         // A heap slot holds a `!T` as its box struct `{T leaves..., code}`.
-        PlumType::TErr(inner, _) => match registry.err_box.get(&**inner) {
+        PlumType::TErr(inner, _) => match registry.err_box.get(&canonTy(inner)) {
             Some(idx) => gcRef(*idx),
             None => ValType::Ref(RefType::ANYREF),
         },
@@ -1742,6 +1759,8 @@ impl<'a> TypeCollector<'a> {
         if hasFreeTy(t) {
             return;
         }
+        let canon = canonTy(t);
+        let t = &canon;
         match t {
             PlumType::TApp(n, args) => {
                 for a in args {
@@ -1905,6 +1924,25 @@ fn compileSourceInner(
     }
     // ---- collect the concrete generic types the program uses ----
+    VALUE_ENUMS.with(|v| {
+        let mut v = v.borrow_mut();
+        v.clear();
+        for item in &source.items {
+            if let ast::Item::Enum(e) = item {
+                if e.isValue && e.variants.len() == 1 && e.generics.is_empty() {
+                    let var = &e.variants[0];
+                    v.insert(
+                        e.name.clone(),
+                        var.field_names
+                            .iter()
+                            .cloned()
+                            .zip(var.fields.iter().map(plum_checker::plumTypeFromAst))
+                            .collect(),
+                    );
+                }
+            }
+        }
+    });
     let mut tc = TypeCollector {
         apps: Vec::new(),
         seen: HashSet::new(),
@@ -1957,25 +1995,6 @@ fn compileSourceInner(
     let mut module = WasmModule::new();
-    VALUE_ENUMS.with(|v| {
-        let mut v = v.borrow_mut();
-        v.clear();
-        for item in &source.items {
-            if let ast::Item::Enum(e) = item {
-                if e.isValue && e.variants.len() == 1 && e.generics.is_empty() {
-                    let var = &e.variants[0];
-                    v.insert(
-                        e.name.clone(),
-                        var.field_names
-                            .iter()
-                            .cloned()
-                            .zip(var.fields.iter().map(plum_checker::plumTypeFromAst))
-                            .collect(),
-                    );
-                }
-            }
-        }
-    });
     VALUE_BLOCK_TYPES.with(|m| m.borrow_mut().clear());
     VALUE_HELPERS.with(|m| m.borrow_mut().clear());
@@ -6701,7 +6720,7 @@ fn compileExprCore(
             match ctx.enum_variants.get(n) {
                 Some(info) if info.field_types.is_empty() => {
                     let ety = enumTypeOfExpr(expr, info, ctx);
-                    let global_idx = *ctx.singleton_globals.get(&(ety, n.clone()))
+                    let global_idx = *ctx.singleton_globals.get(&(canonTy(&ety), n.clone()))
                     .unwrap_or_else(|| panic!("internal codegen error: payload-free variant '{}' has no singleton global", n));
                     Instruction::GlobalGet(global_idx).encode(body);
                 }
@@ -7339,7 +7358,7 @@ fn compileVariantConstruction(
     if info.field_types.is_empty() {
         // Pre-allocated singleton (this migration plan's Decision 2) — not a fresh
         // struct.new per reference.
-        let global_idx = *ctx.singleton_globals.get(&(ety.clone(), call.name.clone())).ok_or_else(|| {
+        let global_idx = *ctx.singleton_globals.get(&(canonTy(&ety), call.name.clone())).ok_or_else(|| {
             format!(
                 "codegen: payload-free variant '{}' has no singleton global",
                 call.name

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

@@ -2750,3 +2750,52 @@ fun main() -> Int =
 ";
     assert_eq!(runWithCrash("nullvalue", src).0.unwrap(), 400 + 50 + 9);
 }
+#[test]
+fn list_of_error_unions_across_sets_valid_wasm() {
+    let src = "\
+import std/Str
+import std/Number
+import std/List
+fun chk(n: Int) -> !Int =
+  if n < 0
+    fail Neg
+  n
+fun total(xs: List[!Int [Neg]]) -> Int =
+  a := xs.at(0) catch 0
+  b := xs.at(1) catch 100
+  a + b
+fun main() -> Int =
+  xs := List(chk(4))
+  xs.push(chk(-1))
+  total(xs)
+";
+    assert_eq!(runWithCrash("listsets", src).0.unwrap(), 104);
+}
+#[test]
+fn map_value_error_union_across_sets() {
+    let src = "\
+import std/Str
+import std/Number
+import std/Map
+fun chk(n: Int) -> !Int =
+  if n < 0
+    fail Neg
+  n
+fun look(m: Map[Int, !Int [Neg]]) -> Int =
+  v := m.get(1) catch chk(-1)
+  v catch 0
+fun main() -> Int =
+  m := Map[Int, !Int]()
+  m.set(1, chk(7))
+  look(m)
+";
+    assert_eq!(runWithCrash("mapsets", src).0.unwrap(), 7);
+}