6c41056 | plum | pyrossh

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

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

6c41056 — Peter John 2026-10-25T19:30:30+05:30

feat: trait names as types with typeId-header dyn dispatch

Files changed (8) hide show

plum-checker/src/lib.rs +83 -7
plum-checker/tests/checker_tests.rs +70 -0
plum-cli/src/main.rs +6 -5
plum-examples/traits.plum +66 -0
plum-runtime/src/main.rs +6 -6
plum-wasm-codegen/src/lib.rs +507 -75
plum-wasm-codegen/tests/codegen_tests.rs +115 -0
plum-wasm-codegen/tests/examples_test.rs +2 -2

plum-checker/src/lib.rs CHANGED Viewed

@@ -432,6 +432,43 @@ const GLOBAL_KEY: &str = "$global:";
 const TRAIT_KEY: &str = "$trait:";
 /// `TypeEnv` key prefix for a generic parameter's trait bound (`$bound:K:Hashable`).
 const BOUND_KEY: &str = "$bound:";
+/// `methods` method-name marking a receiver name as a trait (see `buildTables`).
+pub const TRAIT_MARKER: &str = "$trait";
+/// The name of the first method `trait_name` declares that `actual` lacks, or
+/// `None` when `actual` implements the whole trait (or `trait_name` isn't one).
+/// Reuses the per-receiver method table: a primitive/variant also counts when
+/// its owning "union" enum (`Number` for `Int`) defines the method.
+pub fn traitMissingMethod(
+    trait_name: &str,
+    actual: &PlumType,
+    ctx: &CheckCtx,
+) -> Option<String> {
+    let key = (trait_name.to_string(), TRAIT_MARKER.to_string());
+    if !ctx.methods.contains_key(&key) {
+        return None;
+    }
+    let recv = methodReceiverName(actual);
+    let owner = recv.as_ref().and_then(|r| {
+        ctx.enum_variants.get(r.as_str()).map(|i| i.enum_name.clone())
+    });
+    ctx.methods
+        .range((trait_name.to_string(), String::new())..)
+        .take_while(|((r, _), _)| r == trait_name)
+        .map(|((_, m), _)| m)
+        .filter(|m| m.as_str() != TRAIT_MARKER)
+        .find(|m| {
+            let has = |r: &String| ctx.methods.contains_key(&(r.clone(), (*m).clone()));
+            !(recv.as_ref().is_some_and(has) || owner.as_ref().is_some_and(has))
+        })
+        .cloned()
+}
+/// True if `name` is a declared trait.
+pub fn isTraitName(name: &str, ctx: &CheckCtx) -> bool {
+    ctx.methods
+        .contains_key(&(name.to_string(), TRAIT_MARKER.to_string()))
+}
 pub fn plumTypeFromAst(ty: &ast::Type) -> PlumType {
     plumTypeFromName(&ty.name)
@@ -590,6 +627,20 @@ pub fn unify(t1: &PlumType, t2: &PlumType, ctx: &CheckCtx) -> Result<(), String>
             }
             unify(r1, r2, ctx)
         }
+        // A trait used as a type: any value implementing every trait method
+        // coerces to it (a bounded generic parameter is trusted).
+        (PlumType::TNamed(tr), actual) if isTraitName(tr, ctx) => {
+            if matches!(actual, PlumType::TParam(_)) {
+                return Ok(());
+            }
+            match traitMissingMethod(tr, actual, ctx) {
+                Some(m) => Err(format!(
+                    "type '{}' does not implement trait '{}': missing '{}'",
+                    actual, tr, m
+                )),
+                None => Ok(()),
+            }
+        }
         _ => Err(format!("type mismatch: expected {}, found {}", t1, t2)),
     }
 }
@@ -887,15 +938,40 @@ pub fn buildTables(
                 };
                 global_env.insert(c.name.clone(), TypeScheme::mono(ty));
             }
-            ast::Item::Trait(t) if generic => {
+            ast::Item::Trait(t) => {
+                // A trait name is also usable as a type (`s: Shape`): register it
+                // as a receiver in `methods` (a `$trait` marker plus one entry per
+                // declared method) so calls on a trait-typed value resolve to the
-                // Trait method signatures, looked up for calls on a bounded `TParam`.
+                // declared signature and `unify` can check implementers.
+                methods.insert(
+                    (t.name.clone(), TRAIT_MARKER.to_string()),
+                    PlumType::TFun(Vec::new(), Box::new(PlumType::TUnit)),
+                );
                 for m in &t.methods {
-                    let params: Vec<PlumType> = m.params.iter().map(|p| paramTypeG(&p.ty)).collect();
+                    let params: Vec<PlumType> = m
+                        .params
+                        .iter()
+                        .map(|p| match &p.ty {
+                            ast::ParamType::Type(ty) => conv(ty),
+                            ast::ParamType::Variadic(ty) => {
+                                PlumType::TVariadic(Box::new(conv(ty)))
+                            }
+                            ast::ParamType::Fn(ps, ret) => PlumType::TFun(
+                                ps.iter().map(&conv).collect(),
+                                Box::new(ret.as_ref().map(|r| conv(r)).unwrap_or(PlumType::TUnit)),
+                            ),
+                        })
+                        .collect();
                     let ret = m.returns.as_ref().map(&conv).unwrap_or(PlumType::TUnit);
+                    let sig = PlumType::TFun(params, Box::new(ret));
+                    methods.insert((t.name.clone(), m.name.clone()), sig.clone());
+                    if generic {
+                        // Looked up for calls on a bounded `TParam`.
-                    global_env.insert(
+                        global_env.insert(
-                        format!("{}{}:{}", TRAIT_KEY, t.name, m.name),
+                            format!("{}{}:{}", TRAIT_KEY, t.name, m.name),
-                        TypeScheme::mono(PlumType::TFun(params, Box::new(ret))),
+                            TypeScheme::mono(sig),
-                    );
+                        );
+                    }
                 }
             }
             _ => {}

plum-checker/tests/checker_tests.rs CHANGED Viewed

@@ -2224,3 +2224,73 @@ fn probe_nested_generic_substitution() {
     let m2 = "fun f() -> List[Int] =\n  List(items: 1).map(|x| x + 1)\n";
     assert!(checkSource(&parseClean(&format!("{}{}", GENERIC_DEFS, m2))).is_ok());
 }
+// ---- trait types (T3) ----
+const SHAPE_DEFS: &str = "\
+trait Shape =
+  area() -> Float
+enum Circle(Shape) =
+  | Circle(r: Float)
+  fun area(self) -> Float =
+    self.r
+enum Plain =
+  | Plain(n: Int)
+";
+#[test]
+fn trait_type_accepts_implementer() {
+    let src = format!(
+        "{}fun total(s: Shape) -> Float =\n  s.area()\n\nfun go() -> Float =\n  total(Circle(r: 2.0))\n",
+        SHAPE_DEFS
+    );
+    let r = checkSource(&parseClean(&src));
+    assert!(r.is_ok(), "got {:?}", r.err());
+}
+#[test]
+fn missing_trait_method_rejected_in_checker() {
+    let src = format!(
+        "{}fun total(s: Shape) -> Float =\n  s.area()\n\nfun go() -> Float =\n  total(Plain(n: 1))\n",
+        SHAPE_DEFS
+    );
+    let msg = errText(checkSource(&parseClean(&src)));
+    assert!(
+        msg.contains("type 'Plain' does not implement trait 'Shape': missing 'area'"),
+        "got {}",
+        msg
+    );
+}
+#[test]
+fn trait_method_call_has_declared_signature() {
+    let src = format!("{}fun f(s: Shape) -> Int =\n  s.area()\n", SHAPE_DEFS);
+    assert!(checkSource(&parseClean(&src)).is_err());
+}
+#[test]
+fn primitive_coerces_to_trait_via_number() {
+    let src = "\
+enum Number =
+  | Int
+  | Float
+  fun toStr(self) -> Str =
+    \"n\"
+trait ToStr =
+  toStr() -> Str
+fun show(x: ToStr) -> Str =
+  x.toStr()
+fun go() -> Str =
+  show(5)
+";
+    let r = checkSource(&parseClean(src));
+    assert!(r.is_ok(), "got {:?}", r.err());
+}

plum-cli/src/main.rs CHANGED Viewed

@@ -654,11 +654,11 @@ fn unwrapStrToArray(
     s: &wasmtime::Rooted<wasmtime::AnyRef>,
 ) -> wasmtime::Result<wasmtime::Rooted<wasmtime::ArrayRef>> {
     let str_struct = s.unwrap_struct(&store)?;
-    let wasmtime::Val::AnyRef(Some(buffer_ref)) = str_struct.field(&mut store, 0)? else {
+    let wasmtime::Val::AnyRef(Some(buffer_ref)) = str_struct.field(&mut store, 1)? else {
         return Err(wasmtime::Error::msg("Str.data is not a Buffer reference"));
     };
     let buffer_struct = buffer_ref.unwrap_struct(&store)?;
-    let wasmtime::Val::AnyRef(Some(bytes_ref)) = buffer_struct.field(&mut store, 0)? else {
+    let wasmtime::Val::AnyRef(Some(bytes_ref)) = buffer_struct.field(&mut store, 1)? else {
         return Err(wasmtime::Error::msg(
             "Buffer.data is not a []Byte reference",
         ));
@@ -708,7 +708,7 @@ fn makeStrResult(
         .ok_or_else(|| wasmtime::Error::msg("expected a concrete struct return type"))?
         .clone();
     let buffer_ty = str_ty
-        .field(0)
+        .field(1)
         .and_then(|f| match f.element_type() {
             wasmtime::StorageType::ValType(wasmtime::ValType::Ref(rt)) => {
                 rt.heap_type().as_concrete_struct().cloned()
@@ -719,7 +719,7 @@ fn makeStrResult(
             wasmtime::Error::msg("expected Str.data to be a concrete Buffer struct type")
         })?;
     let array_ty = buffer_ty
-        .field(0)
+        .field(1)
         .and_then(|f| match f.element_type() {
             wasmtime::StorageType::ValType(wasmtime::ValType::Ref(rt)) => {
                 rt.heap_type().as_concrete_array().cloned()
@@ -738,6 +738,7 @@ fn makeStrResult(
         &mut caller,
         &buffer_pre,
         &[
+            wasmtime::Val::I32(6), // Buffer typeId (see plum_wasm_codegen::TYPE_ID_BUFFER)
             wasmtime::Val::AnyRef(Some(arr.to_anyref())),
             wasmtime::Val::I64(bytes.len() as i64),
         ],
@@ -747,7 +748,7 @@ fn makeStrResult(
     let str_val = wasmtime::StructRef::new(
         &mut caller,
         &str_pre,
-        &[wasmtime::Val::AnyRef(Some(buffer.to_anyref()))],
+        &[wasmtime::Val::I32(5), wasmtime::Val::AnyRef(Some(buffer.to_anyref()))], // 5 = Str typeId
     )?;
     Ok(str_val.to_anyref())
 }

plum-examples/traits.plum ADDED Viewed

@@ -0,0 +1,66 @@
+import std/Bool
+import std/Str
+import std/Number
+import std/Try
+import std/List
+# A trait name is a type. Any value whose type implements every method the
+# trait declares can be passed where the trait is expected, and calling a
+# method on it dispatches on the value's runtime type id.
+trait Shape =
+  area() -> Float
+  name() -> Str
+enum Circle(Shape) =
+  | Circle(r: Float)
+  fun area(self) -> Float =
+    self.r * self.r * 3.0
+  fun name(self) -> Str =
+    "circle"
+enum Square(Shape) =
+  | Square(s: Float)
+  fun area(self) -> Float =
+    self.s * self.s
+  fun name(self) -> Str =
+    "square"
+enum Tagged(ToStr) =
+  | Tagged(label: Str)
+  fun toStr(self) -> Str =
+    "<{self.label}>"
+fun totalArea(shapes: List[Shape]) -> Float =
+  shapes.reduce(0.0, |acc, s| acc + s.area())
+fun describe(s: Shape) -> Str =
+  "{s.name()}"
+# Int, Float, Str and a user enum all flow through the same `ToStr` slot;
+# the Int and Float are boxed on the way in.
+fun show(x: ToStr) -> Str =
+  x.toStr()
+test "a heterogeneous List[Shape] sums its areas through dynamic dispatch"
+  shapes := List[Shape]()
+  shapes.add(Circle(r: 1.5))
+  shapes.add(Square(s: 1.5))
+  shapes.add(Circle(r: 0.5))
+  # 6.75 + 2.25 + 0.75
+  assert totalArea(shapes) == 9.75
+test "a method on a trait-typed value picks the implementor by runtime type"
+  assert describe(Circle(r: 1.0)) == "circle"
+  assert describe(Square(s: 1.0)) == "square"
+test "ToStr on mixed values: boxed Int, boxed Float, Str and an enum"
+  assert show(5) == "5"
+  assert show(-12) == "-12"
+  assert show(2.5) == "2.5"
+  assert show("hi") == "hi"
+  assert show(Tagged(label: "x")) == "<x>"

plum-runtime/src/main.rs CHANGED Viewed

@@ -282,11 +282,11 @@ fn unwrapStrToArray(
     s: &wasmtime::Rooted<wasmtime::AnyRef>,
 ) -> wasmtime::Result<wasmtime::Rooted<wasmtime::ArrayRef>> {
     let str_struct = s.unwrap_struct(&store)?;
-    let wasmtime::Val::AnyRef(Some(buffer_ref)) = str_struct.field(&mut store, 0)? else {
+    let wasmtime::Val::AnyRef(Some(buffer_ref)) = str_struct.field(&mut store, 1)? else {
         return Err(wasmtime::Error::msg("Str.data is not a Buffer reference"));
     };
     let buffer_struct = buffer_ref.unwrap_struct(&store)?;
-    let wasmtime::Val::AnyRef(Some(bytes_ref)) = buffer_struct.field(&mut store, 0)? else {
+    let wasmtime::Val::AnyRef(Some(bytes_ref)) = buffer_struct.field(&mut store, 1)? else {
         return Err(wasmtime::Error::msg("Buffer.data is not a []Byte reference"));
     };
     bytes_ref.unwrap_array(&store)
@@ -321,13 +321,13 @@ fn makeStrResult(
     let str_ty = ref_ty.heap_type().as_concrete_struct()
         .ok_or_else(|| wasmtime::Error::msg("expected a concrete struct return type"))?
         .clone();
-    let buffer_ty = str_ty.field(0)
+    let buffer_ty = str_ty.field(1)
         .and_then(|f| match f.element_type() {
             wasmtime::StorageType::ValType(wasmtime::ValType::Ref(rt)) => rt.heap_type().as_concrete_struct().cloned(),
             _ => None,
         })
         .ok_or_else(|| wasmtime::Error::msg("expected Str.data to be a concrete Buffer struct type"))?;
-    let array_ty = buffer_ty.field(0)
+    let array_ty = buffer_ty.field(1)
         .and_then(|f| match f.element_type() {
             wasmtime::StorageType::ValType(wasmtime::ValType::Ref(rt)) => rt.heap_type().as_concrete_array().cloned(),
             _ => None,
@@ -341,11 +341,11 @@ fn makeStrResult(
     let buffer = wasmtime::StructRef::new(
         &mut caller,
         &buffer_pre,
-        &[wasmtime::Val::AnyRef(Some(arr.to_anyref())), wasmtime::Val::I64(bytes.len() as i64)],
+        &[wasmtime::Val::I32(6), wasmtime::Val::AnyRef(Some(arr.to_anyref())), wasmtime::Val::I64(bytes.len() as i64)], // 6 = Buffer typeId
     )?;
     let str_pre = wasmtime::StructRefPre::new(&mut caller, str_ty);
-    let str_val = wasmtime::StructRef::new(&mut caller, &str_pre, &[wasmtime::Val::AnyRef(Some(buffer.to_anyref()))])?;
+    let str_val = wasmtime::StructRef::new(&mut caller, &str_pre, &[wasmtime::Val::I32(5), wasmtime::Val::AnyRef(Some(buffer.to_anyref()))])?; // 5 = Str typeId
     Ok(str_val.to_anyref())
 }

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

@@ -629,20 +629,52 @@ fn collectTagNames(s: &str, out: &mut std::collections::BTreeSet<String>) {
 /// reference values are stored as-is.
 fn boxTagPayload(ty: &PlumType, body: &mut Vec<u8>, ctx: &LocalCtx) {
     match plumTypeToValtype(ty) {
-        ValType::I64 => Instruction::StructNew(ctx.gc_types.box_i64_idx).encode(body),
+        ValType::I64 => Instruction::Call(ctx.gc_types.box_i64_fn).encode(body),
-        ValType::F64 => Instruction::StructNew(ctx.gc_types.box_f64_idx).encode(body),
+        ValType::F64 => Instruction::Call(ctx.gc_types.box_f64_fn).encode(body),
-        ValType::I32 => Instruction::StructNew(ctx.gc_types.box_i32_idx).encode(body),
+        ValType::I32 => Instruction::Call(ctx.gc_types.box_i32_fn).encode(body),
         _ => {}
     }
 }
+/// Boxes the primitive on top of the stack (`ty`) into its `$Box*` struct when
+/// it flows into a slot whose wasm type is `expected` and `ty` itself is not a
+/// reference — i.e. an `Int`/`Float`/`Byte` entering a trait-typed (`$Obj`) slot.
+fn boxIfPrimitiveIntoObj(ty: &PlumType, expected: ValType, body: &mut Vec<u8>, ctx: &LocalCtx) {
+    let ValType::Ref(rt) = expected else { return };
+    if rt.heap_type != HeapType::Concrete(ctx.gc_types.obj_type_idx) {
+        return;
+    }
+    if matches!(ty, PlumType::TInt | PlumType::TFloat | PlumType::TByte) {
+        boxTagPayload(ty, body, ctx);
+    }
+}
+/// Compiles `expr` and, if it is a primitive flowing into a trait-typed slot of
+/// wasm type `expected`, boxes it.
+fn compileExprAs(
+    expr: &ast::Expr,
+    expected: Option<ValType>,
+    body: &mut Vec<u8>,
+    ctx: &LocalCtx,
+    state: &mut ModuleState,
+) -> Result<(), String> {
+    compileExpr(expr, body, ctx, state)?;
+    if let Some(vt @ ValType::Ref(rt)) = expected {
+        if rt.heap_type == HeapType::Concrete(ctx.gc_types.obj_type_idx) {
+            let ty = inferLocalType(expr, ctx);
+            boxIfPrimitiveIntoObj(&ty, vt, body, ctx);
+        }
+    }
+    Ok(())
+}
 /// Inverse of `boxTagPayload`: an `anyref` payload on the stack becomes a `ty` value.
 fn unboxTagPayload(ty: &PlumType, body: &mut Vec<u8>, ctx: &LocalCtx) {
     let unbox = |idx: u32, body: &mut Vec<u8>| {
         Instruction::RefCastNonNull(HeapType::Concrete(idx)).encode(body);
         Instruction::StructGet {
             struct_type_index: idx,
-            field_index: 0,
+            field_index: fld(0),
         }
         .encode(body);
     };
@@ -668,6 +700,7 @@ fn compileTagLiteral(
     ctx: &LocalCtx,
     state: &mut ModuleState,
 ) -> Result<(), String> {
+    Instruction::I32Const(TYPE_ID_TAG).encode(body);
     Instruction::I32Const(tagId(name)).encode(body);
     match payload {
         Some(e) => {
@@ -866,6 +899,46 @@ pub struct GcTypeRegistry {
     pub box_i64_idx: u32,
     pub box_f64_idx: u32,
     pub box_i32_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
+    /// every value of that type (all variants of an enum share the enum's id).
+    pub type_ids: HashMap<String, i32>,
+    /// Box-helper function indices `(i64) -> $BoxI64`, `(f64) -> $BoxF64`,
+    /// `(i32) -> $BoxI32` (they push the header typeId themselves).
+    pub box_i64_fn: u32,
+    pub box_f64_fn: u32,
+    pub box_i32_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>,
+    /// `(trait, method)` -> its `$dyn$<Trait>$<method>` dispatcher function.
+    pub dyn_fns: HashMap<(String, String), u32>,
+}
+/// Box type ids (see the plan's Global constraints): 0 is `$Obj` itself.
+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;
+/// `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;
+/// First id handed to a declared class/enum, in declaration order.
+pub const TYPE_ID_FIRST_DECLARED: i32 = 16;
+/// Every class/enum/tag/box struct carries `typeId: i32` as field 0, so a
+/// declared field `i` lives at struct field `i + OBJ_HEADER_FIELDS`.
+const OBJ_HEADER_FIELDS: u32 = 1;
+/// Struct field index of declared payload field `i` (skipping the typeId header).
+fn fld(i: usize) -> u32 {
+    i as u32 + OBJ_HEADER_FIELDS
+}
+/// The runtime typeId of a variant/enum, or 0 when unknown.
+fn typeIdOf(r: &GcTypeRegistry, name: &str) -> i32 {
+    r.type_ids.get(name).copied().unwrap_or(0)
 }
 /// Whether `name` is `Array` itself or one of its monomorphized specializations
@@ -955,6 +1028,8 @@ fn buildGcTypeRegistry(
 ) -> GcTypeRegistry {
     enum Slot {
         Str,
+        /// `$Obj {typeId: i32}` — supertype of every struct below.
+        Obj,
         EnumSuper(String),
         Variant(String),
         /// The single shared `array<anyref>` type every `Array[T]`
@@ -968,13 +1043,17 @@ fn buildGcTypeRegistry(
     // Pass 1: assign every entry a slot (and therefore a type index) up front, before
     // any field list is built, so field-type resolution can reference ANY other entry.
-    let mut slots: Vec<Slot> = vec![Slot::Str];
+    let mut slots: Vec<Slot> = vec![Slot::Str, Slot::Obj];
+    let obj_type_idx: u32 = 1;
+    let mut type_ids: HashMap<String, i32> = HashMap::new();
+    let mut next_type_id = TYPE_ID_FIRST_DECLARED;
     let mut class_type_idx: HashMap<String, u32> = HashMap::new();
     let mut enum_super_type_idx: HashMap<String, u32> = HashMap::new();
     let mut variant_type_idx: HashMap<String, u32> = HashMap::new();
     let mut array_ref_slot: Option<u32> = None;
     let mut erased_enum_super: HashMap<String, u32> = HashMap::new();
     let mut erased_variant_idx: HashMap<String, u32> = HashMap::new();
+    let mut erased_enum_id: HashMap<String, i32> = HashMap::new();
     // `Bool` is an ordinary enum now (`type Bool = | True | False` in
     // `libs/std/Bool.plum`) — registered exactly like any other enum
@@ -988,6 +1067,12 @@ fn buildGcTypeRegistry(
             ));
         }
     }
+    // A trait name used as a type lowers to `ref null $Obj`.
+    for item in &source.items {
+        if let ast::Item::Trait(t) = item {
+            class_type_idx.insert(t.name.clone(), obj_type_idx);
+        }
+    }
     for (enum_name, variant_names) in &enum_decls {
         // `Array`/`Array$T` is a RECORD-shaped enum (single variant sharing the
         // enum's own name — the `type Array[T] = ...` replacement) whose values
@@ -1016,6 +1101,13 @@ fn buildGcTypeRegistry(
         let erased_enum = plum_checker::erasedEnumName(enum_name);
         if let Some(existing_super) = erased_enum_super.get(&erased_enum) {
             enum_super_type_idx.insert(enum_name.clone(), *existing_super);
+            // Shares the first specialization's wasm types, and so its typeId.
+            if let Some(first_id) = erased_enum_id.get(&erased_enum).copied() {
+                type_ids.insert(enum_name.clone(), first_id);
+                for vname in variant_names {
+                    type_ids.insert(vname.clone(), first_id);
+                }
+            }
             for vname in variant_names {
                 let ev = plum_checker::erasedEnumName(vname);
                 if let Some(idx) = erased_variant_idx.get(&ev) {
@@ -1028,6 +1120,20 @@ fn buildGcTypeRegistry(
             }
             continue;
         }
+        let this_id = match enum_name.as_str() {
+            "Str" => TYPE_ID_STR,
+            "Buffer" => TYPE_ID_BUFFER,
+            _ => {
+                let id = next_type_id;
+                next_type_id += 1;
+                id
+            }
+        };
+        type_ids.insert(enum_name.clone(), this_id);
+        for vname in variant_names {
+            type_ids.insert(vname.clone(), this_id);
+        }
+        erased_enum_id.insert(erased_enum.clone(), this_id);
         enum_super_type_idx.insert(enum_name.clone(), slots.len() as u32);
         erased_enum_super.insert(erased_enum, slots.len() as u32);
         slots.push(Slot::EnumSuper(enum_name.clone()));
@@ -1072,6 +1178,13 @@ fn buildGcTypeRegistry(
         box_i64_idx,
         box_f64_idx,
         box_i32_idx,
+        obj_type_idx,
+        type_ids,
+        box_i64_fn: 0,
+        box_f64_fn: 0,
+        box_i32_fn: 0,
+        mk_str_fn: None,
+        dyn_fns: HashMap::new(),
     };
     // Pass 2: build the real SubType for every slot, now that every cross-reference
@@ -1101,16 +1214,14 @@ fn buildGcTypeRegistry(
             // trap at runtime whenever `self` isn't actually THAT variant).
             Slot::EnumSuper(enum_name) => {
                 let params = enum_params.get(enum_name).cloned().unwrap_or_default();
-                let field_types: Vec<FieldType> = params
+                let mut field_types: Vec<FieldType> = vec![typeIdField()];
-                    .iter()
-                    .map(|(_, ty)| FieldType {
+                field_types.extend(params.iter().map(|(_, ty)| FieldType {
-                        element_type: StorageType::Val(plumTypeToGcValtype(ty, &registry)),
+                    element_type: StorageType::Val(plumTypeToGcValtype(ty, &registry)),
-                        mutable: true,
+                    mutable: true,
-                    })
+                }));
-                    .collect();
                 SubType {
                     is_final: false,
-                    supertype_idx: None,
+                    supertype_idx: Some(obj_type_idx),
                     composite_type: CompositeType {
                         inner: CompositeInnerType::Struct(StructType {
                             fields: field_types.into(),
@@ -1139,14 +1250,11 @@ fn buildGcTypeRegistry(
                 // supertype's own fields (see the `EnumSuper` arm above) — a variant with
                 // zero ADDED fields beyond its supertype is still valid wasm-gc
                 // subtyping, so no special-casing is needed here.
-                let field_types: Vec<FieldType> = info
+                let mut field_types: Vec<FieldType> = vec![typeIdField()];
-                    .field_types
-                    .iter()
-                    .map(|ty| FieldType {
+                field_types.extend(info.field_types.iter().map(|ty| FieldType {
-                        element_type: StorageType::Val(plumTypeToGcValtype(ty, &registry)),
+                    element_type: StorageType::Val(plumTypeToGcValtype(ty, &registry)),
-                        mutable: true,
+                    mutable: true,
-                    })
+                }));
-                    .collect();
                 SubType {
                     is_final: true,
                     supertype_idx: Some(super_idx),
@@ -1158,12 +1266,23 @@ fn buildGcTypeRegistry(
                     },
                 }
             }
+            Slot::Obj => SubType {
+                is_final: false,
+                supertype_idx: None,
+                composite_type: CompositeType {
+                    inner: CompositeInnerType::Struct(StructType {
+                        fields: vec![typeIdField()].into(),
+                    }),
+                    shared: false,
+                },
+            },
             Slot::Tag => SubType {
                 is_final: true,
-                supertype_idx: None,
+                supertype_idx: Some(obj_type_idx),
                 composite_type: CompositeType {
                     inner: CompositeInnerType::Struct(StructType {
                         fields: vec![
+                            typeIdField(),
                             FieldType {
                                 element_type: StorageType::Val(ValType::I32),
                                 mutable: false,
@@ -1178,9 +1297,9 @@ fn buildGcTypeRegistry(
                     shared: false,
                 },
             },
-            Slot::BoxI64 => boxSubType(ValType::I64),
+            Slot::BoxI64 => boxSubType(ValType::I64, obj_type_idx),
-            Slot::BoxF64 => boxSubType(ValType::F64),
+            Slot::BoxF64 => boxSubType(ValType::F64, obj_type_idx),
-            Slot::BoxI32 => boxSubType(ValType::I32),
+            Slot::BoxI32 => boxSubType(ValType::I32, obj_type_idx),
             Slot::ArrayRef => SubType {
                 is_final: true,
                 supertype_idx: None,
@@ -1200,16 +1319,27 @@ fn buildGcTypeRegistry(
     registry
 }
+/// The immutable `typeId: i32` header field every `$Obj` subtype starts with.
+fn typeIdField() -> FieldType {
+    FieldType {
+        element_type: StorageType::Val(ValType::I32),
+        mutable: false,
+    }
+}
-fn boxSubType(vt: ValType) -> SubType {
+fn boxSubType(vt: ValType, obj_type_idx: u32) -> SubType {
     SubType {
         is_final: true,
-        supertype_idx: None,
+        supertype_idx: Some(obj_type_idx),
         composite_type: CompositeType {
             inner: CompositeInnerType::Struct(StructType {
-                fields: vec![FieldType {
+                fields: vec![
+                    typeIdField(),
+                    FieldType {
-                    element_type: StorageType::Val(vt),
+                        element_type: StorageType::Val(vt),
-                    mutable: false,
+                        mutable: false,
-                }]
+                    },
+                ]
                 .into(),
             }),
             shared: false,
@@ -1647,13 +1777,43 @@ fn compileSourceInner(
         let global_idx = module.addGlobal(gcRef(variant_idx), true, &init);
         singleton_globals.insert(name.clone(), global_idx);
+        // A payload-free variant is exactly `{typeId}`.
+        Instruction::I32Const(typeIdOf(&gc_types, name)).encode(&mut start_body);
-        Instruction::StructNewDefault(variant_idx).encode(&mut start_body);
+        Instruction::StructNew(variant_idx).encode(&mut start_body);
         Instruction::GlobalSet(global_idx).encode(&mut start_body);
     }
     let start_type_idx = module.addType(&[], &[]);
     let start_func_idx = module.addFunction(start_type_idx, &[]);
     module.setStartFunction(start_func_idx);
+    // Box helpers (`i64 -> $BoxI64`, ...) and the `Str` builder push the header
+    // typeId themselves, so callers only supply the payload.
+    gc_types.box_i64_fn =
+        registerBoxHelper(&mut module, ValType::I64, TYPE_ID_BOX_I64, gc_types.box_i64_idx);
+    gc_types.box_f64_fn =
+        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);
+    if let (Some(&buffer_idx), Some(&str_idx)) = (
+        gc_types.class_type_idx.get("Buffer"),
+        gc_types.class_type_idx.get("Str"),
+    ) {
+        let mut b = vec![0u8];
+        Instruction::I32Const(TYPE_ID_STR).encode(&mut b);
+        Instruction::I32Const(TYPE_ID_BUFFER).encode(&mut b);
+        Instruction::LocalGet(0).encode(&mut b);
+        Instruction::LocalGet(1).encode(&mut b);
+        Instruction::StructNew(buffer_idx).encode(&mut b);
+        Instruction::StructNew(str_idx).encode(&mut b);
+        Instruction::End.encode(&mut b);
+        let t = module.addType(
+            &[gcRef(gc_types.byte_array_type_idx), ValType::I64],
+            &[gcRef(str_idx)],
+        );
+        gc_types.mk_str_fn = Some(module.addFunction(t, &b));
+    }
+    CURRENT_GC_TYPES.with(|c| *c.borrow_mut() = Some(gc_types.clone()));
     // Closure wasm signature -> function-type index, deduped so every closure/call site
     // of the same shape shares one `call_indirect` type.
     let mut closure_call_types: HashMap<ClosureSigKey, u32> = HashMap::new();
@@ -1706,6 +1866,17 @@ fn compileSourceInner(
         }
     }
+    registerDynDispatchers(
+        &mut module,
+        source,
+        &methods,
+        &enum_variants,
+        &func_ids,
+        &func_sigs,
+        &mut gc_types,
+    );
+    CURRENT_GC_TYPES.with(|c| *c.borrow_mut() = Some(gc_types.clone()));
     let fns: Vec<&ast::Fn> = source
         .items
         .iter()
@@ -1995,6 +2166,177 @@ fn compileSourceInner(
     Ok(module.finish())
 }
+/// `(payload) -> ref $Box*`: allocates a box with its header typeId set.
+fn registerBoxHelper(module: &mut WasmModule, vt: ValType, type_id: i32, box_idx: u32) -> u32 {
+    let mut b = vec![0u8];
+    Instruction::I32Const(type_id).encode(&mut b);
+    Instruction::LocalGet(0).encode(&mut b);
+    Instruction::StructNew(box_idx).encode(&mut b);
+    Instruction::End.encode(&mut b);
+    let t = module.addType(&[vt], &[gcRef(box_idx)]);
+    module.addFunction(t, &b)
+}
+/// Emits one `$dyn$<Trait>$<method>(self: ref null $Obj, args...)` dispatcher per
+/// trait method that has at least one implementor: it reads the receiver's
+/// `typeId` and calls the matching concrete method. Declared enums dispatch by
+/// their own id; boxed `Int`/`Float`/`Byte` unbox and call the primitive's method
+/// (or, for `Int`/`Float`, wrap into the "union" enum such as `Number` that
+/// defines it — the same fallback a direct `x.toStr()` call uses). Only methods
+/// present in `func_ids` (i.e. actually compiled) are ever referenced.
+fn registerDynDispatchers(
+    module: &mut WasmModule,
+    source: &ast::Source,
+    methods: &MethodEnv,
+    enum_variants: &EnumVariants,
+    func_ids: &HashMap<String, u32>,
+    func_sigs: &HashMap<String, FuncSig>,
+    gc_types: &mut GcTypeRegistry,
+) {
+    let obj_idx = gc_types.obj_type_idx;
+    let enum_names: Vec<&str> = source
+        .items
+        .iter()
+        .filter_map(|i| match i {
+            ast::Item::Enum(e) if !isArraySpecialization(&e.name) => Some(e.name.as_str()),
+            _ => None,
+        })
+        .collect();
+    let mut registered: Vec<((String, String), u32)> = Vec::new();
+    for item in &source.items {
+        let ast::Item::Trait(t) = item else { continue };
+        for m in &t.methods {
+            let key = (t.name.clone(), m.name.clone());
+            let Some(PlumType::TFun(ps, ret)) = methods.get(&key) else {
+                continue;
+            };
+            if ps
+                .iter()
+                .any(|p| matches!(p, PlumType::TVariadic(_) | PlumType::TFun(..)))
+            {
+                continue;
+            }
+            let params_vt: Vec<ValType> = ps.iter().map(plumTypeToValtype).collect();
+            let ret_vt: Option<ValType> = if **ret == PlumType::TUnit {
+                None
+            } else {
+                Some(plumTypeToValtype(ret))
+            };
+            let sig_matches = |fkey: &str| {
+                func_sigs
+                    .get(fkey)
+                    .is_some_and(|s| s.params.get(1..) == Some(&params_vt[..]) && s.ret == ret_vt)
+            };
+            // (typeId, arm code) — code leaves the call result on the stack.
+            let mut arms: Vec<(i32, Vec<u8>)> = Vec::new();
+            let push_args = |b: &mut Vec<u8>| {
+                for i in 0..params_vt.len() {
+                    Instruction::LocalGet(i as u32 + 1).encode(b);
+                }
+            };
+            let mut seen_ids = std::collections::HashSet::new();
+            for en in &enum_names {
+                let fkey = format!("{}::{}", en, m.name);
+                let Some(&fidx) = func_ids.get(&fkey) else { continue };
+                let id = typeIdOf(gc_types, en);
+                if id == 0 || !sig_matches(&fkey) || !seen_ids.insert(id) {
+                    continue;
+                }
+                let Some(ValType::Ref(self_rt)) = func_sigs.get(&fkey).and_then(|s| s.params.first().copied())
+                else {
+                    continue;
+                };
+                let mut b = Vec::new();
+                Instruction::LocalGet(0).encode(&mut b);
+                Instruction::RefCastNullable(self_rt.heap_type).encode(&mut b);
+                push_args(&mut b);
+                Instruction::Call(fidx).encode(&mut b);
+                arms.push((id, b));
+            }
+            // Boxed primitives.
+            for (prim, vt, box_idx, tid) in [
+                ("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),
+            ] {
+                let direct = format!("{}::{}", prim, m.name);
+                let mut b = Vec::new();
+                if func_ids.contains_key(&direct)
+                    && sig_matches(&direct)
+                    && func_sigs.get(&direct).and_then(|s| s.params.first().copied()) == Some(vt)
+                {
+                    Instruction::LocalGet(0).encode(&mut b);
+                    Instruction::RefCastNonNull(HeapType::Concrete(box_idx)).encode(&mut b);
+                    Instruction::StructGet {
+                        struct_type_index: box_idx,
+                        field_index: fld(0),
+                    }
+                    .encode(&mut b);
+                    push_args(&mut b);
+                    Instruction::Call(func_ids[&direct]).encode(&mut b);
+                } else if let Some(info) = enum_variants.get(prim) {
+                    let wrap_key = format!("{}::{}", info.enum_name, m.name);
+                    let (Some(&fidx), Some(&variant_idx)) =
+                        (func_ids.get(&wrap_key), gc_types.variant_type_idx.get(prim))
+                    else {
+                        continue;
+                    };
+                    if !sig_matches(&wrap_key) {
+                        continue;
+                    }
+                    Instruction::I32Const(typeIdOf(gc_types, prim)).encode(&mut b);
+                    Instruction::LocalGet(0).encode(&mut b);
+                    Instruction::RefCastNonNull(HeapType::Concrete(box_idx)).encode(&mut b);
+                    Instruction::StructGet {
+                        struct_type_index: box_idx,
+                        field_index: fld(0),
+                    }
+                    .encode(&mut b);
+                    Instruction::StructNew(variant_idx).encode(&mut b);
+                    push_args(&mut b);
+                    Instruction::Call(fidx).encode(&mut b);
+                } else {
+                    continue;
+                }
+                arms.push((tid, b));
+            }
+            if arms.is_empty() {
+                continue;
+            }
+            let mut all_params = vec![gcRef(obj_idx)];
+            all_params.extend(params_vt.iter().copied());
+            let results: Vec<ValType> = ret_vt.into_iter().collect();
+            let tid_local = all_params.len() as u32;
+            let mut body = Vec::new();
+            body.extend(encodeLeb128U32(1));
+            body.extend(encodeLeb128U32(1));
+            ValType::I32.encode(&mut body);
+            Instruction::LocalGet(0).encode(&mut body);
+            Instruction::StructGet {
+                struct_type_index: obj_idx,
+                field_index: 0,
+            }
+            .encode(&mut body);
+            Instruction::LocalSet(tid_local).encode(&mut body);
+            for (id, code) in &arms {
+                Instruction::LocalGet(tid_local).encode(&mut body);
+                Instruction::I32Const(*id).encode(&mut body);
+                Instruction::I32Eq.encode(&mut body);
+                Instruction::If(BlockType::Empty).encode(&mut body);
+                body.extend(code);
+                Instruction::Return.encode(&mut body);
+                Instruction::End.encode(&mut body);
+            }
+            Instruction::Unreachable.encode(&mut body);
+            Instruction::End.encode(&mut body);
+            let t = module.addType(&all_params, &results);
+            let fidx = module.addFunction(t, &body);
+            registered.push((key, fidx));
+        }
+    }
+    gc_types.dyn_fns.extend(registered);
+}
 /// Registers `__string_concat(a: ref Str, b: ref Str) -> ref Str`, a hand-written
 /// runtime helper backing string interpolation. Unwraps both `Str` params down
 /// to their raw `array<i8>`s (`unwrapStrToBytes`) — which each track their own
@@ -2451,9 +2793,10 @@ fn wrapBytesAsStr(body: &mut Vec<u8>, push_len: impl FnOnce(&mut Vec<u8>)) {
     let Some((buffer_type_idx, str_type_idx)) = types else {
         return;
     };
+    let _ = (buffer_type_idx, str_type_idx);
     push_len(body);
-    Instruction::StructNew(buffer_type_idx).encode(body);
+    let mk = withGcTypes(|r| r.mk_str_fn).expect("mk_str_fn registered with Str/Buffer");
-    Instruction::StructNew(str_type_idx).encode(body);
+    Instruction::Call(mk).encode(body);
 }
 /// The inverse of `wrapBytesAsStr`: given a `Str` value already on the stack,
@@ -2474,12 +2817,12 @@ fn unwrapStrToBytes(body: &mut Vec<u8>) {
     };
     Instruction::StructGet {
         struct_type_index: str_type_idx,
-        field_index: 0,
+        field_index: fld(0),
     }
     .encode(body);
     Instruction::StructGet {
         struct_type_index: buffer_type_idx,
-        field_index: 0,
+        field_index: fld(0),
     }
     .encode(body);
 }
@@ -3879,7 +4222,7 @@ fn compileStmtInValuePosition(
     state: &mut ModuleState,
 ) -> Result<(), String> {
     match stmt {
-        ast::Stmt::Expr(e, ..) => compileExpr(e, body, ctx, state),
+        ast::Stmt::Expr(e, ..) => compileExprAs(e, Some(result_vt), body, ctx, state),
         ast::Stmt::Return(_) | ast::Stmt::Todo | ast::Stmt::Crash(_) => {
             compileStmt(stmt, body, ctx, state)
         }
@@ -4116,7 +4459,7 @@ fn compileStmt(
                                 compileExpr(value, body, ctx, state)?;
                                 Instruction::StructSet {
                                     struct_type_index: super_type_idx,
-                                    field_index: field_idx as u32,
+                                    field_index: fld(field_idx),
                                 }
                                 .encode(body);
                             }
@@ -4147,7 +4490,7 @@ fn compileStmt(
                                 compileExpr(value, body, ctx, state)?;
                                 Instruction::StructSet {
                                     struct_type_index: variant_type_idx,
-                                    field_index: field_idx as u32,
+                                    field_index: fld(field_idx),
                                 }
                                 .encode(body);
                             }
@@ -4157,7 +4500,7 @@ fn compileStmt(
             }
         }
         ast::Stmt::Return(Some(e)) => {
-            compileExpr(e, body, ctx, state)?;
+            compileExprAs(e, ctx.ret_type.as_ref().map(plumTypeToValtype), body, ctx, state)?;
             Instruction::Return.encode(body);
         }
         ast::Stmt::Return(None) => {
@@ -4501,7 +4844,7 @@ fn compileTagPattern(
     load(body);
     Instruction::StructGet {
         struct_type_index: tag_idx,
-        field_index: 0,
+        field_index: fld(0),
     }
     .encode(body);
     Instruction::I32Const(tagId(name)).encode(body);
@@ -4516,7 +4859,7 @@ fn compileTagPattern(
             load(body);
             Instruction::StructGet {
                 struct_type_index: tag_idx,
-                field_index: 1,
+                field_index: fld(1),
             }
             .encode(body);
             unboxTagPayload(pty, body, ctx);
@@ -5056,7 +5399,7 @@ fn compileFieldPatterns(
                     Instruction::LocalGet(container_local).encode(b);
                     Instruction::StructGet {
                         struct_type_index: container_type_idx,
-                        field_index: fpos as u32,
+                        field_index: fld(fpos),
                     }
                     .encode(b);
                 },
@@ -5125,7 +5468,7 @@ fn compileFieldPatterns(
             Instruction::LocalGet(container_local).encode(body);
             Instruction::StructGet {
                 struct_type_index: container_type_idx,
-                field_index: fpos as u32,
+                field_index: fld(fpos),
             }
             .encode(body);
             Instruction::LocalSet(idx).encode(body);
@@ -5166,7 +5509,7 @@ fn compileFieldPatterns(
             Instruction::LocalGet(container_local).encode(body);
             Instruction::StructGet {
                 struct_type_index: container_type_idx,
-                field_index: fpos as u32,
+                field_index: fld(fpos),
             }
             .encode(body);
             Instruction::RefTestNonNull(HeapType::Concrete(variant_idx)).encode(body);
@@ -5206,7 +5549,7 @@ fn compileFieldPatterns(
             Instruction::LocalGet(container_local).encode(body);
             Instruction::StructGet {
                 struct_type_index: container_type_idx,
-                field_index: fpos as u32,
+                field_index: fld(fpos),
             }
             .encode(body);
             Instruction::I64Const(*n).encode(body);
@@ -5285,7 +5628,7 @@ fn compileFieldPatterns(
             Instruction::LocalGet(container_local).encode(body);
             Instruction::StructGet {
                 struct_type_index: container_type_idx,
-                field_index: fpos as u32,
+                field_index: fld(fpos),
             }
             .encode(body);
             Instruction::RefTestNonNull(HeapType::Concrete(inner_variant_idx)).encode(body);
@@ -5294,7 +5637,7 @@ fn compileFieldPatterns(
             Instruction::LocalGet(container_local).encode(body);
             Instruction::StructGet {
                 struct_type_index: container_type_idx,
-                field_index: fpos as u32,
+                field_index: fld(fpos),
             }
             .encode(body);
             Instruction::RefCastNonNull(HeapType::Concrete(inner_variant_idx)).encode(body);
@@ -5457,8 +5800,6 @@ fn compileExpr(
             Instruction::LocalTee(scratch_local).encode(body);
             Instruction::RefTestNonNull(HeapType::Concrete(failure_idx)).encode(body);
             Instruction::If(BlockType::Result(success_vt)).encode(body);
-            Instruction::LocalGet(scratch_local).encode(body);
-            Instruction::RefCastNonNull(HeapType::Concrete(failure_idx)).encode(body);
             // Failure branch: take the inner `Err` payload and build the OUTER
             // function's `Err` variant from it (the Ok types may differ).
             let outer_err = match &ctx.ret_type {
@@ -5468,6 +5809,7 @@ fn compileExpr(
                 }
                 _ => None,
             };
+            let mut rewrap: Option<(u32, i32)> = None;
             if let Some(outer_err_name) = outer_err {
                 let outer_idx = *ctx
                     .gc_types
@@ -5480,14 +5822,22 @@ fn compileExpr(
                         )
                     })?;
                 if outer_idx != failure_idx {
-                    Instruction::StructGet {
-                        struct_type_index: failure_idx,
-                        field_index: 0,
-                    }
-                    .encode(body);
-                    Instruction::StructNew(outer_idx).encode(body);
+                    rewrap = Some((outer_idx, typeIdOf(ctx.gc_types, outer_err_name)));
                 }
             }
+            if let Some((_, tid)) = rewrap {
+                Instruction::I32Const(tid).encode(body);
+            }
+            Instruction::LocalGet(scratch_local).encode(body);
+            Instruction::RefCastNonNull(HeapType::Concrete(failure_idx)).encode(body);
+            if let Some((outer_idx, _)) = rewrap {
+                Instruction::StructGet {
+                    struct_type_index: failure_idx,
+                    field_index: fld(0),
+                }
+                .encode(body);
+                Instruction::StructNew(outer_idx).encode(body);
+            }
             Instruction::Return.encode(body);
             Instruction::Else.encode(body);
             Instruction::LocalGet(scratch_local).encode(body);
@@ -5495,7 +5845,7 @@ fn compileExpr(
             if !success_info.field_types.is_empty() {
                 Instruction::StructGet {
                     struct_type_index: success_idx,
-                    field_index: 0,
+                    field_index: fld(0),
                 }
                 .encode(body);
             }
@@ -5576,7 +5926,7 @@ fn compileExpr(
             if !success_info.field_types.is_empty() {
                 Instruction::StructGet {
                     struct_type_index: success_idx,
-                    field_index: 0,
+                    field_index: fld(0),
                 }
                 .encode(body);
             }
@@ -5660,7 +6010,7 @@ fn compileExpr(
                     compileExpr(side, body, ctx, state)?;
                     Instruction::StructGet {
                         struct_type_index: tag_idx,
-                        field_index: 0,
+                        field_index: fld(0),
                     }
                     .encode(body);
                 }
@@ -5883,10 +6233,15 @@ fn compileExpr(
                     },
                     _ => None,
                 };
+                let sig_params: Vec<ValType> = ctx
+                    .func_sigs
+                    .get(&call.name)
+                    .map(|s| s.params.clone())
+                    .unwrap_or_default();
                 match variadic_split {
                     Some((elem_ty, fixed_count)) => {
-                        for arg in call.args.iter().take(fixed_count) {
+                        for (i, arg) in call.args.iter().take(fixed_count).enumerate() {
-                            compileExpr(argExprOf(arg), body, ctx, state)?;
+                            compileExprAs(argExprOf(arg), sig_params.get(i).copied(), body, ctx, state)?;
                         }
                         let trailing: Vec<&ast::Expr> =
                             call.args.iter().skip(fixed_count).map(argExprOf).collect();
@@ -5897,7 +6252,7 @@ fn compileExpr(
                             .get(&elem_vt)
                             .ok_or_else(|| "internal codegen error: no variadic array type registered for this elem type".to_string())?;
                         for arg_expr in &trailing {
-                            compileExpr(arg_expr, body, ctx, state)?;
+                            compileExprAs(arg_expr, Some(elem_vt), body, ctx, state)?;
                         }
                         Instruction::ArrayNewFixed {
                             array_type_index: array_type_idx,
@@ -5912,8 +6267,8 @@ fn compileExpr(
                         Instruction::Call(*func_idx).encode(body);
                     }
                     None => {
-                        for arg in &call.args {
+                        for (i, arg) in call.args.iter().enumerate() {
-                            compileExpr(argExprOf(arg), body, ctx, state)?;
+                            compileExprAs(argExprOf(arg), sig_params.get(i).copied(), body, ctx, state)?;
                         }
                         compileDefaultArgs(&call.name, call.args.len(), body, ctx, state)?;
                         let func_idx = ctx
@@ -6033,9 +6388,16 @@ fn compileExpr(
                     )
                 })?;
             let field_names = info.field_names.clone();
+            Instruction::I32Const(typeIdOf(ctx.gc_types, &call.type_name)).encode(body);
             for (field_idx, field_name) in field_names.iter().enumerate() {
                 match call.fields.iter().find(|fa| &fa.name == field_name) {
-                    Some(fa) => compileExpr(&fa.value, body, ctx, state)?,
+                    Some(fa) => compileExprAs(
+                        &fa.value,
+                        info.field_types.get(field_idx).map(plumTypeToValtype),
+                        body,
+                        ctx,
+                        state,
+                    )?,
                     // `Circle(..c, radius: 10)` — a field not overridden is read
                     // straight off the spread source instead (checker only proved
                     // `c` is SOME value of the owning enum, restricted to a bare
@@ -6056,7 +6418,7 @@ fn compileExpr(
                         Instruction::RefCastNonNull(HeapType::Concrete(variant_idx)).encode(body);
                         Instruction::StructGet {
                             struct_type_index: variant_idx,
-                            field_index: field_idx as u32,
+                            field_index: fld(field_idx),
                         }
                         .encode(body);
                     }
@@ -6123,7 +6485,7 @@ fn compileExpr(
                             compileExpr(&attr.object, body, ctx, state)?;
                             Instruction::StructGet {
                                 struct_type_index: super_type_idx,
-                                field_index: field_idx as u32,
+                                field_index: fld(field_idx),
                             }
                             .encode(body);
                         }
@@ -6172,7 +6534,7 @@ fn compileExpr(
                                 .encode(body);
                             Instruction::StructGet {
                                 struct_type_index: variant_type_idx,
-                                field_index: field_idx as u32,
+                                field_index: fld(field_idx),
                             }
                             .encode(body);
                         }
@@ -6198,6 +6560,59 @@ fn compileExpr(
                             ))
                         }
                     };
+                    // A method call on a trait-typed value goes through the trait's
+                    // `$dyn$<Trait>$<method>` dispatcher (reads the receiver's typeId).
+                    let is_trait_recv = ctx.gc_types.class_type_idx.get(&class_name)
+                        == Some(&ctx.gc_types.obj_type_idx)
+                        && ctx.methods.contains_key(&(
+                            class_name.clone(),
+                            plum_checker::TRAIT_MARKER.to_string(),
+                        ));
+                    // A method the receiver's own trait doesn't declare (e.g. a
+                    // `T: ToStr` bound's `toStr` on a `Shape`-typed value inside a
+                    // specialized generic) dispatches through whichever trait does.
+                    let dyn_owner = if is_trait_recv {
+                        if ctx.gc_types.dyn_fns.contains_key(&(class_name.clone(), call.name.clone())) {
+                            Some(class_name.clone())
+                        } else {
+                            ctx.gc_types
+                                .dyn_fns
+                                .keys()
+                                .find(|(_, m)| *m == call.name)
+                                .map(|(t, _)| t.clone())
+                        }
+                    } else {
+                        None
+                    };
+                    if is_trait_recv && dyn_owner.is_none() {
+                        // No implementor of this method exists at all: unreachable at
+                        // runtime, but the call must still type-check structurally.
+                        Instruction::Unreachable.encode(body);
+                        return Ok(());
+                    }
+                    if let Some(&dyn_idx) = dyn_owner.as_ref().and_then(|t| {
+                        ctx.gc_types
+                            .dyn_fns
+                            .get(&(t.clone(), call.name.clone()))
+                    }) {
+                        let owner = dyn_owner.clone().unwrap_or_default();
+                        let param_tys: Vec<PlumType> =
+                            match ctx.methods.get(&(owner, call.name.clone())) {
+                                Some(PlumType::TFun(ps, _)) => ps.clone(),
+                                _ => Vec::new(),
+                            };
+                        compileExpr(&attr.object, body, ctx, state)?;
+                        for (i, arg) in call.args.iter().enumerate() {
+                            let e = match arg {
+                                ast::Arg::Positional(e) => e,
+                                ast::Arg::Keyword { value, .. } => value,
+                                ast::Arg::Pair { value, .. } => value,
+                            };
+                            compileExprAs(e, param_tys.get(i).map(plumTypeToValtype), body, ctx, state)?;
+                        }
+                        Instruction::Call(dyn_idx).encode(body);
+                        return Ok(());
+                    }
                     let direct_key = format!("{}::{}", class_name, call.name);
                     // Fallback: a primitive/class receiver's method might be
                     // defined once on the "union" enum that bare-wraps it
@@ -6254,6 +6669,10 @@ fn compileExpr(
                         let vt = astTypeToWasm(&dispatch_name).unwrap_or(ValType::I32);
                         pushSelfPlaceholder(vt, body);
                     } else {
+                        if box_variant_idx.is_some() {
+                            // The wrap-enum variant's header typeId goes below its payload.
+                            Instruction::I32Const(typeIdOf(ctx.gc_types, &class_name)).encode(body);
+                        }
                         compileExpr(&attr.object, body, ctx, state)?; // push self
                         if let Some(variant_idx) = box_variant_idx {
                             // Dispatching to the wrap-enum's method (see
@@ -6285,10 +6704,15 @@ fn compileExpr(
                             },
                             _ => None,
                         };
+                    let sig_params: Vec<ValType> = ctx
+                        .func_sigs
+                        .get(&key)
+                        .map(|s| s.params.clone())
+                        .unwrap_or_default();
                     match variadic_split {
                         Some((elem_ty, fixed_count)) => {
-                            for arg in call.args.iter().take(fixed_count) {
+                            for (i, arg) in call.args.iter().take(fixed_count).enumerate() {
-                                compileExpr(argExprOf(arg), body, ctx, state)?;
+                                compileExprAs(argExprOf(arg), sig_params.get(i + 1).copied(), body, ctx, state)?;
                             }
                             let trailing: Vec<&ast::Expr> =
                                 call.args.iter().skip(fixed_count).map(argExprOf).collect();
@@ -6299,7 +6723,7 @@ fn compileExpr(
                                 .get(&elem_vt)
                                 .ok_or_else(|| "internal codegen error: no variadic array type registered for this elem type".to_string())?;
                             for arg_expr in &trailing {
-                                compileExpr(arg_expr, body, ctx, state)?;
+                                compileExprAs(arg_expr, Some(elem_vt), body, ctx, state)?;
                             }
                             Instruction::ArrayNewFixed {
                                 array_type_index: array_type_idx,
@@ -6308,8 +6732,8 @@ fn compileExpr(
                             .encode(body);
                         }
                         None => {
-                            for arg in &call.args {
+                            for (i, arg) in call.args.iter().enumerate() {
-                                compileExpr(argExprOf(arg), body, ctx, state)?;
+                                compileExprAs(argExprOf(arg), sig_params.get(i + 1).copied(), body, ctx, state)?;
                             }
                             compileDefaultArgs(&key, call.args.len(), body, ctx, state)?;
                         }
@@ -6421,13 +6845,20 @@ fn compileVariantConstruction(
     // single construction instruction — positional args already match field
     // declaration order (unlike named class-field construction), so no reordering
     // is needed here.
+    Instruction::I32Const(typeIdOf(ctx.gc_types, &call.name)).encode(body);
-    for arg in &call.args {
+    for (i, arg) in call.args.iter().enumerate() {
         let arg_expr = match arg {
             ast::Arg::Positional(e) => e,
             ast::Arg::Keyword { value, .. } => value,
             ast::Arg::Pair { value, .. } => value,
         };
+        compileExprAs(
+            arg_expr,
-        compileExpr(arg_expr, body, ctx, state)?;
+            info.field_types.get(i).map(plumTypeToValtype),
+            body,
+            ctx,
+            state,
+        )?;
     }
     Instruction::StructNew(variant_type_idx).encode(body);
     Ok(())
@@ -6503,6 +6934,7 @@ fn compileInterpolatedString(
                         // `Float` at all already must `import std/Number` (see
                         // `plum-core::loader::checkBuiltinImports`), so these
                         // lookups are always present.
+                        Instruction::I32Const(typeIdOf(ctx.gc_types, "Float")).encode(body);
                         compileExpr(expr, body, ctx, state)?;
                         let variant_idx = *ctx.gc_types.variant_type_idx.get("Float")
                             .ok_or_else(|| "codegen: interpolating a Float value requires `Number` (import std/Number)".to_string())?;

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

@@ -1557,3 +1557,118 @@ fun main() -> Int =
     );
     assert_eq!(got, 9);
 }
+// ---- trait types + typeId (T3) ----
+fn repoRoot() -> std::path::PathBuf {
+    std::path::Path::new(env!("CARGO_MANIFEST_DIR")).join("..")
+}
+/// Compiles `src` as a real file (so `import std/...` resolves against the repo's
+/// `plum-std`) and returns the wasm instance's `main` export plus its store.
+fn runMerged<R: wasmtime::WasmResults>(name: &str, src: &str) -> R {
+    let dir = std::env::temp_dir().join(format!("plum_t3_{}_{}", 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 engine = gcEngine();
+    let module = wasmtime::Module::new(&engine, &bytes).unwrap();
+    let mut store = wasmtime::Store::new(&engine, ());
+    // std pulls in host externs (printLn, ...) the test never calls: stub them.
+    let mut linker = wasmtime::Linker::new(&engine);
+    linker
+        .define_unknown_imports_as_default_values(&mut store, &module)
+        .unwrap();
+    let instance = linker.instantiate(&mut store, &module).unwrap();
+    let main = instance.get_typed_func::<(), R>(&mut store, "main").unwrap();
+    let r = main.call(&mut store, ()).unwrap();
+    let _ = std::fs::remove_dir_all(&dir);
+    r
+}
+#[test]
+fn heterogeneous_list_dispatch() {
+    let src = "\
+import std/Bool
+import std/Str
+import std/Number
+import std/Try
+import std/List
+trait Shape =
+  area() -> Float
+enum Circle(Shape) =
+  | Circle(r: Float)
+  fun area(self) -> Float =
+    self.r * self.r * 3.0
+enum Square(Shape) =
+  | Square(s: Float)
+  fun area(self) -> Float =
+    self.s * self.s
+fun total(xs: List[Shape]) -> Float =
+  xs.reduce(0.0, |acc, x| acc + x.area())
+fun main() -> Float =
+  xs := List[Shape]()
+  xs.add(Circle(r: 1.5))
+  xs.add(Square(s: 1.5))
+  xs.add(Circle(r: 0.5))
+  total(xs)
+";
+    // 6.75 + 2.25 + 0.75, exact in binary floating point.
+    assert_eq!(runMerged::<f64>("hetero", src), 9.75);
+}
+#[test]
+fn missing_trait_method_rejected() {
+    let src = "\
+trait Shape =
+  area() -> Float
+enum Plain =
+  | Plain(n: Int)
+fun total(s: Shape) -> Float =
+  s.area()
+fun main() -> Float =
+  total(Plain(n: 1))
+";
+    let errs = plum_checker::checkSource(&parse(src)).unwrap_err();
+    assert!(
+        errs.iter().any(|e| e
+            .message
+            .contains("type 'Plain' does not implement trait 'Shape': missing 'area'")),
+        "got {:?}",
+        errs.iter().map(|e| e.message.clone()).collect::<Vec<_>>()
+    );
+}
+#[test]
+fn boxed_int_dispatch() {
+    let src = "\
+import std/Bool
+import std/Str
+import std/Number
+fun show(x: ToStr) -> Str =
+  x.toStr()
+fun main() -> Int =
+  if show(5) == \"5\" && show(2.5) == \"2.5\" && show(\"hi\") == \"hi\"
+    return 1
+  return 0
+";
+    assert_eq!(runMerged::<i64>("boxed", src), 1);
+}

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

@@ -135,11 +135,11 @@ fn ioExampleCompilesAndRunsCorrectly() {
                 return Err(wasmtime::Error::msg("printLn expects a Str argument"));
             };
             let str_struct = s.unwrap_struct(&caller)?;
-            let wasmtime::Val::AnyRef(Some(buffer_ref)) = str_struct.field(&mut caller, 0)? else {
+            let wasmtime::Val::AnyRef(Some(buffer_ref)) = str_struct.field(&mut caller, 1)? else {
                 return Err(wasmtime::Error::msg("Str.data is not a Buffer reference"));
             };
             let buffer_struct = buffer_ref.unwrap_struct(&caller)?;
-            let wasmtime::Val::AnyRef(Some(bytes_ref)) = buffer_struct.field(&mut caller, 0)?
+            let wasmtime::Val::AnyRef(Some(bytes_ref)) = buffer_struct.field(&mut caller, 1)?
             else {
                 return Err(wasmtime::Error::msg(
                     "Buffer.data is not a []Byte reference",