d83c36b | plum | pyrossh

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

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

d83c36b — Peter John 2026-11-02T19:40:47+05:30

T2: trait lowering

Files changed (7) hide show

plum-core/src/ast.rs +2 -0
plum-core/src/lib.rs +1 -0
plum-core/src/loader.rs +5 -0
plum-core/src/parser.rs +1 -0
plum-core/src/traits.rs +252 -0
plum-core/tests/traits_test.rs +184 -0
plum-wasm-codegen/src/lib.rs +1 -0

plum-core/src/ast.rs CHANGED Viewed

@@ -25,6 +25,8 @@ pub struct Source {
     /// Every `primitive <Name> =` block of this file. The loader allows one
     /// naming a compiler built-in only in std; any other name is a namespace.
     pub primitives: Vec<PrimitiveDecl>,
+    /// Traits removed by `lowerTraits` (their unions replace them in `items`).
+    pub traits: Vec<TraitDecl>,
 }
 /// A `primitive Name =` block.

plum-core/src/lib.rs CHANGED Viewed

@@ -8,6 +8,7 @@ pub mod formatter;
 pub mod forms;
 pub mod loader;
 pub mod parser;
+pub mod traits;
 pub mod union_lower;
 pub mod unions;

plum-core/src/loader.rs CHANGED Viewed

@@ -77,7 +77,12 @@ pub fn loadAndMergeWithOverrides(
         stars: Vec::new(),
         formLoops: false,
         primitives: prims,
+        traits: Vec::new(),
     };
+    let traitErrors = crate::traits::lowerTraits(&mut merged);
+    if !traitErrors.is_empty() {
+        return Err(traitErrors.join("\n"));
+    }
     let memberErrors = crate::unions::resolveMembers(&mut merged);
     if !memberErrors.is_empty() {
         return Err(memberErrors.join("\n"));

plum-core/src/parser.rs CHANGED Viewed

@@ -174,6 +174,7 @@ impl<'a> AstParser<'a> {
             stars: Vec::new(),
             formLoops: false,
             primitives,
+            traits: Vec::new(),
         }
     }

plum-core/src/traits.rs ADDED Viewed

@@ -0,0 +1,252 @@
+//! Trait lowering: copies each trait's fields and missing default methods into
+//! every record that embeds it, adds `__get_<f>`/`__set_<f>` accessors, and
+//! replaces the trait with a union enum (`isTrait: true`) over its embedders.
+use std::collections::HashMap;
+use crate::ast::*;
+pub fn getter(field: &str) -> String {
+    format!("__get_{}", field)
+}
+pub fn setter(field: &str) -> String {
+    format!("__set_{}", field)
+}
+fn accessor(
+    name: String,
+    record: &str,
+    file: &str,
+    t: &TraitDecl,
+    params: Vec<Param>,
+    returns: Option<Type>,
+    body: FnBody,
+) -> Fn {
+    Fn {
+        name,
+        file: file.to_string(),
+        line: t.line,
+        column: t.column,
+        type_param: Some(record.to_string()),
+        is_extern: false,
+        is_export: false,
+        is_star: false,
+        has_self: true,
+        params,
+        yields: None,
+        returns,
+        body,
+    }
+}
+fn selfField(field: &str) -> Expr {
+    Expr::Attribute(Box::new(AttributeExpr {
+        object: Expr::Self_,
+        attr: AttrKind::Field(field.to_string()),
+    }))
+}
+/// Lowers every `trait` of `source`. Returns error messages (empty on success).
+/// Idempotent: a second call finds no traits and no embeds and does nothing.
+pub fn lowerTraits(source: &mut Source) -> Vec<String> {
+    let mut errors = Vec::new();
+    let traits: HashMap<String, TraitDecl> = source
+        .items
+        .iter()
+        .filter_map(|i| match i {
+            Item::Trait(t) => Some((t.name.clone(), t.clone())),
+            _ => None,
+        })
+        .collect();
+    let mut embedders: HashMap<String, Vec<String>> = 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 {
+        items
+            .iter()
+            .find_map(|i| match i {
+                Item::Fn(f) if f.type_param.as_deref() == Some(rec) => Some(f.file.clone()),
+                _ => None,
+            })
+            .unwrap_or_else(|| source.file.clone())
+    };
+    for ii in 0..source.items.len() {
+        let (rname, isRecord, isValue, embeds) = match &source.items[ii] {
+            Item::Enum(e) if !e.embeds.is_empty() => {
+                (e.name.clone(), e.isRecord, e.isValue, e.embeds.clone())
+            }
+            _ => continue,
+        };
+        let kind = if isValue { "struct" } else { "record" };
+        let before = errors.len();
+        for em in &embeds {
+            if !traits.contains_key(em) {
+                errors.push(format!("{} embeds {}, which is not a trait", rname, em));
+            } else if isValue || !isRecord {
+                errors.push(format!(
+                    "{} {} cannot embed trait {}; only records embed traits",
+                    kind, rname, em
+                ));
+            }
+        }
+        if errors.len() > before {
+            if let Item::Enum(e) = &mut source.items[ii] {
+                e.embeds.clear();
+            }
+            continue;
+        }
+        let file = fnFile(&source.items, &rname);
+        let Item::Enum(e) = &source.items[ii] else { continue };
+        let ownNames: Vec<String> = e.variants[0].field_names.clone();
+        let mut fieldOwner: Vec<(String, String)> = Vec::new(); // (field, trait)
+        let mut newTypes: Vec<Type> = Vec::new();
+        let mut newNames: Vec<String> = Vec::new();
+        for em in &embeds {
+            for f in &traits[em].fields {
+                if let Some((_, other)) = fieldOwner.iter().find(|(n, _)| *n == f.name) {
+                    errors.push(format!(
+                        "record {} gets field {} from both {} and {}",
+                        rname, f.name, other, em
+                    ));
+                } else if ownNames.contains(&f.name) {
+                    errors.push(format!(
+                        "record {} field {} is already declared by trait {}",
+                        rname, f.name, em
+                    ));
+                } else {
+                    fieldOwner.push((f.name.clone(), em.clone()));
+                    newTypes.push(f.ty.clone());
+                    newNames.push(f.name.clone());
+                }
+            }
+        }
+        let defined = |name: &str| {
+            source.items.iter().any(|i| {
+                matches!(i, Item::Fn(f) if f.type_param.as_deref() == Some(&rname) && f.name == name)
+            })
+        };
+        let mut defaultOwner: Vec<(String, String)> = Vec::new();
+        let mut copies: Vec<Fn> = Vec::new();
+        for em in &embeds {
+            let t = &traits[em];
+            for r in &t.required {
+                if !defined(&r.name) {
+                    errors.push(format!(
+                        "record {} embeds {} but does not define required method {}",
+                        rname, em, r.name
+                    ));
+                }
+            }
+            for m in &t.methods {
+                if defined(&m.name) {
+                    continue;
+                }
+                if let Some((_, other)) = defaultOwner.iter().find(|(n, _)| *n == m.name) {
+                    errors.push(format!(
+                        "record {} gets default method {} from both {} and {}; define {}.{}",
+                        rname, m.name, other, em, rname, m.name
+                    ));
+                    continue;
+                }
+                defaultOwner.push((m.name.clone(), em.clone()));
+                let mut c = m.clone();
+                c.type_param = Some(rname.clone());
+                c.file = file.clone();
+                copies.push(c);
+            }
+            embedders.entry(em.clone()).or_default().push(rname.clone());
+        }
+        for em in &embeds {
+            let t = &traits[em];
+            for f in &t.fields {
+                if !fieldOwner.iter().any(|(n, o)| *n == f.name && o == em) {
+                    continue;
+                }
+                copies.push(accessor(
+                    getter(&f.name),
+                    &rname,
+                    &file,
+                    t,
+                    vec![],
+                    Some(f.ty.clone()),
+                    FnBody::Expr(selfField(&f.name)),
+                ));
+                copies.push(accessor(
+                    setter(&f.name),
+                    &rname,
+                    &file,
+                    t,
+                    vec![Param {
+                        name: "v".to_string(),
+                        ty: ParamType::Type(f.ty.clone()),
+                        default: None,
+                    }],
+                    None,
+                    FnBody::Block(Block {
+                        stmts: vec![Stmt::Assign(Assign {
+                            targets: vec![AssignTarget::Field(
+                                Box::new(Expr::Self_),
+                                f.name.clone(),
+                            )],
+                            values: vec![Expr::Var("v".to_string())],
+                            declare: false,
+                            ty: None,
+                        })],
+                    }),
+                ));
+            }
+        }
+        if let Item::Enum(e) = &mut source.items[ii] {
+            e.embeds.clear();
+            if errors.len() == before {
+                let v = &mut e.variants[0];
+                let mut tys = newTypes;
+                tys.extend(std::mem::take(&mut v.fields));
+                let mut names = newNames;
+                names.extend(std::mem::take(&mut v.field_names));
+                v.fields = tys;
+                v.field_names = names;
+            }
+        }
+        if errors.len() == before {
+            newFns.extend(copies.into_iter().map(Item::Fn));
+        }
+    }
+    for item in source.items.iter_mut() {
+        let Item::Trait(t) = item else { continue };
+        let variants = embedders
+            .get(&t.name)
+            .cloned()
+            .unwrap_or_default()
+            .into_iter()
+            .map(|r| EnumVariant {
+                name: r.clone(),
+                member: Some(Type {
+                    name: r,
+                    generics: vec![],
+                }),
+                fields: vec![],
+                field_names: vec![],
+                values: vec![],
+            })
+            .collect();
+        let e = Enum {
+            name: t.name.clone(),
+            line: t.line,
+            column: t.column,
+            generics: vec![],
+            params: vec![],
+            variants,
+            isValue: false,
+            isRecord: false,
+            embeds: vec![],
+            isTrait: true,
+        };
+        source.traits.push(t.clone());
+        *item = Item::Enum(e);
+    }
+    source.items.extend(newFns);
+    errors
+}

plum-core/tests/traits_test.rs ADDED Viewed

@@ -0,0 +1,184 @@
+#![allow(non_snake_case)]
+use plum_core::ast::*;
+use plum_core::traits::{getter, lowerTraits, setter};
+use plum_core::unions::resolveMembers;
+use plum_core::AstParser;
+fn parseRaw(src: &str) -> Source {
+    let mut parser = tree_sitter::Parser::new();
+    parser
+        .set_language(&tree_sitter_plum::LANGUAGE.into())
+        .unwrap();
+    let tree = parser.parse(src, None).unwrap();
+    assert!(!tree.root_node().has_error(), "{}", tree.root_node().to_sexp());
+    AstParser::new(src).parseSourceRaw(tree.root_node())
+}
+fn enumOf<'a>(s: &'a Source, name: &str) -> &'a Enum {
+    s.items
+        .iter()
+        .find_map(|i| match i {
+            Item::Enum(e) if e.name == name => Some(e),
+            _ => None,
+        })
+        .unwrap()
+}
+fn fnOf<'a>(s: &'a Source, rec: &str, name: &str) -> Option<&'a Fn> {
+    s.items.iter().find_map(|i| match i {
+        Item::Fn(f) if f.type_param.as_deref() == Some(rec) && f.name == name => Some(f),
+        _ => None,
+    })
+}
+const BASIC: &str = "trait Ent(z: Int) =\n  fun up(self)\n  fun gz(self) -> Int = self.z\n\nrecord Hut(Ent, k: Int) =\n  fun up(self) -> Int = 1\n";
+#[test]
+fn accessor_names() {
+    assert_eq!(getter("pos"), "__get_pos");
+    assert_eq!(setter("pos"), "__set_pos");
+}
+#[test]
+fn lowers_basic() {
+    let mut s = parseRaw(BASIC);
+    assert_eq!(lowerTraits(&mut s), Vec::<String>::new());
+    assert!(!s.items.iter().any(|i| matches!(i, Item::Trait(_))));
+    assert_eq!(s.traits.len(), 1);
+    let u = enumOf(&s, "Ent");
+    assert!(u.isTrait);
+    assert_eq!(u.variants.len(), 1);
+    assert_eq!(u.variants[0].member.as_ref().unwrap().name, "Hut");
+    let h = enumOf(&s, "Hut");
+    assert_eq!(h.variants[0].field_names, vec!["z", "k"]);
+    assert!(fnOf(&s, "Hut", "__get_z").is_some());
+    let set = fnOf(&s, "Hut", "__set_z").unwrap();
+    assert!(set.has_self && set.params.len() == 1);
+    let get = fnOf(&s, "Hut", "__get_z").unwrap();
+    assert_eq!(get.returns.as_ref().unwrap().name, "Int");
+    assert!(fnOf(&s, "Hut", "gz").is_some());
+    // required methods are never copied
+    assert_eq!(
+        s.items.iter().filter(|i| matches!(i, Item::Fn(f) if f.name == "up")).count(),
+        1
+    );
+    assert!(resolveMembers(&mut s).is_empty());
+    assert_eq!(enumOf(&s, "Ent").variants[0].name, "Ent__Hut");
+}
+#[test]
+fn accessor_bodies_match_parsed_code() {
+    let mut s = parseRaw(BASIC);
+    lowerTraits(&mut s);
+    let r = parseRaw("record Tmp(z: Int) =\n  fun getz(self) -> Int = self.z\n  fun setz(self, v: Int) =\n    self.z = v\n");
+    let want = |n: &str| match r.items.iter().find_map(|i| match i {
+        Item::Fn(f) if f.name == n => Some(f.body.clone()),
+        _ => None,
+    }) {
+        Some(b) => b,
+        None => panic!(),
+    };
+    assert_eq!(fnOf(&s, "Hut", "__get_z").unwrap().body, want("getz"));
+    assert_eq!(fnOf(&s, "Hut", "__set_z").unwrap().body, want("setz"));
+}
+#[test]
+fn idempotent() {
+    let mut s = parseRaw(BASIC);
+    lowerTraits(&mut s);
+    let snap = s.clone();
+    assert!(lowerTraits(&mut s).is_empty());
+    assert_eq!(s, snap);
+}
+#[test]
+fn missing_required() {
+    let mut s = parseRaw("trait Ent(z: Int) =\n  fun up(self)\n\nrecord Hut(Ent)\n");
+    assert_eq!(
+        lowerTraits(&mut s),
+        vec!["record Hut embeds Ent but does not define required method up"]
+    );
+}
+#[test]
+fn field_clash() {
+    let mut s = parseRaw("trait Aa(x: Int)\ntrait Bb(x: Int)\nrecord Rec(Aa, Bb)\n");
+    assert_eq!(lowerTraits(&mut s), vec!["record Rec gets field x from both Aa and Bb"]);
+    let mut s = parseRaw("trait Aa(x: Int)\nrecord Rec(Aa, x: Int)\n");
+    assert_eq!(
+        lowerTraits(&mut s),
+        vec!["record Rec field x is already declared by trait Aa"]
+    );
+}
+#[test]
+fn default_clash() {
+    let src = "trait Aa =\n  fun f(self) -> Int = 1\ntrait Bb =\n  fun f(self) -> Int = 1\nrecord Rec(Aa, Bb)\n";
+    let mut s = parseRaw(src);
+    assert_eq!(
+        lowerTraits(&mut s),
+        vec!["record Rec gets default method f from both Aa and Bb; define Rec.f"]
+    );
+    let mut s = parseRaw(&format!("{}\n  fun f(self) -> Int = 1\n", src.trim_end().to_string() + " ="));
+    assert!(lowerTraits(&mut s).is_empty());
+}
+#[test]
+fn embed_not_trait() {
+    let mut s = parseRaw("struct Vec2(x: Float)\nrecord Rec(Vec2)\n");
+    assert_eq!(lowerTraits(&mut s), vec!["Rec embeds Vec2, which is not a trait"]);
+}
+#[test]
+fn struct_embed() {
+    let mut s = parseRaw("trait Ent(z: Int)\nstruct Stu(Ent, x: Int)\n");
+    assert_eq!(
+        lowerTraits(&mut s),
+        vec!["struct Stu cannot embed trait Ent; only records embed traits"]
+    );
+}
+#[test]
+fn self_recursive_field() {
+    let mut s = parseRaw("trait Act(children: List[Act])\nrecord Nod(Act)\n");
+    assert!(lowerTraits(&mut s).is_empty());
+    let t = &enumOf(&s, "Nod").variants[0].fields[0];
+    assert_eq!(t.name, "List");
+    assert_eq!(t.generics[0].name, "Act");
+}
+#[test]
+fn own_default_wins() {
+    let mut s = parseRaw(BASIC.replace("fun up(self) -> Int = 1", "fun up(self) -> Int = 1\n  fun gz(self) -> Int = 7").as_str());
+    assert!(lowerTraits(&mut s).is_empty());
+    assert_eq!(
+        s.items.iter().filter(|i| matches!(i, Item::Fn(f) if f.name == "gz")).count(),
+        1
+    );
+}
+#[test]
+fn no_embedders_gives_empty_union() {
+    let mut s = parseRaw("trait Lone(z: Int)\n");
+    assert!(lowerTraits(&mut s).is_empty());
+    let u = enumOf(&s, "Lone");
+    assert!(u.isTrait && u.variants.is_empty());
+}
+#[test]
+fn loader_runs_lowerTraits() {
+    let dir = std::env::temp_dir().join(format!("plum_traits_{}", std::process::id()));
+    std::fs::create_dir_all(dir.join("plum-std")).unwrap();
+    std::fs::write(dir.join("ent.plum"), "module ent\n\ntrait Ent(nxt: Ent) =\n  fun up(self)\n").unwrap();
+    std::fs::write(
+        dir.join("main.plum"),
+        "import ent\n\nrecord Hut(Ent) =\n  fun up(self) =\n    return\n",
+    )
+    .unwrap();
+    let r = plum_core::loadAndMerge(&dir.join("main.plum"), &dir);
+    let s = r.unwrap_or_else(|e| panic!("{}", e));
+    assert!(enumOf(&s, "Ent").isTrait);
+    assert_eq!(enumOf(&s, "Ent").variants[0].name, "Ent__Hut");
+    assert_eq!(enumOf(&s, "Hut").variants[0].field_names, vec!["nxt"]);
+    let _ = std::fs::remove_dir_all(&dir);
+}

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

@@ -1692,6 +1692,7 @@ fn desugarTestsToFns(source: &ast::Source) -> (ast::Source, Vec<(String, String)
             stars: source.stars.clone(),
             formLoops: source.formLoops,
             primitives: source.primitives.clone(),
+            traits: source.traits.clone(),
         },
         extra_exports,
     )