aa923a9 | plum | pyrossh

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

aa923a9 — Peter John 2026-11-02T20:24:55+05:30

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

Files changed (7) hide show

plum-core/src/ast.rs CHANGED Viewed

@@ -172,12 +172,12 @@ 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,
+    /// On a lowered trait enum: every embedder lists the trait first, so the layout
+    /// is wasm-gc subtyping (no box). The variants are the embedding records.
+    pub isSubtypedTrait: bool,
 }
 #[derive(Debug, Clone, PartialEq)]

plum-core/src/parser.rs CHANGED Viewed

@@ -300,6 +300,7 @@ impl<'a> AstParser<'a> {
             isRecord: false,
             embeds: Vec::new(),
             isTrait: false,
+            isSubtypedTrait: false,
             name,
             line: pos.row + 1,
             column: pos.column + 1,
@@ -376,6 +377,7 @@ impl<'a> AstParser<'a> {
             isRecord: false,
             embeds,
             isTrait: false,
+            isSubtypedTrait: false,
             name,
             line: pos.row + 1,
             column: pos.column + 1,

plum-core/src/traits.rs CHANGED Viewed

@@ -248,8 +248,9 @@ pub fn lowerTraits(source: &mut Source) -> Vec<String> {
             variants,
             isValue: false,
             isRecord: false,
-            embeds: if subtyped { names } else { vec![] },
+            embeds: vec![],
             isTrait: true,
+            isSubtypedTrait: subtyped,
         };
         source.traits.push(t.clone());
         *item = Item::Enum(e);

plum-core/src/union_lower.rs CHANGED Viewed

@@ -8,13 +8,13 @@ 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
+    // Subtyped traits (see `Enum.isSubtypedTrait`) 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()),
+            Item::Enum(e) if e.isSubtypedTrait => Some(e.name.clone()),
             _ => None,
         })
         .collect();

plum-core/tests/traits_test.rs CHANGED Viewed

@@ -200,3 +200,18 @@ fn struct_typed_field_accessors_and_two_traits() {
     assert_eq!(enumOf(&s, "Aa").variants.len(), 1);
     assert_eq!(enumOf(&s, "Bb").variants[0].name, "Rr");
 }
+#[test]
+fn subtyped_flag_explicit_and_idempotent() {
+    let mut s = parseRaw(
+        "trait Aa(p: Int)\ntrait Bb(q: Int)\ntrait Cc(r: Int)\nrecord Rr(Aa, Bb, k: Int)\nrecord Ss(Bb, Cc)\n",
+    );
+    assert!(lowerTraits(&mut s).is_empty());
+    assert!(enumOf(&s, "Aa").isSubtypedTrait);
+    assert!(!enumOf(&s, "Bb").isSubtypedTrait);
+    assert!(!enumOf(&s, "Cc").isSubtypedTrait);
+    assert!(enumOf(&s, "Aa").embeds.is_empty());
+    let before = s.clone();
+    assert!(lowerTraits(&mut s).is_empty());
+    assert_eq!(s, before);
+}

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

@@ -1119,8 +1119,19 @@ fn subtypedTraits(source: &ast::Source) -> HashMap<String, Vec<String>> {
         .items
         .iter()
         .filter_map(|i| match i {
-            ast::Item::Enum(e) if e.isTrait && !e.embeds.is_empty() => {
+            ast::Item::Enum(e) if e.isSubtypedTrait => {
+                Some((
-                Some((e.name.clone(), e.embeds.clone()))
+                    e.name.clone(),
+                    e.variants
+                        .iter()
+                        .map(|v| {
+                            v.name
+                                .strip_prefix(&format!("{}__", e.name))
+                                .unwrap_or(&v.name)
+                                .to_string()
+                        })
+                        .collect(),
+                ))
             }
             _ => None,
         })

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

@@ -325,3 +325,57 @@ fun main() -> Int =
     // useExtra: n=11, b=8 -> 19; useBase: 4+5=9; t.n = 11
     assert_eq!(runInt("boxed2", &src), 19000 + 90 + 11);
 }
+#[test]
+fn nested_narrowing_two_levels() {
+    let src = prog("\
+trait Actor(x: Int) =
+  fun hit(self) -> Int
+record Dot(Actor, w: Int) =
+  fun hit(self) -> Int = self.w
+record Cat(Actor) =
+  fun hit(self) -> Int = 1
+record Holder(a: Actor)
+record Outer(h: Holder)
+fun f(o: Outer) -> Int =
+  match o
+    Outer(Holder(Dot(x, w))) => x * 100 + w
+    _ => 5
+fun main() -> Int =
+  f(Outer(h: Holder(a: Dot(x: 4, w: 9)))) * 10 + f(Outer(h: Holder(a: Cat(x: 1))))
+");
+    assert_eq!(runInt("nest2", &src), 4090 + 5);
+}
+#[test]
+fn subtyped_with_boxed_second_self_list_and_eq() {
+    let src = prog("\
+trait Actor(x: Int, kids: List[Actor]) =
+  fun hit(self) -> Int
+trait Extra(n: Int) =
+  fun b(self) -> Int
+record Dot(Actor, Extra, w: Int) =
+  fun hit(self) -> Int = self.w
+  fun b(self) -> Int = self.n
+fun main() -> Int =
+  d := Dot(x: 1, kids: List[Actor](), n: 6, w: 3)
+  a: Actor := d
+  e: Extra := d
+  e.n = 8
+  a.x = 2
+  a2: Actor := d
+  same := 0
+  if a == a2
+    same = 1
+  a.hit() * 1000 + d.n * 100 + d.x * 10 + same
+");
+    assert_eq!(runInt("mix", &src), 3000 + 800 + 20 + 1);
+}