538b1ee | plum | pyrossh

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

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

538b1ee — Peter John 2026-11-02T20:19:57+05:30

T10: box-free trait layout (wasm-gc subtyping)

Files changed (7) hide show

plum-checker/tests/trait_fields_tests.rs +4 -1
plum-core/src/ast.rs +3 -0
plum-core/src/traits.rs +13 -6
plum-core/src/union_lower.rs +36 -2
plum-game/web-test/BENCHMARK.md +3 -0
plum-wasm-codegen/src/lib.rs +237 -64
plum-wasm-codegen/tests/traits_e2e_test.rs +122 -0

plum-checker/tests/trait_fields_tests.rs CHANGED Viewed

@@ -21,7 +21,10 @@ trait Ent(pos: Vec2, z: Float) =
 record Hut(Ent, k: Float) =
   fun draw(self) -> Float = self.z
+# Orc lists Ent second, so Ent stays a boxed trait (accessor dispatch).
+trait Mark(m: Int)
-record Orc(Ent) =
+record Orc(Mark, Ent) =
   fun draw(self) -> Float = self.z + 1.0
 record Circle(r: Float)

plum-core/src/ast.rs CHANGED Viewed

@@ -172,6 +172,9 @@ pub struct Enum {
     /// `record X[T](..)`: a generic single-constructor heap type.
     pub isRecord: bool,
     /// Traits listed first in a `record`/`struct` field list (`record H(E, k: Int)`).
+    /// On a lowered trait enum (`isTrait`): the embedding records when the trait is
+    /// *subtyped* (every embedder lists it first, so their struct types extend the
+    /// trait's base struct and a conversion needs no box); empty otherwise.
     pub embeds: Vec<String>,
     /// A union enum produced by lowering a `trait`.
     pub isTrait: bool,

plum-core/src/traits.rs CHANGED Viewed

@@ -59,6 +59,8 @@ pub fn lowerTraits(source: &mut Source) -> Vec<String> {
         })
         .collect();
     let mut embedders: HashMap<String, Vec<String>> = HashMap::new();
+    // Records that list the trait FIRST: their struct layout starts with its fields.
+    let mut firstEmbedders: HashMap<String, usize> = HashMap::new();
     let mut newFns: Vec<Item> = Vec::new();
     // Record names and the file of any of their methods (for accessor `file`).
     let fnFile = |items: &[Item], rec: &str| -> String {
@@ -73,7 +75,7 @@ pub fn lowerTraits(source: &mut Source) -> Vec<String> {
     for ii in 0..source.items.len() {
         let (rname, isRecord, isValue, embeds) = match &source.items[ii] {
-            Item::Enum(e) if !e.embeds.is_empty() => {
+            Item::Enum(e) if !e.embeds.is_empty() && !e.isTrait => {
                 (e.name.clone(), e.isRecord, e.isValue, e.embeds.clone())
             }
             _ => continue,
@@ -156,6 +158,9 @@ pub fn lowerTraits(source: &mut Source) -> Vec<String> {
                 copies.push(c);
             }
             embedders.entry(em.clone()).or_default().push(rname.clone());
+            if embeds.first() == Some(em) {
+                *firstEmbedders.entry(em.clone()).or_default() += 1;
+            }
         }
         for em in &embeds {
             let t = &traits[em];
@@ -216,10 +221,12 @@ pub fn lowerTraits(source: &mut Source) -> Vec<String> {
     for item in source.items.iter_mut() {
         let Item::Trait(t) = item else { continue };
+        let names = embedders.get(&t.name).cloned().unwrap_or_default();
+        // Subtyped layout: every embedder lists the trait first.
+        let subtyped = !names.is_empty()
+            && firstEmbedders.get(&t.name).copied().unwrap_or(0) == names.len();
-        let variants = embedders
+        let variants = names
-            .get(&t.name)
-            .cloned()
+            .clone()
-            .unwrap_or_default()
             .into_iter()
             .map(|r| EnumVariant {
                 name: r.clone(),
@@ -241,7 +248,7 @@ pub fn lowerTraits(source: &mut Source) -> Vec<String> {
             variants,
             isValue: false,
             isRecord: false,
-            embeds: vec![],
+            embeds: if subtyped { names } else { vec![] },
             isTrait: true,
         };
         source.traits.push(t.clone());

plum-core/src/union_lower.rs CHANGED Viewed

@@ -8,8 +8,19 @@ use std::collections::{HashMap, HashSet};
 /// Applies `plan` to `source`.
 pub fn applyPlan(source: &mut Source, plan: &UnionPlan) {
+    // Subtyped traits (see `Enum.embeds`) keep records as their own subtypes: no
+    // box, and trait field reads/writes stay plain field accesses for codegen.
+    let subtyped: HashSet<String> = source
+        .items
+        .iter()
+        .filter_map(|i| match i {
+            Item::Enum(e) if e.isTrait && !e.embeds.is_empty() => Some(e.name.clone()),
+            _ => None,
+        })
+        .collect();
     let mut lw = Lowerer {
         plan,
+        subtyped,
         pending: Vec::new(),
         needs: Vec::new(),
     };
@@ -45,6 +56,8 @@ pub fn applyPlan(source: &mut Source, plan: &UnionPlan) {
 struct Lowerer<'a> {
     plan: &'a UnionPlan,
+    /// Names of the subtyped (box-free) traits.
+    subtyped: HashSet<String>,
     /// Narrowings (from, to) found in the condition being visited.
     pending: Vec<(String, String)>,
     /// (variants, method name) of every dispatch seen.
@@ -56,6 +69,14 @@ fn addr<T>(t: &T) -> usize {
 }
 impl<'a> Lowerer<'a> {
+    /// Whether hidden variant `Enum__Member` belongs to a subtyped trait.
+    fn isSubtyped(&self, variant: &str) -> bool {
+        variant
+            .split("__")
+            .next()
+            .is_some_and(|e| self.subtyped.contains(e))
+    }
     fn block(&mut self, b: &mut Block) {
         for s in &mut b.stmts {
             self.stmt(s);
@@ -128,6 +149,9 @@ impl<'a> Lowerer<'a> {
         else {
             return;
         };
+        if variants.first().is_some_and(|v| self.isSubtyped(v)) {
+            return;
+        }
         if a.targets.len() != 1 || a.values.len() != 1 || a.declare {
             return;
         }
@@ -306,7 +330,12 @@ impl<'a> Lowerer<'a> {
             | Expr::Var(_)
             | Expr::TypeName(_) => {}
         }
-        if let Some(variants) = self.plan.fieldReads.get(&a) {
+        if let Some(variants) = self
+            .plan
+            .fieldReads
+            .get(&a)
+            .filter(|vs| !vs.first().is_some_and(|v| self.isSubtyped(v)))
+        {
             if let Expr::Attribute(at) = e {
                 if let AttrKind::Field(f) = &at.attr {
                     let method = crate::traits::getter(f);
@@ -330,7 +359,12 @@ impl<'a> Lowerer<'a> {
             };
             self.needs.push((variants.clone(), method));
         }
-        if let Some(variant) = self.plan.wraps.get(&a) {
+        if let Some(variant) = self
+            .plan
+            .wraps
+            .get(&a)
+            .filter(|v| !self.isSubtyped(v))
+        {
             let inner = std::mem::replace(e, Expr::Int(0));
             *e = Expr::FnCall(FnCall {
                 name: variant.clone(),

plum-game/web-test/BENCHMARK.md CHANGED Viewed

@@ -123,7 +123,10 @@ With culling the frame costs about what the 2,000 visible sprites cost, not what
 | stress_scene, 5.8k nodes | `trait Actor` | 1.69, 1.69 | 1.8 | 0.039 | 1.27 | 0.26 |
 | stress_world, 20k nodes, culling on | closure `Node` | 1.09, 1.09 | 1.2 | 0.421 | 0.495 | 0.082 |
 | stress_world, 20k nodes, culling on | `trait Actor` | 2.09, 2.12 | 2.3-2.4 | 1.29-1.31 | 0.59 | 0.09 |
+| stress_scene, 5.8k nodes | trait (box-free) | 1.67, 1.68 | 1.8 | 0.038 | 1.26 | 0.26 |
+| stress_world, 20k nodes, culling on | trait (box-free) | 1.10, 1.11 | 1.2 | 0.37-0.38 | 0.54 | 0.085 |
 - `stress_scene`: +5% (1.60 -> 1.69 ms), at the edge of noise. The per-node closure call became a trait dispatch, which is cheaper (`update` 0.055 -> 0.039 ms); `draw` grew by 0.08 ms because the draw walk reads child fields through the trait.
 - `stress_world`: +92% (1.09 -> 2.09 ms), above the 10% threshold. All of it is `update`, which here is the y-sort: `sortChildren(|a, b| a.y < b.y)` makes 2 x 19,999 `a.y` reads per frame and every read of a trait field is a dispatch (`__get_y`) over the program's actor kinds, about 30-40 ns each against about 10 ns for a direct field read. Without the sort `update` is 0.01 ms. The cost scales with the number of actor kinds in the program: dropping two unused test-only kinds took `update` from 1.65 to 1.29 ms, which is why the Scene tests that need their own `act`/`draw` records live in `plum-examples/scene.plum` and not in `std/game/Scene.plum`. Draw is +0.1 ms (culling and transforms run as trait default methods, so they read fields directly, one dispatch per child).
+- Box-free layout (T10): a trait whose every embedder lists it first is compiled as a wasm-gc base struct of the trait's fields with each embedding record's struct as a subtype. A record already is a trait value (no box, `==` is reference identity), a trait field read or write is one `struct.get`/`struct.set` on the base type, and only method dispatch and `match` narrowing use `ref.test`/`ref.cast`. `stress_world` goes 2.09 -> 1.10 ms (+1% against the closure version's 1.09, inside the 10% threshold; `update` 1.29 -> 0.37 ms) and `stress_scene` 1.69 -> 1.68 ms (+5% against 1.60, the same edge-of-noise gap as before). A trait that some record lists second or later keeps the boxed layout described above.
 - Reading the trait's fields from outside it (a game's sort key, hit tests on `.x`/`.y`) is the price of the trait. Default methods run on the concrete record and read its fields directly, which is why `local()`, `outside()`, `drawTree()` and `hitTree()` are trait methods rather than free functions.

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

@@ -999,6 +999,9 @@ pub struct GcTypeRegistry {
     pub mk_str_fn: Option<u32>,
     /// `!T` (keyed by `T`) -> its heap box struct `{leaves of T..., code: i32}`.
     pub err_box: HashMap<PlumType, u32>,
+    /// Hidden member variants (`Actor__Box`) of subtyped traits: no struct of their
+    /// own, they resolve to the member record's struct (see `subtypedTraits`).
+    pub trait_members: HashSet<String>,
 }
 impl GcTypeRegistry {
@@ -1108,6 +1111,49 @@ fn arrayDepth(t: &PlumType) -> usize {
     }
 }
+/// Subtyped (box-free) traits: trait name -> its embedding records. Such a trait
+/// is a non-final base struct of its fields, each embedder's struct extends it,
+/// so a record already IS a trait value and trait fields are plain struct fields.
+fn subtypedTraits(source: &ast::Source) -> HashMap<String, Vec<String>> {
+    source
+        .items
+        .iter()
+        .filter_map(|i| match i {
+            ast::Item::Enum(e) if e.isTrait && !e.embeds.is_empty() => {
+                Some((e.name.clone(), e.embeds.clone()))
+            }
+            _ => None,
+        })
+        .collect()
+}
+/// Registers each subtyped trait's fields as its enum params, so trait field
+/// reads and writes take the shared-field `struct.get`/`struct.set` path.
+fn addTraitParams(
+    source: &ast::Source,
+    enum_variants: &EnumVariants,
+    enum_params: &mut EnumParams,
+) {
+    for (t, members) in subtypedTraits(source) {
+        let Some(decl) = source.traits.iter().find(|d| d.name == t) else {
+            continue;
+        };
+        let Some(info) = members.first().and_then(|m| enum_variants.get(m)) else {
+            continue;
+        };
+        let params = info
+            .field_names
+            .iter()
+            .cloned()
+            .zip(info.field_types.iter().cloned())
+            .take(decl.fields.len())
+            .collect::<Vec<_>>();
+        if !params.is_empty() {
+            enum_params.insert(t, params);
+        }
+    }
+}
 /// Builds the wasm-gc type registry: one struct family per non-generic enum and per
 /// distinct concrete instance (`apps`, e.g. `List[Int]`) of a generic enum, keyed by
 /// the structural `PlumType`; `Array[T]` instances become native wasm arrays of `T`'s
@@ -1145,7 +1191,15 @@ fn buildGcTypeRegistry(
         leaf_array_idx: HashMap::new(),
         mk_str_fn: None,
         err_box: HashMap::new(),
+        trait_members: HashSet::new(),
     };
+    let subtyped = subtypedTraits(source);
+    let mut parent_of: HashMap<String, String> = HashMap::new();
+    for (t, members) in &subtyped {
+        for m in members {
+            parent_of.insert(m.clone(), t.clone());
+        }
+    }
     let mut enum_decls: HashMap<String, &ast::Enum> = HashMap::new();
     let mut instances: Vec<PlumType> = Vec::new();
     for item in &source.items {
@@ -1166,6 +1220,10 @@ fn buildGcTypeRegistry(
             }
         }
     }
+    // A trait's base struct must precede the records that extend it.
+    instances.sort_by_key(|t| {
+        !matches!(t, PlumType::TNamed(n) if subtyped.contains_key(n))
+    });
     for ty in &instances {
         let n = plum_checker::nominalName(ty).unwrap().to_string();
         let e = enum_decls[&n];
@@ -1179,6 +1237,10 @@ fn buildGcTypeRegistry(
                 reg.app_super.insert(ty.clone(), super_idx);
             }
         }
+        if subtyped.contains_key(&n) {
+            // Box-free trait: only the base struct; members are the records.
+            continue;
+        }
         for v in &e.variants {
             let idx = slots.len() as u32;
             slots.push(Slot::Variant(ty.clone(), v.name.clone()));
@@ -1202,6 +1264,15 @@ fn buildGcTypeRegistry(
             }
         }
     }
+    for (t, members) in &subtyped {
+        for m in members {
+            if let Some(&idx) = reg.class_type_idx.get(m) {
+                let hidden = plum_core::unions::hiddenVariant(t, m);
+                reg.variant_type_idx.insert(hidden.clone(), idx);
+                reg.trait_members.insert(hidden);
+            }
+        }
+    }
     reg.instances = instances.clone();
     for t in errs {
         if !reg.err_box.contains_key(t) {
@@ -1316,7 +1387,12 @@ fn buildGcTypeRegistry(
                         vname
                     )
                 });
+                let super_idx = match ty {
+                    PlumType::TNamed(n) if *vname == *n && parent_of.contains_key(n) => {
+                        reg.enum_super_type_idx[&parent_of[n]]
+                    }
-                let super_idx = reg.superIdx(ty).expect("enum supertype slot");
+                    _ => reg.superIdx(ty).expect("enum supertype slot"),
+                };
                 let mut field_types: Vec<FieldType> = Vec::new();
                 if let Some(leaves) = valueFieldsOf(ty).map(|_| flatValtypes(ty, &reg)) {
                     // A value enum's box holds its flattened leaves directly.
@@ -2025,7 +2101,9 @@ fn compileSourceInner(
     for ((id, ptr), t) in inst_expr_types {
         inst_types[id].insert(ptr, t);
     }
-    let (global_env, methods, enum_variants, enum_params) = plum_checker::buildGlobalTables(source);
+    let (global_env, methods, enum_variants, mut enum_params) =
+        plum_checker::buildGlobalTables(source);
+    addTraitParams(source, &enum_variants, &mut enum_params);
     let min_required = plum_checker::buildMinRequiredArgs(source);
     let primitive_generics = plum_checker::buildPrimitiveGenerics(source);
     let mut eg: EnumGenerics = HashMap::new();
@@ -5801,14 +5879,55 @@ fn compileVariantConstructorArm(
     Instruction::LocalGet(scratch_local).encode(body);
     Instruction::RefCastNonNull(HeapType::Concrete(variant_idx)).encode(body);
     Instruction::LocalSet(narrow_local).encode(body);
+    let mut onMatch = |body: &mut Vec<u8>, state: &mut ModuleState| {
+        compileCasePositions(
+            case,
+            pos + 1,
+            all_subjects,
+            rest,
+            result_vt,
+            exhaustive_fallback,
+            body,
+            ctx,
+            state,
+        )
+    };
+    if ctx.gc_types.trait_members.contains(name) {
+        compileTraitMemberInner(
+            &fields[0],
+            &inst_types[0],
+            narrow_local,
+            variant_idx,
+            rest,
+            all_subjects,
+            result_vt,
+            exhaustive_fallback,
+            body,
+            ctx,
+            state,
+            &mut onMatch,
+        )?;
+    } else {
-    compileFieldPatterns(
+        compileFieldPatterns(
-        fields,
+            fields,
-        &field_types,
+            &field_types,
-        &inst_types,
+            &inst_types,
-        0,
+            0,
-        narrow_local,
+            narrow_local,
-        variant_idx,
+            variant_idx,
-        value_leaf_map.as_deref(),
+            value_leaf_map.as_deref(),
+            rest,
+            all_subjects,
+            result_vt,
+            exhaustive_fallback,
+            body,
+            ctx,
+            state,
+            &mut onMatch,
+        )?;
+    }
+    Instruction::Else.encode(body);
+    compileMatchArmsMulti(
         rest,
         all_subjects,
         result_vt,
@@ -5816,32 +5935,68 @@ fn compileVariantConstructorArm(
         body,
         ctx,
         state,
+    )?;
+    Instruction::End.encode(body);
+    Ok(())
+}
+/// Matches `inner` (the payload pattern of a hidden member variant `Actor__Box` of
+/// a subtyped trait) against the member record held in `member_local`. The record
+/// IS the trait value, so there is no payload field to read.
+#[allow(clippy::too_many_arguments)]
+fn compileTraitMemberInner(
+    inner: &ast::CasePattern,
+    member_ty: &PlumType,
+    member_local: u32,
+    member_idx: u32,
+    rest: &[ast::Case],
+    all_subjects: &[(ValType, u32)],
+    result_vt: Option<ValType>,
+    exhaustive_fallback: bool,
+    body: &mut Vec<u8>,
+    ctx: &LocalCtx,
+    state: &mut ModuleState,
+    on_match: &mut dyn FnMut(&mut Vec<u8>, &mut ModuleState) -> Result<(), String>,
+) -> Result<(), String> {
+    match inner {
+        ast::CasePattern::Wildcard => on_match(body, state),
+        ast::CasePattern::Name(n) if !ctx.enum_variants.contains_key(n) => {
+            let idx = ctx.locals.get(n).copied().ok_or_else(|| {
+                format!("internal codegen error: missing binding local '{}'", n)
+            })?;
+            Instruction::LocalGet(member_local).encode(body);
+            Instruction::LocalSet(idx).encode(body);
+            ctx.type_env
+                .borrow_mut()
+                .insert(n.to_string(), TypeScheme::mono(member_ty.clone()));
-        &mut |body, state| {
+            on_match(body, state)
+        }
+        ast::CasePattern::Class { name, fields } => {
+            let info = ctx
+                .enum_variants
+                .get(name)
+                .ok_or_else(|| format!("codegen: unknown enum variant '{}'", name))?;
+            let types = instFields(info, member_ty);
-            compileCasePositions(
+            compileFieldPatterns(
+                fields,
+                &types,
+                &types,
+                0,
+                member_local,
+                member_idx,
-                case,
+                None,
-                pos + 1,
-                all_subjects,
                 rest,
+                all_subjects,
                 result_vt,
                 exhaustive_fallback,
                 body,
                 ctx,
                 state,
+                on_match,
             )
-        },
+        }
-    )?;
-    Instruction::Else.encode(body);
+        _ => Err("codegen: unsupported pattern on a trait member".to_string()),
-    compileMatchArmsMulti(
-        rest,
-        all_subjects,
-        result_vt,
-        exhaustive_fallback,
-        body,
-        ctx,
-        state,
-    )?;
+    }
-    Instruction::End.encode(body);
-    Ok(())
 }
 /// Pushes field `fpos` of the pattern container in `container_local`.
@@ -6257,41 +6412,59 @@ fn compileFieldPatterns(
             );
             Instruction::RefCastNonNull(HeapType::Concrete(inner_variant_idx)).encode(body);
             Instruction::LocalSet(nested_local).encode(body);
+            let mut onNested = |body: &mut Vec<u8>, state: &mut ModuleState| {
-            compileFieldPatterns(
+                compileFieldPatterns(
+                    fields,
+                    field_types,
+                    inst_types,
+                    fpos + 1,
+                    container_local,
+                    container_type_idx,
+                    leaf_map,
+                    rest,
+                    all_subjects,
+                    result_vt,
+                    exhaustive_fallback,
+                    body,
+                    ctx,
+                    state,
+                    on_match,
+                )
+            };
+            if ctx.gc_types.trait_members.contains(name) {
+                compileTraitMemberInner(
+                    &inner_fields[0],
+                    &inner_inst_types[0],
+                    nested_local,
+                    inner_variant_idx,
+                    rest,
+                    all_subjects,
+                    result_vt,
+                    exhaustive_fallback,
+                    body,
+                    ctx,
+                    state,
+                    &mut onNested,
+                )?;
+            } else {
+                compileFieldPatterns(
-                inner_fields,
+                    inner_fields,
-                &inner_field_types,
+                    &inner_field_types,
-                &inner_inst_types,
+                    &inner_inst_types,
-                0,
+                    0,
-                nested_local,
+                    nested_local,
-                inner_variant_idx,
+                    inner_variant_idx,
-                None,
+                    None,
-                rest,
+                    rest,
-                all_subjects,
+                    all_subjects,
-                result_vt,
+                    result_vt,
-                exhaustive_fallback,
+                    exhaustive_fallback,
-                body,
+                    body,
-                ctx,
+                    ctx,
-                state,
+                    state,
-                &mut |body, state| {
+                    &mut onNested,
-                    compileFieldPatterns(
-                        fields,
-                        field_types,
-                        inst_types,
-                        fpos + 1,
-                        container_local,
-                        container_type_idx,
-                        leaf_map,
-                        rest,
-                        all_subjects,
-                        result_vt,
-                        exhaustive_fallback,
-                        body,
-                        ctx,
-                        state,
-                        on_match,
-                    )
-                },
-            )?;
+                )?;
+            }
             Instruction::Else.encode(body);
             compileMatchArmsMulti(
                 rest,

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

@@ -203,3 +203,125 @@ fun main() -> Int =
 ");
     assert_eq!(runInt("narrow", &src), 4090 + 5);
 }
+/// Operator names (Debug form) of the function named `name` in `bytes` (found
+/// through the name section).
+fn opsOfExport(bytes: &[u8], name: &str) -> Vec<String> {
+    use wasmparser::{Name, NameSectionReader, Parser, Payload};
+    let mut funcIdx = None;
+    let mut imported = 0u32;
+    let mut bodies = Vec::new();
+    for p in Parser::new(0).parse_all(bytes) {
+        match p.unwrap() {
+            Payload::ImportSection(s) => {
+                for i in s {
+                    if matches!(i.unwrap().ty, wasmparser::TypeRef::Func(_)) {
+                        imported += 1;
+                    }
+                }
+            }
+            Payload::CustomSection(c) if c.name() == "name" => {
+                for n in NameSectionReader::new(wasmparser::BinaryReader::new(c.data(), c.data_offset())) {
+                    if let Name::Function(m) = n.unwrap() {
+                        for a in m {
+                            let a = a.unwrap();
+                            if a.name == name {
+                                funcIdx = Some(a.index);
+                            }
+                        }
+                    }
+                }
+            }
+            Payload::CodeSectionEntry(b) => bodies.push(b),
+            _ => {}
+        }
+    }
+    let idx = funcIdx.unwrap_or_else(|| panic!("no function named {name}")) - imported;
+    let mut ops = Vec::new();
+    let mut r = bodies[idx as usize].get_operators_reader().unwrap();
+    while !r.eof() {
+        ops.push(format!("{:?}", r.read().unwrap()));
+    }
+    ops
+}
+fn compileOk(name: &str, src: &str) -> Vec<u8> {
+    let source = load(name, src).expect("load");
+    let bytes = compileSource(&source).unwrap_or_else(|e| panic!("compile failed: {e}"));
+    wasmparser::validate(&bytes).expect("valid wasm");
+    bytes
+}
+const ACTORS: &str = "\
+trait Actor(x: Int, y: Int) =
+  fun hit(self) -> Int
+record Box(Actor, w: Int) =
+  fun hit(self) -> Int = self.w
+record Dot(Actor) =
+  fun hit(self) -> Int = 1
+";
+#[test]
+fn subtyped_field_read_direct() {
+    let src = prog(&format!("{ACTORS}
+fun readY(a: Actor) -> Int = a.y
+fun main() -> Int =
+  readY(Box(x: 1, y: 7, w: 3))
+"));
+    let bytes = compileOk("direct_read", &src);
+    let ops = opsOfExport(&bytes, "readY");
+    assert!(ops.iter().any(|o| o.starts_with("StructGet")), "{ops:?}");
+    assert!(!ops.iter().any(|o| o.starts_with("Call") || o.starts_with("RefTest") || o.starts_with("RefCast")), "{ops:?}");
+    assert_eq!(runInt("direct_read_run", &src), 7);
+}
+#[test]
+fn conversion_is_identity() {
+    let src = prog(&format!("{ACTORS}
+fun asActor(b: Box) -> Actor = b
+fun main() -> Int =
+  b := Box(x: 1, y: 7, w: 3)
+  a: Actor := b
+  c: Actor := b
+  a.y = 9
+  same := 0
+  if a == c
+    same = 1
+  same * 100 + b.y
+"));
+    let bytes = compileOk("identity", &src);
+    let ops = opsOfExport(&bytes, "asActor");
+    assert!(!ops.iter().any(|o| o.starts_with("StructNew")), "{ops:?}");
+    assert_eq!(runInt("identity_run", &src), 109);
+}
+#[test]
+fn second_trait_stays_boxed() {
+    let src = prog("\
+trait Base(id: Int) =
+  fun a(self) -> Int
+trait Extra(n: Int) =
+  fun b(self) -> Int
+record Thing(Base, Extra, k: Int) =
+  fun a(self) -> Int = self.k
+  fun b(self) -> Int = self.k * 2
+fun useExtra(e: Extra) -> Int =
+  e.n = e.n + 1
+  e.b() + e.n
+fun useBase(x: Base) -> Int = x.a() + x.id
+fun main() -> Int =
+  t := Thing(id: 5, n: 10, k: 4)
+  useExtra(t) * 1000 + useBase(t) * 10 + t.n
+");
+    // useExtra: n=11, b=8 -> 19; useBase: 4+5=9; t.n = 11
+    assert_eq!(runInt("boxed2", &src), 19000 + 90 + 11);
+}