b3bb7b5 | plum | pyrossh

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

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

b3bb7b5 — Peter John 2026-10-26T10:24:18+05:30

feat!: Bool is a built-in i32 primitive

Files changed (5) hide show

plum-checker/src/lib.rs +7 -16
plum-checker/tests/checker_tests.rs +35 -0
plum-std/Bool.plum +8 -15
plum-wasm-codegen/src/lib.rs +247 -129
plum-wasm-codegen/tests/codegen_tests.rs +97 -0

plum-checker/src/lib.rs CHANGED Viewed

@@ -483,17 +483,6 @@ pub fn unify(t1: &PlumType, t2: &PlumType, ctx: &CheckCtx) -> Result<(), String>
         {
             Ok(())
         }
-        // Same reasoning as `Str` above — `Bool` is an ordinary enum now
-        // (`enum Bool = | True | False` in `libs/std/Bool.plum`), so a bare
-        // `True`/`False`/`Ok(...)`-wrapped-variant reference can infer as
-        // `TNamed("Bool")` (via `EnumVariantInfo`/`bareVariantWrapType`)
-        // while a `Bool` type ANNOTATION resolves via `plumTypeFromName` to
-        // the dedicated `TBool` variant instead.
-        (PlumType::TBool, PlumType::TNamed(n)) | (PlumType::TNamed(n), PlumType::TBool)
-            if n == "Bool" =>
-        {
-            Ok(())
-        }
         (PlumType::TByte, PlumType::TByte) => Ok(()),
         (PlumType::TByteSlice, PlumType::TByteSlice) => Ok(()),
         (PlumType::TUnit, PlumType::TUnit) => Ok(()),
@@ -2184,8 +2173,11 @@ fn checkPattern(
         ast::CasePattern::Int(_) => unify(subject_ty, &PlumType::TInt, ctx),
         ast::CasePattern::Float(_) => unify(subject_ty, &PlumType::TFloat, ctx),
         ast::CasePattern::String(_) => unify(subject_ty, &PlumType::TStr, ctx),
+        ast::CasePattern::Name(n) if n == "True" || n == "False" => {
+            unify(subject_ty, &PlumType::TBool, ctx)
+        }
         ast::CasePattern::Name(n) => {
-            let is_known_variant = n.chars().next().map(|c| c.is_uppercase()).unwrap_or(false)
+            let is_known_variant =n.chars().next().map(|c| c.is_uppercase()).unwrap_or(false)
                 && ctx.enum_variants.contains_key(n);
             if is_known_variant {
                 Ok(()) // equality check against a known enum tag, e.g. `True`
@@ -2425,7 +2417,7 @@ fn isTagLiteralName(n: &str, ctx: &CheckCtx) -> bool {
     n.chars().next().is_some_and(|c| c.is_uppercase())
         && !matches!(
             n,
-            "Int" | "Float" | "Bool" | "Str" | "Byte" | "Unit" | "Self"
+            "Int" | "Float" | "Bool" | "Str" | "Byte" | "Unit" | "Self" | "True" | "False"
         )
         && !ctx.enum_variants.contains_key(n)
         && !ctx.enum_variants.values().any(|i| i.enum_name == n)
@@ -2738,12 +2730,11 @@ fn inferExprInner(
         // const (`PI`, `MAX_VALUE`, ...), since there's no separate "constant"
         // token. Prefer a matching const's real type over the enum-variant/
         // unmodeled-type-name fallbacks below.
+        // `True`/`False` are built-in `Bool` literals, always available.
+        ast::Expr::TypeName(n) if n == "True" || n == "False" => Ok(PlumType::TBool),
         ast::Expr::TypeName(n) => match lookup(env, n) {
             Ok(ty) if !matches!(ty, PlumType::TVar(_)) => Ok(ty),
             _ => match ctx.enum_variants.get(n) {
-                // `Bool` normalizes to the dedicated `TBool` variant (not
-                // `TNamed("Bool")`) — see the note on `unify`'s Bool arm.
-                Some(info) if info.enum_name == "Bool" => Ok(PlumType::TBool),
                 Some(info) => {
                     let (_, result, binds) = startVariant(info, &[], expected);
                     Ok(substVars(&result, &binds))

plum-checker/tests/checker_tests.rs CHANGED Viewed

@@ -2239,3 +2239,38 @@ enum Box[T] =
     let result = checkSource(&parse(src));
     assert!(result.is_ok(), "got {:?}", result.err());
 }
+// ---------- built-in Bool (no `import std/Bool`, no `enum Bool`) ----------
+#[test]
+fn builtin_bool_needs_no_import() {
+    let src = "\
+fun both(a: Bool, b: Bool) -> Bool =
+  a && !b || False
+fun main() -> Bool =
+  x := True
+  x == both(True, False)
+";
+    let r = checkSource(&parseClean(src));
+    assert!(r.is_ok(), "got {:?}", r.err());
+}
+#[test]
+fn builtin_bool_match_missing_false_is_rejected() {
+    let r = errText(checkSource(&parseClean(
+        "fun name(b: Bool) -> Str =\n  match b\n    True => \"y\"\n",
+    )));
+    assert!(r.contains("non-exhaustive match on Bool: missing False"), "got: {}", r);
+    let ok = checkSource(&parseClean(
+        "fun name(b: Bool) -> Str =\n  match b\n    True => \"y\"\n    False => \"n\"\n",
+    ));
+    assert!(ok.is_ok(), "got {:?}", ok.err());
+}
+#[test]
+fn true_false_are_never_tags() {
+    let src = "fun f() -> Int =\n  x := True\n  y := False\n  x == y ? 1 : 0\n";
+    let r = checkSource(&parseClean(src));
+    assert!(r.is_ok(), "got {:?}", r.err());
+}

plum-std/Bool.plum CHANGED Viewed

@@ -2,9 +2,12 @@ module std
 import std/Try
 import std/Str
+# `Bool` is a built-in primitive (a wasm i32, 0/1); `True`/`False` are always
+# available literals and need no import. This file only provides the METHODS
+# whose receiver is a `Bool` (the single-variant enum is a pure marker, exactly
+# like `Byte.plum`/`Number.plum`).
 enum Bool =
-  | True
+  | Bool
-  | False
   fun parse(v: Str) -> Try[Bool, [BadBoolStr]] =
     if v == "true"
@@ -15,20 +18,10 @@ enum Bool =
       Err(BadBoolStr)
   fun and(self, o: Bool) -> Bool =
-    match self, o
-      True, True => True
-      True, False => False
-      False, True => False
-      False, False => False
+    self && o
   fun or(self, o: Bool) -> Bool =
-    match self, o
+    self || o
-      True, True => True
-      True, False => True
-      False, True => True
-      False, False => False
   fun toStr(self) -> Str =
-    match self
-      True => "True"
-      False => "False"
+    self ? "True" : "False"

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

@@ -643,6 +643,10 @@ fn collectTagNamesTy(ty: &PlumType, out: &mut std::collections::BTreeSet<String>
 /// as an `anyref`: `Int`/`Float`/`Byte` get a `$BoxI64`/`$BoxF64`/`$BoxI32`,
 /// reference values are stored as-is.
 fn boxTagPayload(ty: &PlumType, body: &mut Vec<u8>, ctx: &LocalCtx) {
+    if matches!(ty, PlumType::TBool) {
+        Instruction::Call(ctx.gc_types.box_bool_fn).encode(body);
+        return;
+    }
     match plumTypeToValtype(ty) {
         ValType::I64 => Instruction::Call(ctx.gc_types.box_i64_fn).encode(body),
         ValType::F64 => Instruction::Call(ctx.gc_types.box_f64_fn).encode(body),
@@ -651,6 +655,33 @@ fn boxTagPayload(ty: &PlumType, body: &mut Vec<u8>, ctx: &LocalCtx) {
     }
 }
+/// Stand-in plum type for "any erased reference" in `coerceTy` calls.
+fn anyTy() -> PlumType {
+    // A function type lowers to `anyref`, the closure ABI's erased slot type.
+    PlumType::TFun(Vec::new(), Box::new(PlumType::TUnit))
+}
+/// `coerceVt` with static types: a `Bool` and a `Byte` are both wasm `i32`, so
+/// boxing/unboxing across an erased edge must look at the plum type to pick
+/// `$BoxBool` over `$BoxI32`.
+fn coerceTy(from: &PlumType, to: &PlumType, body: &mut Vec<u8>, g: &GcTypeRegistry) {
+    let (fv, tv) = (plumTypeToGcValtype(from, g), plumTypeToGcValtype(to, g));
+    match (from, to) {
+        (PlumType::TBool, _) if matches!(tv, ValType::Ref(_)) => {
+            Instruction::Call(g.box_bool_fn).encode(body)
+        }
+        (_, PlumType::TBool) if matches!(fv, ValType::Ref(_)) => {
+            Instruction::RefCastNonNull(HeapType::Concrete(g.box_bool_idx)).encode(body);
+            Instruction::StructGet {
+                struct_type_index: g.box_bool_idx,
+                field_index: fld(0),
+            }
+            .encode(body);
+        }
+        _ => coerceVt(fv, tv, body, g),
+    }
+}
 /// Converts the value on top of the stack from representation `from` to `to`
 /// (the erased-generics edge conversions): a primitive entering a reference slot
 /// (`ref null $Obj` / `anyref`) is boxed; a reference leaving such a slot for a
@@ -707,8 +738,12 @@ fn compileExprAs(
 ) -> Result<(), String> {
     compileExpr(expr, body, ctx, state)?;
     if let Some(vt) = expected {
-        let own = plumTypeToValtype(&inferLocalType(expr, ctx));
+        let own_ty = inferLocalType(expr, ctx);
+        if matches!(own_ty, PlumType::TBool) && matches!(vt, ValType::Ref(_)) {
-        coerceVt(own, vt, body, ctx.gc_types);
+            coerceTy(&own_ty, &anyTy(), body, ctx.gc_types);
+        } else {
+            coerceVt(plumTypeToValtype(&own_ty), vt, body, ctx.gc_types);
+        }
     }
     Ok(())
 }
@@ -762,6 +797,10 @@ fn unboxTagPayload(ty: &PlumType, body: &mut Vec<u8>, ctx: &LocalCtx) {
         }
         .encode(body);
     };
+    if matches!(ty, PlumType::TBool) {
+        unbox(ctx.gc_types.box_bool_idx, body);
+        return;
+    }
     match plumTypeToValtype(ty) {
         ValType::I64 => unbox(ctx.gc_types.box_i64_idx, body),
         ValType::F64 => unbox(ctx.gc_types.box_f64_idx, body),
@@ -892,13 +931,7 @@ fn plumTypeToValtype(t: &PlumType) -> ValType {
         PlumType::TApp(n, _) => plumTypeToValtype(&PlumType::TNamed(n.clone())),
         PlumType::TInt => ValType::I64,
         PlumType::TFloat => ValType::F64,
-        PlumType::TBool => withGcTypes(|r| {
+        PlumType::TBool => ValType::I32,
-            gcRef(
-                *r.enum_super_type_idx
-                    .get("Bool")
-                    .expect("Bool must be registered"),
-            )
-        }),
         // `Str` is an ORDINARY class (`type Str(...) = data: Buffer ...` in
         // `str.plum`) — its own real struct type, registered exactly like any
         // other class (see `buildGcTypeRegistry`'s `Slot::Class` handling),
@@ -986,6 +1019,8 @@ pub struct GcTypeRegistry {
     pub box_i64_idx: u32,
     pub box_f64_idx: u32,
     pub box_i32_idx: u32,
+    /// `$BoxBool {typeId, i32}` — a `Bool` crossing an erased edge (`toStr` must say True/False).
+    pub box_bool_idx: u32,
     /// The `$Obj {typeId: i32}` supertype of every class/enum/tag/box struct.
     pub obj_type_idx: u32,
     /// Enum name and variant name -> the runtime `typeId` stored in field 0 of
@@ -996,6 +1031,7 @@ pub struct GcTypeRegistry {
     pub box_i64_fn: u32,
     pub box_f64_fn: u32,
     pub box_i32_fn: u32,
+    pub box_bool_fn: u32,
     /// Helper `(arr: array<i8>, len: i64) -> Str` building `Str{Buffer{arr,len}}`
     /// with correct headers; `None` when the program has no `Str`/`Buffer`.
     pub mk_str_fn: Option<u32>,
@@ -1008,6 +1044,8 @@ pub const TYPE_ID_BOX_I64: i32 = 1;
 pub const TYPE_ID_BOX_F64: i32 = 2;
 pub const TYPE_ID_BOX_I32: i32 = 3;
 pub const TYPE_ID_TAG: i32 = 4;
+/// Box for a `Bool` (i32 payload); ids 5/6 are `Str`/`Buffer`.
+pub const TYPE_ID_BOX_BOOL: i32 = 7;
 /// `Str` and `Buffer` get fixed ids so hosts can build them without a lookup.
 pub const TYPE_ID_STR: i32 = 5;
 pub const TYPE_ID_BUFFER: i32 = 6;
@@ -1047,16 +1085,7 @@ fn plumTypeToGcValtype(t: &PlumType, registry: &GcTypeRegistry) -> ValType {
         PlumType::TApp(n, _) => plumTypeToGcValtype(&PlumType::TNamed(n.clone()), registry),
         PlumType::TInt => ValType::I64,
         PlumType::TFloat => ValType::F64,
-        PlumType::TBool => {
+        PlumType::TBool => ValType::I32,
-            let idx = *registry
-                .enum_super_type_idx
-                .get("Bool")
-                .expect("internal codegen error: Bool must be registered in the GC type registry");
-            ValType::Ref(RefType {
-                nullable: true,
-                heap_type: HeapType::Concrete(idx),
-            })
-        }
         // See the matching comment in `plumTypeToValtype` — `Str` is an
         // ordinary class's own real struct type, not the raw
         // `byte_array_type_idx`, except when `Str` was never actually
@@ -1126,6 +1155,7 @@ fn buildGcTypeRegistry(
         BoxI64,
         BoxF64,
         BoxI32,
+        BoxBool,
     }
     // Pass 1: assign every entry a slot (and therefore a type index) up front, before
@@ -1216,6 +1246,8 @@ fn buildGcTypeRegistry(
     slots.push(Slot::BoxF64);
     let box_i32_idx = slots.len() as u32;
     slots.push(Slot::BoxI32);
+    let box_bool_idx = slots.len() as u32;
+    slots.push(Slot::BoxBool);
     // The registry is fully index-complete after pass 1 (every name has an assigned
     // slot) even though no field lists exist yet — safe to hand to `plumTypeToGcValtype`
@@ -1232,11 +1264,13 @@ fn buildGcTypeRegistry(
         box_i64_idx,
         box_f64_idx,
         box_i32_idx,
+        box_bool_idx,
         obj_type_idx,
         type_ids,
         box_i64_fn: 0,
         box_f64_fn: 0,
         box_i32_fn: 0,
+        box_bool_fn: 0,
         mk_str_fn: None,
         dyn_fns: HashMap::new(),
     };
@@ -1354,6 +1388,7 @@ fn buildGcTypeRegistry(
             Slot::BoxI64 => boxSubType(ValType::I64, obj_type_idx),
             Slot::BoxF64 => boxSubType(ValType::F64, obj_type_idx),
             Slot::BoxI32 => boxSubType(ValType::I32, obj_type_idx),
+            Slot::BoxBool => boxSubType(ValType::I32, obj_type_idx),
             Slot::ArrayRef => SubType {
                 is_final: true,
                 supertype_idx: None,
@@ -1908,6 +1943,8 @@ fn compileSourceInner(
         registerBoxHelper(&mut module, ValType::F64, TYPE_ID_BOX_F64, gc_types.box_f64_idx);
     gc_types.box_i32_fn =
         registerBoxHelper(&mut module, ValType::I32, TYPE_ID_BOX_I32, gc_types.box_i32_idx);
+    gc_types.box_bool_fn =
+        registerBoxHelper(&mut module, ValType::I32, TYPE_ID_BOX_BOOL, gc_types.box_bool_idx);
     if let (Some(&buffer_idx), Some(&str_idx)) = (
         gc_types.class_type_idx.get("Buffer"),
         gc_types.class_type_idx.get("Str"),
@@ -2135,10 +2172,18 @@ fn compileSourceInner(
         tbody.push(0u8); // no locals beyond the params already in the signature
         for (i, vt) in sig.params.iter().enumerate() {
             Instruction::LocalGet((i + 1) as u32).encode(&mut tbody); // local 0 is env, ignored
+            match sig.decl_params.get(i) {
+                Some(PlumType::TBool) => {
+                    coerceTy(&anyTy(), &PlumType::TBool, &mut tbody, &gc_types)
+                }
-            coerceVt(ValType::Ref(RefType::ANYREF), *vt, &mut tbody, &gc_types);
+                _ => coerceVt(ValType::Ref(RefType::ANYREF), *vt, &mut tbody, &gc_types),
+            }
         }
         Instruction::Call(real_func_idx).encode(&mut tbody);
         match sig.ret {
+            Some(_) if matches!(sig.decl_ret, PlumType::TBool) => {
+                coerceTy(&PlumType::TBool, &anyTy(), &mut tbody, &gc_types)
+            }
             Some(rvt) => coerceVt(rvt, ValType::Ref(RefType::ANYREF), &mut tbody, &gc_types),
             None => Instruction::RefNull(HeapType::ANY).encode(&mut tbody),
         }
@@ -2358,6 +2403,7 @@ fn registerDynDispatchers(
                 ("Int", ValType::I64, gc_types.box_i64_idx, TYPE_ID_BOX_I64),
                 ("Float", ValType::F64, gc_types.box_f64_idx, TYPE_ID_BOX_F64),
                 ("Byte", ValType::I32, gc_types.box_i32_idx, TYPE_ID_BOX_I32),
+                ("Bool", ValType::I32, gc_types.box_bool_idx, TYPE_ID_BOX_BOOL),
             ] {
                 let direct = format!("{}::{}", prim, m.name);
                 let mut b = Vec::new();
@@ -2481,6 +2527,7 @@ fn registerDynEqHelper(module: &mut WasmModule, g: &GcTypeRegistry, string_eq_fu
         (TYPE_ID_BOX_I64, g.box_i64_idx, Instruction::I64Eq),
         (TYPE_ID_BOX_F64, g.box_f64_idx, Instruction::F64Eq),
         (TYPE_ID_BOX_I32, g.box_i32_idx, Instruction::I32Eq),
+        (TYPE_ID_BOX_BOOL, g.box_bool_idx, Instruction::I32Eq),
     ] {
         tid(&mut b, 0);
         Instruction::I32Const(id).encode(&mut b);
@@ -3461,7 +3508,7 @@ fn fvCollectBoundBlock(block: &ast::Block, bound: &mut std::collections::HashSet
 fn fvCollectPatternBindings(pat: &ast::CasePattern, bound: &mut std::collections::HashSet<String>) {
     match pat {
-        ast::CasePattern::Name(n) => {
+        ast::CasePattern::Name(n) if n != "True" && n != "False" => {
             bound.insert(n.clone());
         }
         ast::CasePattern::Class { fields, .. } => {
@@ -3711,7 +3758,7 @@ impl<'a> Collector<'a> {
         match pat {
             ast::CasePattern::Name(n) => {
                 let is_variant = n.chars().next().map(|c| c.is_uppercase()).unwrap_or(false)
-                    && self.enum_variants.contains_key(n);
+                    && (self.enum_variants.contains_key(n) || n == "True" || n == "False");
                 if !is_variant {
                     self.bind(n, ty.clone());
                 }
@@ -4169,11 +4216,8 @@ fn compileStmtInValuePosition(
 /// (each branch is `BlockType::Empty`, nothing left on the stack) or `Some(vt)` when this
 /// `if` is in value position — every branch must then leave a `vt` value on the stack, which
 /// requires an `else` (a value can't be produced on a path that doesn't exist).
-/// Compiles a `Bool`-typed expression, then a `ref.test` against the `True` variant's
+/// Compiles a `Bool`-typed expression (a plain wasm `i32`, 1/0) for use as a native
-/// concrete type, leaving a plain `i32` (1/0) on the stack. Every place a `Bool` value
-/// drives wasm's OWN native control flow (`if`/`br_if`, which require a raw `i32`
-/// condition, not a `ref`) goes through this — see this migration plan's Decision 1
-/// (Bool is a full wasm-gc struct, no special-casing).
+/// control-flow condition; `&&`/`||` short-circuit.
 fn compileBoolConditionAsI32(
     expr: &ast::Expr,
     body: &mut Vec<u8>,
@@ -4184,20 +4228,11 @@ fn compileBoolConditionAsI32(
     // alone executed) unless the left side's result already needs it — guarding
     // `i < len && s.byteAt(i) != ...` on the length check only works if `byteAt`
     // is never reached once `i < len` is false. Handled here (not just as a
-    // generic `Expr::Bool` case in `compileExpr` below) so a boolean used
+    // generic `Expr::Bool` case in `compileExpr` below).
-    // directly as an `if`/`while` condition never pays for constructing a real
-    // `Bool` ref just to immediately `ref.test` it back into an `i32`.
     if let ast::Expr::Bool(b) = expr {
         return compileShortCircuitBoolI32(b, body, ctx, state);
     }
-    compileExpr(expr, body, ctx, state)?;
+    compileExpr(expr, body, ctx, state)
-    let true_idx = *ctx
-        .gc_types
-        .variant_type_idx
-        .get("True")
-        .expect("internal codegen error: True must be registered in the GC type registry");
-    Instruction::RefTestNonNull(HeapType::Concrete(true_idx)).encode(body);
-    Ok(())
 }
 /// Leaves a short-circuited `i32` (1/0) on the stack for `b.left op b.right`:
@@ -4227,28 +4262,6 @@ fn compileShortCircuitBoolI32(
     Ok(())
 }
-/// Given an `i32` boolean (1/0) already on the stack, converts it into a `Bool` ref by
-/// selecting the pre-allocated `True`/`False` singleton (this migration plan's
-/// Decision 2) — the reverse of `compileBoolConditionAsI32`. Used wherever a native
-/// wasm comparison/logical-op instruction just left a raw `i32` predicate on the
-/// stack that needs to become a proper `Bool` value.
-fn pushBoolRefFromI32Flag(body: &mut Vec<u8>, ctx: &LocalCtx) {
-    let bool_ref_ty = plumTypeToValtype(&PlumType::TBool);
-    let true_global = *ctx
-        .singleton_globals
-        .get("True")
-        .expect("internal codegen error: True singleton global missing");
-    let false_global = *ctx
-        .singleton_globals
-        .get("False")
-        .expect("internal codegen error: False singleton global missing");
-    Instruction::If(BlockType::Result(bool_ref_ty)).encode(body);
-    Instruction::GlobalGet(true_global).encode(body);
-    Instruction::Else.encode(body);
-    Instruction::GlobalGet(false_global).encode(body);
-    Instruction::End.encode(body);
-}
 fn compileIf(
     if_: &ast::If,
     result_vt: Option<ValType>,
@@ -4322,12 +4335,7 @@ fn compileStmt(
                         // Convert to the representation the local was declared with
                         // (differs only across an erased/instantiated edge).
                         if let Some(decl) = ctx.local_decl_types.get(name) {
-                            coerceVt(
-                                plumTypeToValtype(&vty),
+                            coerceTy(&vty, decl, body, ctx.gc_types);
-                                plumTypeToValtype(decl),
-                                body,
-                                ctx.gc_types,
-                            );
                         }
                         Instruction::LocalSet(idx).encode(body);
                         ctx.type_env
@@ -4427,7 +4435,11 @@ fn compileStmt(
                 // Closure ABI: the result leaves as an `anyref`.
                 let rt_vt = ctx.ret_type.as_ref().map(plumTypeToValtype);
                 if let Some(vt) = rt_vt {
+                    if let Some(rt @ PlumType::TBool) = ctx.ret_type.as_ref() {
+                        coerceTy(rt, &anyTy(), body, ctx.gc_types);
+                    } else {
-                    coerceVt(vt, ValType::Ref(RefType::ANYREF), body, ctx.gc_types);
+                        coerceVt(vt, ValType::Ref(RefType::ANYREF), body, ctx.gc_types);
+                    }
                 }
             }
             Instruction::Return.encode(body);
@@ -4759,6 +4771,48 @@ fn matchCoversEveryEnumVariant(
     !tuples_seen.is_empty() && tuples_seen.len() == total_combinations
 }
+/// True if unguarded `True`/`False` arms between them cover every combination of
+/// `n` `Bool` subjects (the checker has already proven exhaustiveness).
+fn matchCoversEveryBoolCombo(cases: &[ast::Case], n: usize) -> bool {
+    let mut seen: std::collections::BTreeSet<Vec<bool>> = std::collections::BTreeSet::new();
+    for case in cases {
+        if case.guard.is_some() || case.patterns.len() != n {
+            continue;
+        }
+        let tuple: Option<Vec<Vec<bool>>> = case
+            .patterns
+            .iter()
+            .map(|p| match p {
+                ast::CasePattern::Name(nm) if nm == "True" => Some(vec![true]),
+                ast::CasePattern::Name(nm) if nm == "False" => Some(vec![false]),
+                ast::CasePattern::Wildcard => Some(vec![true, false]),
+                ast::CasePattern::Name(nm)
+                    if !nm.chars().next().is_some_and(|c| c.is_uppercase()) =>
+                {
+                    Some(vec![true, false])
+                }
+                _ => None,
+            })
+            .collect();
+        let Some(options) = tuple else { continue };
+        let mut combos: Vec<Vec<bool>> = vec![Vec::new()];
+        for opts in &options {
+            combos = combos
+                .into_iter()
+                .flat_map(|c| {
+                    opts.iter().map(move |b| {
+                        let mut c = c.clone();
+                        c.push(*b);
+                        c
+                    })
+                })
+                .collect();
+        }
+        seen.extend(combos);
+    }
+    n < 8 && seen.len() == 1usize << n
+}
 /// An uppercase `Name`/`Class` pattern — against a tag-union subject, a tag arm.
 fn isTagPattern(pat: &ast::CasePattern) -> bool {
     let upper = |n: &str| n.chars().next().is_some_and(|c| c.is_uppercase());
@@ -4885,8 +4939,14 @@ fn compileMatch(
             .match_subject_types
             .borrow()
             .contains_key(&all_subjects[0].1);
+    let bool_match = !m.subjects.is_empty()
+        && m.subjects
+            .iter()
+            .all(|e| matches!(inferLocalType(e, ctx), PlumType::TBool));
     let exhaustive_fallback = result_vt.is_some()
+        && (tag_union_match
+            || (bool_match && matchCoversEveryBoolCombo(&m.cases, m.subjects.len()))
-        && (tag_union_match || matchCoversEveryEnumVariant(&m.cases, &subject_vts, ctx));
+            || matchCoversEveryEnumVariant(&m.cases, &subject_vts, ctx));
     compileMatchArmsMulti(
         &m.cases,
@@ -5049,6 +5109,37 @@ fn compileCasePositions(
                 state,
             )
         }
+        // `True`/`False` against a `Bool` (i32) subject: a plain i32 compare.
+        ast::CasePattern::Name(n) if n == "True" || n == "False" => {
+            Instruction::LocalGet(scratch_local).encode(body);
+            if n == "False" {
+                Instruction::I32Eqz.encode(body);
+            }
+            Instruction::If(blockTypeFor(result_vt)).encode(body);
+            compileCasePositions(
+                case,
+                pos + 1,
+                all_subjects,
+                rest,
+                result_vt,
+                exhaustive_fallback,
+                body,
+                ctx,
+                state,
+            )?;
+            Instruction::Else.encode(body);
+            compileMatchArmsMulti(
+                rest,
+                all_subjects,
+                result_vt,
+                exhaustive_fallback,
+                body,
+                ctx,
+                state,
+            )?;
+            Instruction::End.encode(body);
+            Ok(())
+        }
         ast::CasePattern::Name(n) => {
             let is_variant = n.chars().next().map(|c| c.is_uppercase()).unwrap_or(false)
                 && ctx.enum_variants.contains_key(n);
@@ -5371,7 +5462,7 @@ fn compileFieldPatterns(
                         field_index: fld(fpos),
                     }
                     .encode(b);
-                    coerceVt(decl_vt, inst_vt, b, ctx.gc_types);
+                    coerceTy(decl_ty, field_ty, b, ctx.gc_types);
                 },
                 result_vt,
                 body,
@@ -5427,6 +5518,48 @@ fn compileFieldPatterns(
             state,
             on_match,
         ),
+        // A nested `True`/`False` against a `Bool` field: i32 compare.
+        ast::CasePattern::Name(n) if n == "True" || n == "False" => {
+            Instruction::LocalGet(container_local).encode(body);
+            Instruction::StructGet {
+                struct_type_index: container_type_idx,
+                field_index: fld(fpos),
+            }
+            .encode(body);
+            coerceTy(decl_ty, &PlumType::TBool, body, ctx.gc_types);
+            if n == "False" {
+                Instruction::I32Eqz.encode(body);
+            }
+            Instruction::If(blockTypeFor(result_vt)).encode(body);
+            compileFieldPatterns(
+                fields,
+                field_types,
+                inst_types,
+                fpos + 1,
+                container_local,
+                container_type_idx,
+                rest,
+                all_subjects,
+                result_vt,
+                exhaustive_fallback,
+                body,
+                ctx,
+                state,
+                on_match,
+            )?;
+            Instruction::Else.encode(body);
+            compileMatchArmsMulti(
+                rest,
+                all_subjects,
+                result_vt,
+                exhaustive_fallback,
+                body,
+                ctx,
+                state,
+            )?;
+            Instruction::End.encode(body);
+            Ok(())
+        }
         ast::CasePattern::Name(n)
             if !(n.chars().next().map(|c| c.is_uppercase()).unwrap_or(false)
                 && ctx.enum_variants.contains_key(n)) =>
@@ -5443,7 +5576,7 @@ fn compileFieldPatterns(
                 field_index: fld(fpos),
             }
             .encode(body);
-            coerceVt(decl_vt, inst_vt, body, ctx.gc_types);
+            coerceTy(decl_ty, field_ty, body, ctx.gc_types);
             Instruction::LocalSet(idx).encode(body);
             ctx.type_env
                 .borrow_mut()
@@ -5527,7 +5660,7 @@ fn compileFieldPatterns(
                 field_index: fld(fpos),
             }
             .encode(body);
-            coerceVt(decl_vt, inst_vt, body, ctx.gc_types);
+            coerceTy(decl_ty, field_ty, body, ctx.gc_types);
             Instruction::I64Const(*n).encode(body);
             Instruction::I64Eq.encode(body);
             Instruction::If(blockTypeFor(result_vt)).encode(body);
@@ -5698,8 +5831,7 @@ fn compileExpr(
                     // type may differ across an erased edge (a generic `T` slot read
                     // at its instantiated type).
                     if let Some(decl) = ctx.local_decl_types.get(name.as_str()) {
-                        let want = plumTypeToValtype(&inferLocalType(expr, ctx));
-                        coerceVt(plumTypeToValtype(decl), want, body, ctx.gc_types);
+                        coerceTy(decl, &inferLocalType(expr, ctx), body, ctx.gc_types);
                     }
                 }
                 // Not a local: a bare reference to a top-level function used as a
@@ -5772,14 +5904,13 @@ fn compileExpr(
                     })?;
             // The payload slot is declared at its generic type (`T` -> `$Obj`); the
             // value this expression yields is at its instantiated type.
-            let raw_success_vt = plumTypeToValtype(
+            let raw_success_ty = success_info
-                &success_info
-                    .field_types
+                .field_types
-                    .first()
+                .first()
-                    .cloned()
+                .cloned()
-                    .unwrap_or(PlumType::TUnit),
+                .unwrap_or(PlumType::TUnit);
-            );
+            let success_ty = inferLocalType(expr, ctx);
-            let success_vt = plumTypeToValtype(&inferLocalType(expr, ctx));
+            let success_vt = plumTypeToValtype(&success_ty);
             let key = expr as *const ast::Expr as usize;
             let slot = *ctx
@@ -5840,7 +5971,7 @@ fn compileExpr(
                     field_index: fld(0),
                 }
                 .encode(body);
-                coerceVt(raw_success_vt, success_vt, body, ctx.gc_types);
+                coerceTy(&raw_success_ty, &success_ty, body, ctx.gc_types);
             }
             Instruction::End.encode(body);
         }
@@ -5893,14 +6024,13 @@ fn compileExpr(
                             failure_name
                         )
                     })?;
-            let raw_success_vt = plumTypeToValtype(
+            let raw_success_ty = success_info
-                &success_info
-                    .field_types
+                .field_types
-                    .first()
+                .first()
-                    .cloned()
+                .cloned()
-                    .unwrap_or(PlumType::TUnit),
+                .unwrap_or(PlumType::TUnit);
-            );
+            let success_ty = inferLocalType(expr, ctx);
-            let success_vt = plumTypeToValtype(&inferLocalType(expr, ctx));
+            let success_vt = plumTypeToValtype(&success_ty);
             let key = expr as *const ast::Expr as usize;
             let slot = *ctx
@@ -5923,7 +6053,7 @@ fn compileExpr(
                     field_index: fld(0),
                 }
                 .encode(body);
-                coerceVt(raw_success_vt, success_vt, body, ctx.gc_types);
+                coerceTy(&raw_success_ty, &success_ty, body, ctx.gc_types);
             }
             Instruction::End.encode(body);
         }
@@ -5989,12 +6119,10 @@ fn compileExpr(
         }
         ast::Expr::Bool(b) => {
             compileShortCircuitBoolI32(b, body, ctx, state)?;
-            pushBoolRefFromI32Flag(body, ctx);
         }
         ast::Expr::Not(inner) => {
             compileBoolConditionAsI32(inner, body, ctx, state)?;
             Instruction::I32Eqz.encode(body);
-            pushBoolRefFromI32Flag(body, ctx);
         }
         ast::Expr::Compare(c) => {
             let left_ty = inferLocalType(&c.left, ctx);
@@ -6019,7 +6147,6 @@ fn compileExpr(
                         ))
                     }
                 }
-                pushBoolRefFromI32Flag(body, ctx);
                 return Ok(());
             }
             compileExpr(&c.left, body, ctx, state)?;
@@ -6085,7 +6212,17 @@ fn compileExpr(
                         ))
                     }
                 },
+                PlumType::TBool => match &c.op {
+                    ast::CmpOp::Eq => Instruction::I32Eq.encode(body),
+                    ast::CmpOp::Neq | ast::CmpOp::NotEq2 => Instruction::I32Ne.encode(body),
+                    other => {
+                        return Err(format!(
+                            "codegen: '{:?}' is not supported between Bool values",
+                            other
+                        ))
+                    }
+                },
-                // Bool/class/enum values are wasm-gc refs — `==`/`!=` compares
+                // Class/enum values are wasm-gc refs — `==`/`!=` compares
                 // reference identity via `ref.eq`. That's exactly right for a
                 // payload-free singleton (`End`/`True`/`False`, this migration
                 // plan's Decision 2) and for class-instance identity.
@@ -6104,7 +6241,6 @@ fn compileExpr(
                     }
                 },
             }
-            pushBoolRefFromI32Flag(body, ctx);
         }
         ast::Expr::Ternary(t) => {
             let result_vt = plumTypeToValtype(&inferLocalType(expr, ctx));
@@ -6243,6 +6379,9 @@ fn compileExpr(
                 .ok_or_else(|| "codegen: 'self' used outside a method".to_string())?;
             Instruction::LocalGet(idx).encode(body);
         }
+        ast::Expr::TypeName(n) if n == "True" || n == "False" => {
+            Instruction::I32Const((n == "True") as i32).encode(body);
+        }
         ast::Expr::TypeName(n) => {
             match ctx.enum_variants.get(n) {
                 // A bare uppercase name the checker typed as a tag union is a tag
@@ -6445,12 +6584,7 @@ fn coerceCallResultTo(decl_ret: &PlumType, want: &PlumType, body: &mut Vec<u8>,
     if matches!(decl_ret, PlumType::TUnit) || matches!(want, PlumType::TUnit | PlumType::TVar(_)) {
         return;
     }
-    coerceVt(
-        plumTypeToValtype(decl_ret),
+    coerceTy(decl_ret, want, body, ctx.gc_types);
-        plumTypeToValtype(want),
-        body,
-        ctx.gc_types,
-    );
 }
 /// Pushes the arguments of a call to the function described by `sig`: each fixed
@@ -6526,7 +6660,7 @@ fn compileFieldRead(
             ))
         }
     };
-    let want = plumTypeToValtype(&inferLocalType(expr, ctx));
+    let want = &inferLocalType(expr, ctx);
     // A discriminant enum's shared params are declared directly on the enum's
     // SUPERTYPE (see `buildGcTypeRegistry`'s `EnumSuper` arm) — no `ref.cast` to
     // any one variant needed.
@@ -6548,12 +6682,7 @@ fn compileFieldRead(
             field_index: fld(field_idx),
         }
         .encode(body);
-        coerceVt(
-            plumTypeToValtype(&params[field_idx].1),
+        coerceTy(&params[field_idx].1, want, body, ctx.gc_types);
-            want,
-            body,
-            ctx.gc_types,
-        );
         return Ok(());
     }
     // Not a discriminant enum: `class_name` is an ordinary enum, and the checker
@@ -6590,12 +6719,7 @@ fn compileFieldRead(
         field_index: fld(field_idx),
     }
     .encode(body);
-    coerceVt(
-        plumTypeToValtype(&info.field_types[field_idx]),
+    coerceTy(&info.field_types[field_idx], want, body, ctx.gc_types);
-        want,
-        body,
-        ctx.gc_types,
-    );
     Ok(())
 }
@@ -7025,12 +7149,8 @@ fn compileClosureLiteral(
             )
         })?;
         Instruction::LocalGet(local_idx).encode(body);
-        let have = ctx
-            .local_decl_types
-            .get(name)
-            .map(plumTypeToValtype)
-            .unwrap_or_else(|| plumTypeToValtype(cap_ty));
+        let have = ctx.local_decl_types.get(name).unwrap_or(cap_ty);
-        coerceVt(have, plumTypeToValtype(cap_ty), body, ctx.gc_types);
+        coerceTy(have, cap_ty, body, ctx.gc_types);
     }
     Instruction::StructNew(info.env_type_idx).encode(body);
     Instruction::StructNew(ctx.gc_types.closure_type_idx).encode(body);
@@ -7097,8 +7217,7 @@ fn compileClosureCall(
     if closureCallReturnsUnit(&call.name, ctx) {
         Instruction::Drop.encode(body);
     } else {
-        let want = plumTypeToValtype(&inferLocalType(call_expr, ctx));
+        coerceTy(&anyTy(), &inferLocalType(call_expr, ctx), body, ctx.gc_types);
-        coerceVt(any, want, body, ctx.gc_types);
     }
     Ok(())
 }
@@ -7163,12 +7282,12 @@ fn compileClosureBody(
     let mut idx = 0u32;
     idx += 1 + cl.params.len() as u32; // env + raw params (all in the signature)
-    let mut param_prologue: Vec<(u32, u32, ValType)> = Vec::new(); // (raw, typed, vt)
+    let mut param_prologue: Vec<(u32, u32, PlumType)> = Vec::new(); // (raw, typed, ptype)
     for (i, (name, pty)) in cl.params.iter().zip(info.param_ptypes.iter()).enumerate() {
         let vt = plumTypeToValtype(pty);
         locals.insert(name.clone(), idx);
         groups.push(vt);
-        param_prologue.push((i as u32 + 1, idx, vt));
+        param_prologue.push((i as u32 + 1, idx, pty.clone()));
         idx += 1;
     }
     for (name, ty) in &info.free_vars {
@@ -7228,9 +7347,9 @@ fn compileClosureBody(
     }
     // Prologue: convert each raw `anyref` param to its real representation.
-    for (raw, typed, vt) in &param_prologue {
+    for (raw, typed, pty) in &param_prologue {
         Instruction::LocalGet(*raw).encode(&mut body);
-        coerceVt(ValType::Ref(RefType::ANYREF), *vt, &mut body, &ctx.gc_types);
+        coerceTy(&anyTy(), pty, &mut body, &ctx.gc_types);
         Instruction::LocalSet(*typed).encode(&mut body);
     }
     // Restore each captured free variable from the env struct (local 0, statically
@@ -7280,14 +7399,13 @@ fn compileClosureBody(
         subject_ptypes: RefCell::new(HashMap::new()),
     };
-    let any = ValType::Ref(RefType::ANYREF);
     if matches!(info.ret_ptype, PlumType::TUnit) {
         compileBlockAsFnBody(&cl.body, &mut body, &local_ctx, state, None)?;
         Instruction::RefNull(HeapType::ANY).encode(&mut body);
     } else {
         let ret_vt = plumTypeToValtype(&info.ret_ptype);
         compileBlockAsFnBody(&cl.body, &mut body, &local_ctx, state, Some(ret_vt))?;
-        coerceVt(ret_vt, any, &mut body, &ctx.gc_types);
+        coerceTy(&info.ret_ptype, &anyTy(), &mut body, &ctx.gc_types);
     }
     Instruction::End.encode(&mut body);

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

@@ -1772,3 +1772,100 @@ fun main() -> Int =
     assert_eq!(maps.len(), 1, "got {:?}", keys);
     assert!(!keys.iter().any(|k| k.contains('$')), "mangled names remain");
 }
+// ---- built-in Bool (i32; no `import std/Bool`) ----
+#[test]
+fn builtin_bool_without_import() {
+    let src = "\
+import std/Str
+import std/Number
+fun flip(b: Bool) -> Bool =
+  !b
+fun name(b: Bool) -> Str =
+  match b
+    True => \"yes\"
+    False => \"no\"
+fun main() -> Int =
+  x := True
+  if flip(False) && x == True && !False || False
+    if name(x) == \"yes\" && name(False) == \"no\" && \"{x}\" == \"True\"
+      return 1
+  return 0
+";
+    assert_eq!(runMerged::<i64>("bool_noimport", src), 1);
+}
+#[test]
+fn builtin_bool_list_round_trip() {
+    let src = "\
+import std/Str
+import std/Number
+import std/List
+import std/Try
+fun main() -> Int =
+  l := List[Bool]()
+  l.push(True)
+  l.push(False)
+  l.push(True)
+  a := l.get(0) ?? False
+  b := l.get(1) ?? True
+  c := l.get(2) ?? False
+  if a && !b && c && l.length() == 3
+    return 1
+  return 0
+";
+    assert_eq!(runMerged::<i64>("bool_list", src), 1);
+}
+#[test]
+fn boxed_bool_to_str_and_eq() {
+    let src = "\
+import std/Str
+import std/Number
+fun show(x: ToStr) -> Str =
+  x.toStr()
+fun same(a: T, b: T) -> Bool =
+  a == b
+fun main() -> Int =
+  if show(True) == \"True\" && show(False) == \"False\" && same(True, True) && !same(True, False)
+    return 1
+  return 0
+";
+    assert_eq!(runMerged::<i64>("bool_boxed", src), 1);
+}
+#[test]
+fn builtin_bool_in_try_with_question_and_elvis() {
+    let src = "\
+import std/Str
+import std/Number
+import std/Try
+fun yes(ok: Bool) -> Try[Bool, [Nope]] =
+  if ok
+    Ok(True)
+  else
+    Err(Nope)
+fun chain(ok: Bool) -> Try[Bool, [Nope]] =
+  v := yes(ok)?
+  Ok(!v)
+fun main() -> Int =
+  a := chain(True) ?? True
+  b := chain(False) ?? True
+  p := Bool.parse(\"true\") ?? False
+  if !a && b && p
+    return 1
+  return 0
+";
+    assert_eq!(runMerged::<i64>("bool_try", src), 1);
+}