a8f2482 | plum | pyrossh

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

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

a8f2482 — Peter John 2026-10-26T23:46:13+05:30

feat(codegen): Zig-style error unions: !T multi-value lowering, fail/?/!/catch/?., boxed heap slots, nullable interop

Files changed (3) hide show

plum-checker/src/lib.rs +43 -0
plum-wasm-codegen/src/lib.rs +582 -11
plum-wasm-codegen/tests/codegen_tests.rs +328 -0

plum-checker/src/lib.rs CHANGED Viewed

@@ -529,8 +529,51 @@ fn recordBind(name: &str, ty: &PlumType) {
 pub const TRY_WRAP_OK: usize = 1;
 pub const TRY_WRAP_ERR: usize = 2;
 pub const TRY_RELAYOUT: usize = 3;
+/// Error-union coercions (expected `!T`): `+4` a plain `T` becomes the success value,
+/// `+5` a nullable `Try` becomes `!T`; `+6` (expected a nullable `Try`) a `!T` becomes null/value.
+pub const ERR_WRAP: usize = 4;
+pub const ERR_FROM_NULLABLE: usize = 5;
+pub const ERR_TO_NULLABLE: usize = 6;
+fn recordErrCoercion(expr: &ast::Expr, actual: &PlumType, expected: &PlumType, ctx: &CheckCtx) -> bool {
+    let kind = match (expected, actual) {
+        (_, PlumType::TVar(_) | PlumType::TParam(_)) => return false,
+        (PlumType::TErr(inner, _), a) => {
+            if matches!(a, PlumType::TErr(..)) {
+                None
+            } else if nullableTryPayload(a).is_some() {
+                Some(ERR_FROM_NULLABLE)
+            } else if isTryType(a) {
+                None
+            } else if unify(inner, a, ctx).is_ok() {
+                Some(ERR_WRAP)
+            } else {
+                None
+            }
+        }
+        (e, PlumType::TErr(..)) if nullableTryPayload(e).is_some() => Some(ERR_TO_NULLABLE),
+        _ => return false,
+    };
+    let ptr = expr as *const ast::Expr as usize;
+    RECORD.with(|r| {
+        if let Some(m) = r.borrow_mut().as_mut() {
+            for k in [TRY_WRAP_OK, TRY_WRAP_ERR, TRY_RELAYOUT, ERR_WRAP, ERR_FROM_NULLABLE, ERR_TO_NULLABLE] {
+                m.remove(&(ptr + k));
+            }
+            if let Some(k) = kind {
+                m.insert(ptr + k, expected.clone());
+            }
+        }
+    });
+    true
+}
 fn recordTryCoercion(expr: &ast::Expr, actual: &PlumType, expected: Option<&PlumType>, ctx: &CheckCtx) {
+    if let Some(e) = expected {
+        if recordErrCoercion(expr, actual, e, ctx) {
+            return;
+        }
+    }
     let Some(exp @ PlumType::TApp(n, args)) = expected else {
         return;
     };

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

@@ -584,8 +584,9 @@ fn sourceUsesCrash(dbg: &str) -> bool {
                 }
                 i += 1;
             }
+            b'C' | b'B'
-            b'C' if dbg[i..].starts_with("Crash(")
+                if (dbg[i..].starts_with("Crash(") || dbg[i..].starts_with("Bang("))
-                && (i == 0 || matches!(b[i - 1], b'[' | b'(' | b' ')) =>
+                    && (i == 0 || matches!(b[i - 1], b'[' | b'(' | b' ')) =>
             {
                 return true
             }
@@ -595,6 +596,18 @@ fn sourceUsesCrash(dbg: &str) -> bool {
     false
 }
+/// The closure literal of an error-union `a.andThen(|x| ...)` (what `a?.b` desugars to).
+fn andThenClosure<'e>(a: &'e ast::AttributeExpr, call: &'e ast::FnCall) -> Option<&'e ast::Closure> {
+    let _ = a;
+    if call.name != "andThen" || call.args.len() != 1 {
+        return None;
+    }
+    match argExprOf(&call.args[0]) {
+        ast::Expr::Closure(cl) if cl.params.len() == 1 => Some(cl),
+        _ => None,
+    }
+}
 fn tagId(name: &str) -> i32 {
     CURRENT_TAG_IDS.with(|c| {
         let mut m = c.borrow_mut();
@@ -796,11 +809,59 @@ thread_local! {
     static VALUE_BLOCK_TYPES: RefCell<HashMap<u32, u32>> = RefCell::new(HashMap::new());
     /// Helper function indices: `unbox:Vec2`, `eq:Vec2`, `proj:Vec2.x`.
     static VALUE_HELPERS: RefCell<HashMap<String, u32>> = RefCell::new(HashMap::new());
+    /// Error-union facts from the checker for the program being compiled.
+    static ERR_INFO: RefCell<ErrInfo> = RefCell::new(ErrInfo::default());
+}
+#[derive(Default)]
+struct ErrInfo {
+    file: String,
+    sites: HashMap<usize, plum_checker::ErrSite>,
+    codes: std::collections::BTreeMap<String, i32>,
+}
+fn errSite(expr: &ast::Expr) -> Option<plum_checker::ErrSite> {
+    ERR_INFO.with(|e| e.borrow().sites.get(&(expr as *const ast::Expr as usize)).cloned())
+}
+fn errCode(name: &str) -> Result<i32, String> {
+    ERR_INFO
+        .with(|e| e.borrow().codes.get(name).copied())
+        .ok_or_else(|| format!("internal codegen error: no error code for '{}'", name))
+}
+/// Scratch local (named, reserved by `Collector`) holding an error-union operand.
+fn errScratch(expr: &ast::Expr) -> String {
+    format!("errtmp#{}", expr as *const ast::Expr as usize)
+}
+fn errScratchKey(expr: &ast::Expr, kind: usize) -> String {
+    format!("errtmp#{}", expr as *const ast::Expr as usize + kind)
+}
+/// The wasm leaf zero for an "undefined" value slot.
+fn emitZeroLeaf(vt: ValType, body: &mut Vec<u8>) {
+    pushSelfPlaceholder(vt, body);
+}
+fn emitZeros(ty: &PlumType, body: &mut Vec<u8>) {
+    for vt in withGcTypes(|g| flatValtypes(ty, g)) {
+        emitZeroLeaf(vt, body);
+    }
 }
 fn valueFieldsOf(ty: &PlumType) -> Option<Vec<(String, PlumType)>> {
     match ty {
         PlumType::TNamed(n) => VALUE_ENUMS.with(|v| v.borrow().get(n).cloned()),
+        // `!T` is `(T leaves..., code: i32)`; a Unit success has only the code.
+        PlumType::TErr(t, _) => {
+            let mut f = Vec::new();
+            if !matches!(**t, PlumType::TUnit) {
+                f.push(("$value".to_string(), (**t).clone()));
+            }
+            f.push(("$code".to_string(), PlumType::TBool));
+            Some(f)
+        }
         _ => None,
     }
 }
@@ -872,10 +933,17 @@ fn valueHelper(key: &str) -> u32 {
     VALUE_HELPERS.with(|h| *h.borrow().get(key).unwrap_or_else(|| panic!("internal codegen error: missing helper {key}")))
 }
+fn unboxKey(ty: &PlumType) -> String {
+    match ty {
+        PlumType::TNamed(n) => format!("unbox:{n}"),
+        PlumType::TErr(t, _) => format!("unbox:!{t}"),
+        _ => unreachable!("emitUnbox on non-value type"),
+    }
+}
 /// A heap box reference on the stack -> flat leaves.
 fn emitUnbox(ty: &PlumType, body: &mut Vec<u8>) {
-    let PlumType::TNamed(n) = ty else { unreachable!("emitUnbox on non-value type") };
-    Instruction::Call(valueHelper(&format!("unbox:{n}"))).encode(body);
+    Instruction::Call(valueHelper(&unboxKey(ty))).encode(body);
 }
 /// If the value just produced for a heap slot of type `ty` is a value enum, flatten it.
@@ -949,6 +1017,8 @@ pub struct GcTypeRegistry {
     pub tag_ref_idx: u32,
     /// Helper `(arr: array<i8>, len: i64) -> Str` building `Str{Buffer{arr,len}}`; `None` when the program has no `Str`/`Buffer`.
     pub mk_str_fn: Option<u32>,
+    /// `!T` (keyed by `T`) -> its heap box struct `{leaves of T..., code: i32}`.
+    pub err_box: HashMap<PlumType, u32>,
 }
 impl GcTypeRegistry {
@@ -969,6 +1039,7 @@ impl GcTypeRegistry {
         match ty {
             PlumType::TNamed(n) => self.class_type_idx.get(n).copied(),
             PlumType::TApp(..) => self.app_class.get(ty).copied(),
+            PlumType::TErr(t, _) => self.err_box.get(&**t).copied(),
             _ => None,
         }
     }
@@ -1024,7 +1095,10 @@ fn plumTypeToGcValtype(t: &PlumType, registry: &GcTypeRegistry) -> ValType {
         },
         PlumType::TTags(_) => gcRef(registry.tag_type_idx),
         // Lowered by the error-union codegen (E3); until then, as its success type.
-        PlumType::TErr(inner, _) => plumTypeToGcValtype(inner, registry),
+        PlumType::TErr(inner, _) => match registry.err_box.get(&**inner) {
+            Some(idx) => gcRef(*idx),
+            None => ValType::Ref(RefType::ANYREF),
+        },
         PlumType::TFun(_, _) | PlumType::TVariadic(_) => ValType::Ref(RefType::ANYREF),
         PlumType::TParam(_) => ValType::Ref(RefType::ANYREF),
         PlumType::TVar(_) | PlumType::TUnit => ValType::I64,
@@ -1063,6 +1137,7 @@ fn buildGcTypeRegistry(
     enum_variants: &EnumVariants,
     enum_params: &EnumParams,
     apps: &[PlumType],
+    errs: &[PlumType],
 ) -> GcTypeRegistry {
     enum Slot {
         Str,
@@ -1074,6 +1149,7 @@ fn buildGcTypeRegistry(
         TagF64,
         TagI32,
         TagRef,
+        ErrBox(PlumType),
     }
     let mut slots: Vec<Slot> = vec![Slot::Str];
     let mut reg = GcTypeRegistry {
@@ -1095,6 +1171,7 @@ fn buildGcTypeRegistry(
         tag_i32_idx: 0,
         tag_ref_idx: 0,
         mk_str_fn: None,
+        err_box: HashMap::new(),
     };
     let mut enum_decls: HashMap<String, &ast::Enum> = HashMap::new();
     let mut instances: Vec<PlumType> = Vec::new();
@@ -1164,6 +1241,13 @@ fn buildGcTypeRegistry(
     reg.tag_ref_idx = slots.len() as u32;
     slots.push(Slot::TagRef);
+    for t in errs {
+        if !reg.err_box.contains_key(t) {
+            reg.err_box.insert(t.clone(), slots.len() as u32);
+            slots.push(Slot::ErrBox(t.clone()));
+        }
+    }
     // Native arrays: one wasm array type per distinct element representation,
     // innermost (least nested) element types first.
     arrays.sort_by_key(arrayDepth);
@@ -1259,6 +1343,23 @@ fn buildGcTypeRegistry(
                     },
                 }
             }
+            Slot::ErrBox(t) => {
+                let ty = PlumType::TErr(Box::new(t.clone()), plum_checker::types::ErrSet::Inferred(String::new()));
+                SubType {
+                    is_final: true,
+                    supertype_idx: None,
+                    composite_type: CompositeType {
+                        inner: CompositeInnerType::Struct(StructType {
+                            fields: flatValtypes(&ty, &reg)
+                                .into_iter()
+                                .map(|vt| FieldType { element_type: StorageType::Val(vt), mutable: true })
+                                .collect::<Vec<_>>()
+                                .into(),
+                        }),
+                        shared: false,
+                    },
+                }
+            }
             Slot::Tag => SubType {
                 is_final: false,
                 supertype_idx: None,
@@ -1763,6 +1864,7 @@ struct TypeCollector<'a> {
     funs_seen: HashSet<PlumType>,
     variadics: Vec<PlumType>,
     variadics_seen: HashSet<PlumType>,
+    errs: Vec<PlumType>,
     enum_variants: &'a EnumVariants,
     enum_params: &'a EnumParams,
     eg: &'a EnumGenerics,
@@ -1822,6 +1924,12 @@ impl<'a> TypeCollector<'a> {
                     self.visit(v);
                 }
             }
+            PlumType::TErr(inner, _) => {
+                self.visit(inner);
+                if !self.errs.contains(inner) {
+                    self.errs.push((**inner).clone());
+                }
+            }
             _ => {}
         }
     }
@@ -1847,8 +1955,11 @@ fn compileSourceInner(
         call_inst,
         op_calls,
         lowered,
+        err_sites,
+        error_codes,
         ..
     } = typed;
+    ERR_INFO.with(|e| *e.borrow_mut() = ErrInfo { file: source.module.as_ref().map(|m| m.name.clone()).unwrap_or_else(|| "main.plum".to_string()), sites: err_sites, codes: error_codes });
     // The types are keyed by the addresses of the checker's lowered program.
     let source: &ast::Source = lowered.as_deref().unwrap_or(source);
     // Per-instantiation expression types, split out by instantiation id.
@@ -1939,6 +2050,7 @@ fn compileSourceInner(
         funs_seen: HashSet::new(),
         variadics: Vec::new(),
         variadics_seen: HashSet::new(),
+        errs: Vec::new(),
         enum_variants: &enum_variants,
         enum_params: &enum_params,
         eg: &eg,
@@ -2041,7 +2153,7 @@ fn compileSourceInner(
     VALUE_BLOCK_TYPES.with(|m| m.borrow_mut().clear());
     VALUE_HELPERS.with(|m| m.borrow_mut().clear());
-    let mut gc_types = buildGcTypeRegistry(&mut module, source, &enum_variants, &enum_params, &tc.apps);
+    let mut gc_types = buildGcTypeRegistry(&mut module, source, &enum_variants, &enum_params, &tc.apps, &tc.errs);
     CURRENT_GC_TYPES.with(|c| *c.borrow_mut() = Some(gc_types.clone()));
     let value_names: Vec<String> = {
         let mut v: Vec<String> = VALUE_ENUMS.with(|v| v.borrow().keys().cloned().collect());
@@ -2055,6 +2167,14 @@ fn compileSourceInner(
         let bt = module.addType(&[], &leaves);
         VALUE_BLOCK_TYPES.with(|m| m.borrow_mut().insert(box_idx, bt));
     }
+    let mut err_boxes: Vec<(PlumType, u32)> = gc_types.err_box.iter().map(|(t, i)| (t.clone(), *i)).collect();
+    err_boxes.sort_by_key(|(_, i)| *i);
+    for (t, box_idx) in &err_boxes {
+        let ty = PlumType::TErr(Box::new(t.clone()), plum_checker::types::ErrSet::Inferred(String::new()));
+        let leaves = flatValtypes(&ty, &gc_types);
+        let bt = module.addType(&[], &leaves);
+        VALUE_BLOCK_TYPES.with(|m| m.borrow_mut().insert(*box_idx, bt));
+    }
     CURRENT_CONSTS.with(|c| {
         let mut consts = c.borrow_mut();
@@ -2105,6 +2225,9 @@ fn compileSourceInner(
                 continue;
             }
             known_fns.insert(f.name.clone());
+            if matches!(f.returns.as_ref().map(plum_checker::plumTypeFromAstG), Some(PlumType::TErr(..))) {
+                return Err(format!("extern fun '{}' cannot return an error union", f.name));
+            }
             let sig = unitFuncSig(f, &Subst::new(), &eg, &gc_types);
             let param_types = sig.params.clone();
             let ret = sig.ret.clone();
@@ -2250,6 +2373,21 @@ fn compileSourceInner(
         }
     }
+    for (t, box_idx) in &err_boxes {
+        let ty = PlumType::TErr(Box::new(t.clone()), plum_checker::types::ErrSet::Inferred(String::new()));
+        let leaves = flatValtypes(&ty, &gc_types);
+        let mut b = vec![0u8];
+        for i in 0..leaves.len() as u32 {
+            Instruction::LocalGet(0).encode(&mut b);
+            Instruction::StructGet { struct_type_index: *box_idx, field_index: i }.encode(&mut b);
+        }
+        Instruction::End.encode(&mut b);
+        let ft = module.addType(&[gcRef(*box_idx)], &leaves);
+        let f = module.addFunction(ft, &b);
+        module.nameFunction(f, &format!("unbox.!{t}"));
+        VALUE_HELPERS.with(|h| h.borrow_mut().insert(unboxKey(&ty), f));
+    }
     // Pre-allocate one instance of every payload-free variant of every enum instance.
     let mut singleton_globals: HashMap<(PlumType, String), u32> = HashMap::new();
     let mut start_body = Vec::new();
@@ -3450,7 +3588,15 @@ impl<'a, 't> ClosureWalker<'a, 't> {
     fn walkExpr(&mut self, expr: &'a ast::Expr) {
         match expr {
-            ast::Expr::Yield(_) | ast::Expr::Bang(_) | ast::Expr::Catch(_) | ast::Expr::Fail(_) => {}
+            ast::Expr::Yield(_) | ast::Expr::Fail(_) => {}
+            ast::Expr::Bang(b) => self.walkExpr(&b.value),
+            ast::Expr::Catch(c) => {
+                self.walkExpr(&c.value);
+                match &c.handler {
+                    ast::CatchHandler::Default(d) => self.walkExpr(d),
+                    ast::CatchHandler::Block { body, .. } => self.walkBlock(body),
+                }
+            }
             ast::Expr::Closure(cl) => self.recordClosure(expr, cl),
             ast::Expr::Binary(b) => {
                 self.walkExpr(&b.left);
@@ -3733,6 +3879,19 @@ fn fvCollectRefsExpr(
         }
         ast::Expr::Not(inner) => fvCollectRefsExpr(inner, bound, seen, free, env, fn_decls, fn_locals),
         ast::Expr::Try(inner) => fvCollectRefsExpr(inner, bound, seen, free, env, fn_decls, fn_locals),
+        ast::Expr::Bang(b) => fvCollectRefsExpr(&b.value, bound, seen, free, env, fn_decls, fn_locals),
+        ast::Expr::Catch(c) => {
+            fvCollectRefsExpr(&c.value, bound, seen, free, env, fn_decls, fn_locals);
+            match &c.handler {
+                ast::CatchHandler::Default(d) => fvCollectRefsExpr(d, bound, seen, free, env, fn_decls, fn_locals),
+                ast::CatchHandler::Block { binder, body } => {
+                    let mut inner_bound = bound.clone();
+                    inner_bound.insert(binder.clone());
+                    fvCollectBoundBlock(body, &mut inner_bound);
+                    fvCollectRefsBlock(body, &inner_bound, seen, free, env, fn_decls, fn_locals);
+                }
+            }
+        }
         ast::Expr::Unary(u) => fvCollectRefsExpr(&u.operand, bound, seen, free, env, fn_decls, fn_locals),
         ast::Expr::Paren(inner) => fvCollectRefsExpr(inner, bound, seen, free, env, fn_decls, fn_locals),
         ast::Expr::Ternary(t) => {
@@ -3991,8 +4150,42 @@ impl<'a> Collector<'a> {
                 self.nested_class_scratch_types.push((from, String::new()));
             }
         }
+        for k in [plum_checker::ERR_FROM_NULLABLE, plum_checker::ERR_TO_NULLABLE] {
+            if let Some(exp) = self.types.get(&(ptr + k)) {
+                let ty = if k == plum_checker::ERR_FROM_NULLABLE { self.ty(expr) } else { self.ty(expr) };
+                let _ = exp;
+                let slot_ty = if k == plum_checker::ERR_FROM_NULLABLE {
+                    // the nullable ref is parked in a ref local
+                    match plum_checker::nullableTryPayload(&ty) {
+                        Some(p) => p.clone(),
+                        None => ty,
+                    }
+                } else {
+                    ty
+                };
+                self.bind(&errScratchKey(expr, k), slot_ty);
+            }
+        }
         match expr {
-            ast::Expr::Yield(_) | ast::Expr::Bang(_) | ast::Expr::Catch(_) | ast::Expr::Fail(_) => {}
+            ast::Expr::Yield(_) | ast::Expr::Fail(_) => {}
+            ast::Expr::Bang(b) => {
+                let ty = self.ty(&b.value);
+                self.bind(&errScratch(expr), ty);
+                self.walkExpr(&b.value);
+            }
+            ast::Expr::Catch(c) => {
+                let ty = self.ty(&c.value);
+                self.bind(&errScratch(expr), ty);
+                self.walkExpr(&c.value);
+                match &c.handler {
+                    ast::CatchHandler::Default(d) => self.walkExpr(d),
+                    ast::CatchHandler::Block { binder, body } => {
+                        let names = errSite(expr).map(|s| s.names).unwrap_or_default();
+                        self.bind(binder, PlumType::TTags(names.into_iter().map(|n| (n, None)).collect()));
+                        self.walkBlock(body);
+                    }
+                }
+            }
             ast::Expr::ClassCall(call) => {
                 for fa in &call.fields {
                     self.walkExpr(&fa.value);
@@ -4024,6 +4217,9 @@ impl<'a> Collector<'a> {
             ast::Expr::Try(inner) => {
                 let key = expr as *const ast::Expr as usize;
                 let ty = self.ty(inner);
+                if errSite(expr).is_some() {
+                    self.bind(&errScratch(expr), ty.clone());
+                }
                 let slot = self.next_nested_class_slot;
                 self.next_nested_class_slot += 1;
                 self.nested_class_scratch.insert(key, slot);
@@ -4059,6 +4255,15 @@ impl<'a> Collector<'a> {
             ast::Expr::Attribute(a) => {
                 self.walkExpr(&a.object);
                 if let ast::AttrKind::Method(call) = &a.attr {
+                    if matches!(self.ty(&a.object), PlumType::TTags(_)) && call.name == "name" {
+                        self.bind(&errScratch(expr), PlumType::TBool);
+                    }
+                    // `a?.b` on an error union is inlined (no closure is built).
+                    if let (PlumType::TErr(inner, _), Some(cl)) = (self.ty(&a.object), andThenClosure(a, call)) {
+                        self.bind(&errScratch(expr), self.ty(&a.object));
+                        self.bind(&cl.params[0], (*inner).clone());
+                        self.walkBlock(&cl.body);
+                    }
                     // A call through an fn-typed field needs a local to hold the
                     // closure (read twice: env, then table index). Reserved even if
                     // a same-named method wins at compile time (then left unused).
@@ -4283,6 +4488,14 @@ fn compileFnBodyImpl(
         ast::FnBody::Expr(e) => {
             compileExpr(e, &mut body, &local_ctx, state)?;
         }
+        ast::FnBody::Block(block)
+            if matches!(&ret_decl, PlumType::TErr(t, _) if matches!(**t, PlumType::TUnit))
+                && !matches!(block.stmts.last(),
+                    Some(ast::Stmt::Expr(e, ..)) if matches!(inferLocalType(e, &local_ctx), PlumType::TErr(..))) =>
+        {
+            compileBlock(block, &mut body, &local_ctx, state)?;
+            Instruction::I32Const(0).encode(&mut body);
+        }
         ast::FnBody::Block(block) => {
             compileBlockAsFnBody(block, &mut body, &local_ctx, state, result_vt)?;
         }
@@ -4678,6 +4891,9 @@ fn compileStmt(
             Instruction::Return.encode(body);
         }
         ast::Stmt::Return(None) => {
+            if matches!(&ctx.ret_type, Some(PlumType::TErr(t, _)) if matches!(**t, PlumType::TUnit)) {
+                Instruction::I32Const(0).encode(body);
+            }
             Instruction::Return.encode(body);
         }
         ast::Stmt::If(if_) => {
@@ -4751,6 +4967,11 @@ fn compileStmt(
 /// Returns true if the expression leaves a value on the wasm stack.
 fn exprHasResult(expr: &ast::Expr, ctx: &LocalCtx) -> bool {
     match expr {
+        ast::Expr::Try(_) | ast::Expr::Bang(_) | ast::Expr::Catch(_)
+            if matches!(inferLocalType(expr, ctx), PlumType::TUnit) =>
+        {
+            false
+        }
         ast::Expr::FnCall(call) => {
             if ctx.locals.contains_key(&call.name)
                 && matches!(
@@ -6126,6 +6347,44 @@ fn compileExpr(
     if SKIP_COERCION.with(|c| c.replace(0)) == ptr {
         return compileExprCore(expr, body, ctx, state);
     }
+    if ctx.types.contains_key(&(ptr + plum_checker::ERR_WRAP)) {
+        compileExprCore(expr, body, ctx, state)?;
+        Instruction::I32Const(0).encode(body);
+        return Ok(());
+    }
+    if ctx.types.contains_key(&(ptr + plum_checker::ERR_FROM_NULLABLE)) {
+        let scratch = *ctx
+            .locals
+            .get(&errScratchKey(expr, plum_checker::ERR_FROM_NULLABLE))
+            .ok_or_else(|| "internal codegen error: missing nullable->!T scratch".to_string())?;
+        compileExprCore(expr, body, ctx, state)?;
+        Instruction::LocalSet(scratch).encode(body);
+        Instruction::LocalGet(scratch).encode(body);
+        Instruction::LocalGet(scratch).encode(body);
+        Instruction::RefIsNull.encode(body);
+        Instruction::If(BlockType::Result(ValType::I32)).encode(body);
+        Instruction::I32Const(errCode("Missing")?).encode(body);
+        Instruction::Else.encode(body);
+        Instruction::I32Const(0).encode(body);
+        Instruction::End.encode(body);
+        return Ok(());
+    }
+    if let Some(to) = ctx.types.get(&(ptr + plum_checker::ERR_TO_NULLABLE)) {
+        let scratch = *ctx
+            .locals
+            .get(&errScratchKey(expr, plum_checker::ERR_TO_NULLABLE))
+            .ok_or_else(|| "internal codegen error: missing !T->nullable scratch".to_string())?;
+        let ty = inferLocalType(expr, ctx);
+        compileExprCore(expr, body, ctx, state)?;
+        emitSetLocals(scratch, &ty, body);
+        Instruction::LocalGet(scratch + leafCount(&ty) - 1).encode(body);
+        Instruction::If(BlockType::Result(plumTypeToValtype(to))).encode(body);
+        Instruction::RefNull(nullableHeapType(to)).encode(body);
+        Instruction::Else.encode(body);
+        Instruction::LocalGet(scratch).encode(body);
+        Instruction::End.encode(body);
+        return Ok(());
+    }
     if let Some(ety) = ctx.types.get(&(ptr + plum_checker::TRY_WRAP_OK)) {
         return compileTryWrap(expr, ety, true, body, ctx, state);
     }
@@ -6199,6 +6458,296 @@ fn emitMissingReturn(body: &mut Vec<u8>, ctx: &LocalCtx) -> Result<(), String> {
     Ok(())
 }
+/// A compiled error-union operand parked in its scratch local: `!T` as
+/// `(T leaves..., code)`, or a nullable `Try` as its (nullable) reference.
+struct ErrOperand {
+    base: u32,
+    ty: PlumType,
+    success: PlumType,
+    nullable: bool,
+}
+impl ErrOperand {
+    fn pushIsErr(&self, body: &mut Vec<u8>) {
+        if self.nullable {
+            Instruction::LocalGet(self.base).encode(body);
+            Instruction::RefIsNull.encode(body);
+        } else {
+            self.pushCode(body).unwrap();
+            Instruction::I32Const(0).encode(body);
+            Instruction::I32Ne.encode(body);
+        }
+    }
+    fn pushCode(&self, body: &mut Vec<u8>) -> Result<(), String> {
+        if self.nullable {
+            Instruction::I32Const(errCode("Missing")?).encode(body);
+        } else {
+            Instruction::LocalGet(self.base + leafCount(&self.ty) - 1).encode(body);
+        }
+        Ok(())
+    }
+    fn pushValue(&self, body: &mut Vec<u8>) {
+        if self.nullable {
+            Instruction::LocalGet(self.base).encode(body);
+        } else {
+            for i in 0..leafCount(&self.ty) - 1 {
+                Instruction::LocalGet(self.base + i).encode(body);
+            }
+        }
+    }
+}
+/// Compiles `operand` (an error union) into `site_expr`'s scratch local.
+fn errOperand(
+    site_expr: &ast::Expr,
+    operand: &ast::Expr,
+    body: &mut Vec<u8>,
+    ctx: &LocalCtx,
+    state: &mut ModuleState,
+) -> Result<ErrOperand, String> {
+    let ty = inferLocalType(operand, ctx);
+    let base = *ctx
+        .locals
+        .get(&errScratch(site_expr))
+        .ok_or_else(|| "internal codegen error: missing error-union scratch local".to_string())?;
+    compileExpr(operand, body, ctx, state)?;
+    if let PlumType::TErr(t, _) = &ty {
+        emitSetLocals(base, &ty, body);
+        let success = (**t).clone();
+        return Ok(ErrOperand { base, ty, success, nullable: false });
+    }
+    if let Some(p) = plum_checker::nullableTryPayload(&ty) {
+        Instruction::LocalSet(base).encode(body);
+        let success = p.clone();
+        return Ok(ErrOperand { base, ty, success, nullable: true });
+    }
+    Err(format!("codegen: '?', '!' and 'catch' on {} are not supported", ty))
+}
+fn resultBlock(success: &PlumType) -> BlockType {
+    if matches!(success, PlumType::TUnit) {
+        BlockType::Empty
+    } else {
+        blockTypeFor(Some(plumTypeToValtype(success)))
+    }
+}
+/// `return (zeros, code)` for an enclosing `!T` fn, or null for a nullable-`Try` fn.
+fn emitErrReturn(
+    push_code: &dyn Fn(&mut Vec<u8>) -> Result<(), String>,
+    body: &mut Vec<u8>,
+    ctx: &LocalCtx,
+) -> Result<(), String> {
+    let rt = ctx
+        .ret_type
+        .as_ref()
+        .ok_or_else(|| "codegen: `fail`/`?` outside a function returning an error union".to_string())?;
+    match rt {
+        PlumType::TErr(t, _) => {
+            if !matches!(**t, PlumType::TUnit) {
+                emitZeros(t, body);
+            }
+            push_code(body)?;
+        }
+        _ if plum_checker::nullableTryPayload(rt).is_some() => {
+            Instruction::RefNull(nullableHeapType(rt)).encode(body);
+        }
+        _ => return Err(format!("codegen: `fail`/`?` in a function returning {}", rt)),
+    }
+    Instruction::Return.encode(body);
+    Ok(())
+}
+fn calleeText(e: &ast::Expr) -> String {
+    match e {
+        ast::Expr::FnCall(c) => c.name.clone(),
+        ast::Expr::Attribute(a) => match &a.attr {
+            ast::AttrKind::Method(c) => c.name.clone(),
+            ast::AttrKind::Field(f) => f.clone(),
+        },
+        ast::Expr::Var(n) => n.clone(),
+        ast::Expr::Paren(i) => calleeText(i),
+        _ => "value".to_string(),
+    }
+}
+fn compileErrTry(
+    expr: &ast::Expr,
+    inner: &ast::Expr,
+    body: &mut Vec<u8>,
+    ctx: &LocalCtx,
+    state: &mut ModuleState,
+) -> Result<(), String> {
+    let op = errOperand(expr, inner, body, ctx, state)?;
+    op.pushIsErr(body);
+    Instruction::If(BlockType::Empty).encode(body);
+    emitErrReturn(&|b| op.pushCode(b), body, ctx)?;
+    Instruction::End.encode(body);
+    op.pushValue(body);
+    Ok(())
+}
+fn compileErrBang(
+    expr: &ast::Expr,
+    b: &ast::BangExpr,
+    body: &mut Vec<u8>,
+    ctx: &LocalCtx,
+    state: &mut ModuleState,
+) -> Result<(), String> {
+    let op = errOperand(expr, &b.value, body, ctx, state)?;
+    let crash_idx = *ctx
+        .func_ids
+        .get(CRASH_FN_KEY)
+        .ok_or_else(|| "internal codegen error: crash import missing".to_string())?;
+    let callee = calleeText(&b.value);
+    let file = ERR_INFO.with(|e| e.borrow().file.clone());
+    let names = errSite(expr).map(|s| s.names).unwrap_or_default();
+    let msg = |n: &str| format!("{} failed with {} at {}:{}:{}", callee, n, file, b.line, b.column);
+    op.pushIsErr(body);
+    Instruction::If(BlockType::Empty).encode(body);
+    for n in &names {
+        op.pushCode(body)?;
+        Instruction::I32Const(errCode(n)?).encode(body);
+        Instruction::I32Eq.encode(body);
+        Instruction::If(BlockType::Empty).encode(body);
+        compileStaticString(&msg(n), body, state);
+        Instruction::Call(crash_idx).encode(body);
+        Instruction::Unreachable.encode(body);
+        Instruction::End.encode(body);
+    }
+    compileStaticString(&msg("error"), body, state);
+    Instruction::Call(crash_idx).encode(body);
+    Instruction::Unreachable.encode(body);
+    Instruction::End.encode(body);
+    op.pushValue(body);
+    Ok(())
+}
+fn compileErrCatch(
+    expr: &ast::Expr,
+    c: &ast::CatchExpr,
+    body: &mut Vec<u8>,
+    ctx: &LocalCtx,
+    state: &mut ModuleState,
+) -> Result<(), String> {
+    let op = errOperand(expr, &c.value, body, ctx, state)?;
+    op.pushIsErr(body);
+    Instruction::If(resultBlock(&op.success)).encode(body);
+    match &c.handler {
+        ast::CatchHandler::Default(d) => {
+            ctx.loop_extra_depth.set(ctx.loop_extra_depth.get() + 1);
+            let r = compileExprInto(d, &op.success, body, ctx, state);
+            ctx.loop_extra_depth.set(ctx.loop_extra_depth.get() - 1);
+            r?;
+        }
+        ast::CatchHandler::Block { binder, body: blk } => {
+            let names = errSite(expr).map(|s| s.names).unwrap_or_default();
+            // `e` is a tag value of the set's names: build it from the code.
+            for n in &names {
+                op.pushCode(body)?;
+                Instruction::I32Const(errCode(n)?).encode(body);
+                Instruction::I32Eq.encode(body);
+                Instruction::If(BlockType::Result(ValType::I32)).encode(body);
+                Instruction::I32Const(tagId(n)).encode(body);
+                Instruction::Else.encode(body);
+            }
+            Instruction::I32Const(0).encode(body);
+            for _ in &names {
+                Instruction::End.encode(body);
+            }
+            Instruction::StructNew(ctx.gc_types.tag_type_idx).encode(body);
+            let idx = *ctx
+                .locals
+                .get(binder)
+                .ok_or_else(|| format!("undeclared catch binder '{}'", binder))?;
+            Instruction::LocalSet(idx).encode(body);
+            let tags = PlumType::TTags(names.iter().map(|n| (n.clone(), None)).collect());
+            ctx.type_env.borrow_mut().insert(binder.clone(), TypeScheme::mono(tags));
+            let rvt = if matches!(op.success, PlumType::TUnit) { None } else { Some(plumTypeToValtype(&op.success)) };
+            compileCaseBody(blk, rvt, body, ctx, state)?;
+        }
+    }
+    Instruction::Else.encode(body);
+    op.pushValue(body);
+    Instruction::End.encode(body);
+    Ok(())
+}
+/// `a?.b` on an error union: `a.andThen(|x| x.b)` inlined.
+fn compileErrAndThen(
+    expr: &ast::Expr,
+    obj: &ast::Expr,
+    cl: &ast::Closure,
+    body: &mut Vec<u8>,
+    ctx: &LocalCtx,
+    state: &mut ModuleState,
+) -> Result<(), String> {
+    let op = errOperand(expr, obj, body, ctx, state)?;
+    let out_ty = inferLocalType(expr, ctx);
+    let PlumType::TErr(out_inner, _) = &out_ty else {
+        return Err(format!("codegen: '?.' result is {}, not an error union", out_ty));
+    };
+    op.pushIsErr(body);
+    Instruction::If(blockTypeFor(Some(plumTypeToValtype(&out_ty)))).encode(body);
+    emitZeros(out_inner, body);
+    op.pushCode(body)?;
+    Instruction::Else.encode(body);
+    let pidx = *ctx.locals.get(&cl.params[0]).ok_or_else(|| "missing '?.' binding".to_string())?;
+    op.pushValue(body);
+    emitSetLocals(pidx, &op.success, body);
+    let (last, rest) = cl
+        .body
+        .stmts
+        .split_last()
+        .ok_or_else(|| "codegen: empty '?.' body".to_string())?;
+    ctx.loop_extra_depth.set(ctx.loop_extra_depth.get() + 1);
+    for st in rest {
+        compileStmt(st, body, ctx, state)?;
+    }
+    let ast::Stmt::Expr(e, ..) = last else {
+        return Err("codegen: '?.' body must be an expression".to_string());
+    };
+    compileExpr(e, body, ctx, state)?;
+    ctx.loop_extra_depth.set(ctx.loop_extra_depth.get() - 1);
+    if !matches!(inferLocalType(e, ctx), PlumType::TErr(..)) {
+        Instruction::I32Const(0).encode(body);
+    }
+    Instruction::End.encode(body);
+    Ok(())
+}
+/// `e.name()` on a tag/error value: its text.
+fn compileTagName(
+    expr: &ast::Expr,
+    obj: &ast::Expr,
+    tags: &std::collections::BTreeMap<String, Option<Box<PlumType>>>,
+    body: &mut Vec<u8>,
+    ctx: &LocalCtx,
+    state: &mut ModuleState,
+) -> Result<(), String> {
+    let tmp = *ctx
+        .locals
+        .get(&errScratch(expr))
+        .ok_or_else(|| "internal codegen error: missing name() scratch".to_string())?;
+    compileExpr(obj, body, ctx, state)?;
+    Instruction::StructGet { struct_type_index: ctx.gc_types.tag_type_idx, field_index: 0 }.encode(body);
+    Instruction::LocalSet(tmp).encode(body);
+    let svt = plumTypeToValtype(&PlumType::TStr);
+    for n in tags.keys() {
+        Instruction::LocalGet(tmp).encode(body);
+        Instruction::I32Const(tagId(n)).encode(body);
+        Instruction::I32Eq.encode(body);
+        Instruction::If(BlockType::Result(svt)).encode(body);
+        compileStaticString(n, body, state);
+        Instruction::Else.encode(body);
+    }
+    compileStaticString("", body, state);
+    for _ in tags {
+        Instruction::End.encode(body);
+    }
+    Ok(())
+}
 /// Converts a nullable `Try` value (null = `Missing`) into the ordinary struct
 /// layout of the wider `to` type (`Try[T, [Missing, ..]]`).
 fn compileNullableRelayout(
@@ -6241,8 +6790,23 @@ fn compileExprCore(
 ) -> Result<(), String> {
     match expr {
         ast::Expr::Yield(_) => return Err("internal codegen error: yield survived expansion".to_string()),
-        ast::Expr::Bang(_) | ast::Expr::Catch(_) | ast::Expr::Fail(_) => {
+        ast::Expr::Bang(b) => compileErrBang(expr, b, body, ctx, state)?,
+        ast::Expr::Catch(c) => compileErrCatch(expr, c, body, ctx, state)?,
+        ast::Expr::Fail(f) => {
+            let tag = f.tag.clone();
+            let rt = ctx.ret_type.clone();
+            match rt {
+                Some(ref r @ PlumType::TApp(..)) if plum_checker::nullableTryPayload(r).is_none() => {
+                    let idx = ctx.gc_types.variantIdx(r, "Err").ok_or_else(|| {
-            return Err("`!`, `catch` and `fail` are not supported by codegen yet".to_string())
+                        format!("codegen: `fail` in a function returning {}", r)
+                    })?;
+                    Instruction::I32Const(tagId(&tag)).encode(body);
+                    Instruction::StructNew(ctx.gc_types.tag_type_idx).encode(body);
+                    Instruction::StructNew(idx).encode(body);
+                    Instruction::Return.encode(body);
+                }
+                _ => emitErrReturn(&|b| { Instruction::I32Const(errCode(&tag)?).encode(b); Ok(()) }, body, ctx)?,
+            }
         }
         ast::Expr::Int(n) => {
             Instruction::I64Const(*n).encode(body);
@@ -6283,6 +6847,7 @@ fn compileExprCore(
         // `else` branch — the same stack-polymorphism-after-`return` rule
         // `compileStmt`'s own `Return` arm relies on, just reached from
         // inside an expression here for the first time.
+        ast::Expr::Try(inner) if errSite(expr).is_some() => compileErrTry(expr, inner, body, ctx, state)?,
         ast::Expr::Try(inner) => {
             let inner_ty = inferLocalType(inner, ctx);
             let enum_name = match plum_checker::nominalName(&inner_ty) {
@@ -7024,7 +7589,13 @@ fn compileExprCore(
                     compileFieldRead(&attr.object, field_name, &obj_ty, expr, body, ctx, state)?
                 }
                 ast::AttrKind::Method(call) => {
+                    if let (PlumType::TErr(..), Some(cl)) = (&obj_ty, andThenClosure(attr, call)) {
+                        compileErrAndThen(expr, &attr.object, cl, body, ctx, state)?
+                    } else if let (PlumType::TTags(tags), "name", true) = (&obj_ty, call.name.as_str(), call.args.is_empty()) {
+                        compileTagName(expr, &attr.object, tags, body, ctx, state)?
+                    } else {
-                    compileMethodCall(&attr.object, call, &obj_ty, expr, false, body, ctx, state)?
+                        compileMethodCall(&attr.object, call, &obj_ty, expr, false, body, ctx, state)?
+                    }
                 }
             }
         }

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

@@ -2812,3 +2812,331 @@ fn extend_replaces_dummy_enums() {
         assert!(!text.contains(&format!("enum {f} =")), "{f} still has a dummy enum");
     }
 }
+// ---- Zig-style error unions (E3) ----
+fn compileUnmerged(src: &str) -> Vec<u8> {
+    assertValid(src)
+}
+fn runInt(src: &str) -> i64 {
+    let bytes = compileUnmerged(src);
+    let engine = gcEngine();
+    let module = wasmtime::Module::new(&engine, &bytes).unwrap();
+    let mut store = wasmtime::Store::new(&engine, ());
+    let instance = wasmtime::Instance::new(&mut store, &module, &[]).unwrap();
+    instance.get_typed_func::<(), i64>(&mut store, "main").unwrap().call(&mut store, ()).unwrap()
+}
+/// Runs a std-importing program; returns (result or trap, crash messages seen).
+fn runWithCrash(name: &str, src: &str) -> (Result<i64, String>, Vec<String>) {
+    let dir = std::env::temp_dir().join(format!("plum_e3_{}_{}", name, 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");
+    plum_checker::checkSource(&source).unwrap_or_else(|e| {
+        panic!("check errors: {:?}", e.iter().map(|x| x.message.clone()).collect::<Vec<_>>())
+    });
+    let bytes = compileSource(&source).expect("compile failed");
+    wasmparser::validate(&bytes).expect("valid wasm");
+    let _ = std::fs::remove_dir_all(&dir);
+    let engine = gcEngine();
+    let module = wasmtime::Module::new(&engine, &bytes).unwrap();
+    let mut store = wasmtime::Store::new(&engine, Vec::<String>::new());
+    let mut linker: wasmtime::Linker<Vec<String>> = wasmtime::Linker::new(&engine);
+    for imp in module.imports() {
+        if imp.module() == "plum" && imp.name() == "crash" {
+            let ty = imp.ty().func().cloned().unwrap();
+            linker
+                .func_new("plum", "crash", ty, |mut caller, params, _| {
+                    let wasmtime::Val::AnyRef(Some(s)) = &params[0] else { panic!("Str expected") };
+                    let st = s.unwrap_struct(&caller).unwrap();
+                    let wasmtime::Val::AnyRef(Some(buf)) = st.field(&mut caller, 0).unwrap() else { panic!() };
+                    let bs = buf.unwrap_struct(&caller).unwrap();
+                    let wasmtime::Val::AnyRef(Some(arr)) = bs.field(&mut caller, 0).unwrap() else { panic!() };
+                    let wasmtime::Val::I64(len) = bs.field(&mut caller, 1).unwrap() else { panic!() };
+                    let arr = arr.unwrap_array(&caller).unwrap();
+                    let mut b = vec![0u8; arr.len(&caller).unwrap() as usize];
+                    arr.copy_to_i8_slice(&mut caller, &mut b).unwrap();
+                    b.truncate(len as usize);
+                    caller.data_mut().push(String::from_utf8_lossy(&b).into_owned());
+                    Ok(())
+                })
+                .unwrap();
+        }
+    }
+    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();
+    let r = main.call(&mut store, ()).map_err(|e| e.to_string());
+    (r, store.data().clone())
+}
+#[test]
+fn error_union_multi_value() {
+    let bytes = assertValid("fun f(n: Int) -> !Int =\n  if n < 0\n    fail Neg\n  n\n\nfun main() -> Int =\n  f(3) catch 0\n");
+    let mut found = false;
+    for payload in wasmparser::Parser::new(0).parse_all(&bytes) {
+        if let wasmparser::Payload::TypeSection(s) = payload.unwrap() {
+            for g in s {
+                for t in g.unwrap().types() {
+                    if let wasmparser::CompositeInnerType::Func(f) = &t.composite_type.inner {
+                        if f.params() == [wasmparser::ValType::I64]
+                            && f.results() == [wasmparser::ValType::I64, wasmparser::ValType::I32]
+                        {
+                            found = true;
+                        }
+                    }
+                }
+            }
+        }
+    }
+    assert!(found, "no (i64)->(i64,i32) function type");
+}
+#[test]
+fn fail_and_question_propagate() {
+    let src = "\
+fun a(n: Int) -> !Int =
+  if n < 0
+    fail Negative
+  n * 2
+fun b(n: Int) -> !Int =
+  x := a(n)?
+  x + 1
+fun main() -> Int =
+  p := b(5) catch 100
+  q := b(-5) catch 200
+  p * 1000 + q
+";
+    assert_eq!(runInt(src), 11 * 1000 + 200);
+}
+#[test]
+fn catch_default_runtime() {
+    let src = "\
+fun f(n: Int) -> !Int =
+  if n == 0
+    fail Zero
+  n
+fun main() -> Int =
+  {f(7) catch 1} * 10 + {f(0) catch 3}
+";
+    assert_eq!(runInt(src), 73);
+}
+#[test]
+fn catch_fail_maps_tag() {
+    let src = "\
+fun inner(n: Int) -> !Int =
+  if n == 0
+    fail Zero
+  n
+fun outer(n: Int) -> !Int =
+  x := inner(n) catch fail Mapped
+  x + 1
+fun main() -> Int =
+  a := outer(0) catch e
+    match e
+      Mapped => 40
+  b := outer(1) catch 99
+  a + b
+";
+    assert_eq!(runInt(src), 42);
+}
+#[test]
+fn catch_block_binds_error() {
+    let src = "\
+fun f(n: Int) -> !Int =
+  if n == 1
+    fail One
+  if n == 2
+    fail Two
+  n
+fun main() -> Int =
+  a := f(1) catch e
+    match e
+      One => 10
+      Two => 20
+  b := f(2) catch e
+    match e
+      One => 10
+      Two => 20
+  c := f(3) catch e
+    return 0
+  a * 100 + b * 10 + c
+";
+    assert_eq!(runInt(src), 10 * 100 + 20 * 10 + 3);
+}
+#[test]
+fn e_name_runtime() {
+    let src = "\
+import std/Str
+import std/Number
+fun f() -> !Int =
+  fail NotFound
+fun main() -> Int =
+  s := f() catch e
+    e.name()
+  s.length()
+";
+    // the catch block must yield Int, so name() is used for its length instead
+    let src = src.replace("  s := f() catch e\n    e.name()\n  s.length()", "  n := f() catch e\n    e.name().length()\n  n");
+    let (r, _) = runWithCrash("ename", &src);
+    assert_eq!(r.unwrap(), 8);
+}
+#[test]
+fn bang_crashes_with_message() {
+    let src = "\
+import std/Str
+import std/Number
+fun risky() -> !Int =
+  fail Boom
+fun main() -> Int =
+  risky()!
+";
+    let (r, msgs) = runWithCrash("bang", src);
+    assert!(r.is_err());
+    assert_eq!(msgs.len(), 1, "{msgs:?}");
+    assert!(msgs[0].starts_with("risky failed with Boom at "), "{}", msgs[0]);
+    assert!(msgs[0].ends_with(":8:3"), "{}", msgs[0]);
+    let ok = "import std/Str\nimport std/Number\n\nfun f() -> !Int =\n  7\n\nfun main() -> Int =\n  f()!\n";
+    assert_eq!(runWithCrash("bangok", ok).0.unwrap(), 7);
+}
+#[test]
+fn unit_error_union() {
+    let src = "\
+fun check(n: Int) -> !Unit =
+  if n < 0
+    fail Neg
+fun run(n: Int) -> !Int =
+  check(n)?
+  n
+fun main() -> Int =
+  {run(4) catch 0} + {run(-1) catch 5}
+";
+    assert_eq!(runInt(src), 9);
+}
+#[test]
+fn error_union_boxed_in_list() {
+    let src = "\
+import std/Str
+import std/Number
+import std/List
+fun f(n: Int) -> !Int =
+  if n < 0
+    fail Neg
+  n
+fun main() -> Int =
+  xs := List[!Int]()
+  xs.push(f(4))
+  xs.push(f(-1))
+  a := xs.at(0) catch 0
+  b := xs.at(1) catch 100
+  a + b
+";
+    assert_eq!(runWithCrash("boxlist", src).0.unwrap(), 104);
+}
+#[test]
+fn error_union_in_class_field() {
+    let src = "\
+enum Box =
+  | Box(v: !Int)
+fun f(n: Int) -> !Int =
+  if n < 0
+    fail Neg
+  n
+fun main() -> Int =
+  a := Box(v: f(6))
+  b := Box(v: f(-6))
+  {a.v catch 0} * 10 + {b.v catch 1}
+";
+    assert_eq!(runInt(src), 61);
+}
+#[test]
+fn safe_nav_on_error_union() {
+    let src = "\
+enum User =
+  | User(age: Int)
+fun load(n: Int) -> !User =
+  if n < 0
+    fail NoUser
+  User(age: n)
+fun age(n: Int) -> !Int =
+  load(n)?.age
+fun main() -> Int =
+  {age(30) catch 0} + {age(-1) catch 1}
+";
+    assert_eq!(runInt(src), 31);
+}
+#[test]
+fn nullable_ref_still_null() {
+    let src = "\
+import std/Str
+import std/Number
+import std/Try
+enum Item =
+  | Item(v: Int)
+fun find(n: Int) -> Item? =
+  if n < 0
+    fail Missing
+  Item(v: n)
+fun main() -> Int =
+  a := find(3) catch Item(v: 0)
+  b := find(-3) catch Item(v: 5)
+  a.v * 10 + b.v
+";
+    assert_eq!(runWithCrash("nullable", src).0.unwrap(), 35);
+}
+#[test]
+fn no_alloc_on_error_path() {
+    let src = "\
+fun a(n: Int) -> !Int =
+  if n < 0
+    fail Neg
+  n
+fun b(n: Int) -> !Int =
+  x := a(n)?
+  y := a(x + 1)?
+  x + y
+fun main() -> Int =
+  b(2) catch 0
+";
+    let bytes = assertValid(src);
+    let ops = opsOf(&bytes, "b");
+    assert_eq!(countOps(&ops, "StructNew"), 0, "{ops:?}");
+}