afc0334 | plum | pyrossh

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

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

afc0334 — Peter John 2026-11-01T23:26:02+05:30

fix: bare generic type name inside its own methods compiles (applyOwnGenerics pre-pass)

Files changed (2) hide show

plum-checker/src/lib.rs +124 -0
plum-examples/generics.plum +50 -0

plum-checker/src/lib.rs CHANGED Viewed

@@ -1103,6 +1103,15 @@ pub fn typedSource(source: &ast::Source) -> CheckResult<TypedInfo> {
 }
 fn checkSourceFull(source: &ast::Source) -> (CheckResult<()>, TypedInfo) {
+    if let Some(applied) = applyOwnGenerics(source) {
+        // Check (and let codegen compile) the copy with bare own-generic names applied.
+        let applied = std::rc::Rc::new(applied);
+        let (result, mut info) = checkSourceFull(&applied);
+        if info.lowered.is_none() {
+            info.lowered = Some(applied);
+        }
+        return (result, info);
+    }
     if !source.formLoops {
         return checkUnions(source, |s| checkSourceOnce(s));
     }
@@ -1221,6 +1230,121 @@ fn fillErrorTables(source: &ast::Source, info: &mut TypedInfo) {
     info.error_codes = all.into_iter().zip(1..).collect();
 }
+/// Inside a generic type's own methods and field types, a bare `Crate` (for
+/// `record Crate[T]`) means `Crate[T]`, the declaration's own type arguments.
+/// Returns a copy of `source` with every such type annotation (params, returns,
+/// yields, annotated locals, explicit construction generics, fields) applied,
+/// so the checker and codegen both see the same `TApp`; `None` if there is none.
+fn applyOwnGenerics(source: &ast::Source) -> Option<ast::Source> {
+    let own: HashMap<&str, Vec<ast::Type>> = source
+        .items
+        .iter()
+        .filter_map(|i| match i {
+            ast::Item::Enum(e) if !e.generics.is_empty() => Some((
+                e.name.as_str(),
+                e.generics.iter().map(|g| ast::Type { name: g.name.clone(), generics: vec![] }).collect(),
+            )),
+            _ => None,
+        })
+        .collect();
+    if own.is_empty() {
+        return None;
+    }
+    fn apply(t: &mut ast::Type, name: &str, args: &[ast::Type], changed: &mut bool) {
+        if t.name == name && t.generics.is_empty() {
+            t.generics = args.to_vec();
+            *changed = true;
+        }
+        for g in &mut t.generics {
+            apply(g, name, args, changed);
+        }
+    }
+    // Statement-level annotations (`c: Crate := ...`) in `stmts` and their nested blocks.
+    fn stmtTypes(stmts: &mut [ast::Stmt], fix: &mut dyn FnMut(&mut ast::Type)) {
+        for s in stmts {
+            match s {
+                ast::Stmt::Assign(a) => a.ty.iter_mut().for_each(&mut *fix),
+                ast::Stmt::While(w) => stmtTypes(&mut w.body.stmts, fix),
+                ast::Stmt::ForLoop(l) => stmtTypes(&mut l.body.stmts, fix),
+                ast::Stmt::If(i) => {
+                    stmtTypes(&mut i.body.stmts, fix);
+                    for e in &mut i.else_ifs {
+                        stmtTypes(&mut e.body.stmts, fix);
+                    }
+                    if let Some(b) = &mut i.else_ {
+                        stmtTypes(&mut b.stmts, fix);
+                    }
+                }
+                ast::Stmt::Match(m) => m.cases.iter_mut().for_each(|c| stmtTypes(&mut c.body.stmts, fix)),
+                _ => {}
+            }
+        }
+    }
+    let mut replaced: Vec<(usize, ast::Item)> = Vec::new();
+    for (idx, item) in source.items.iter().enumerate() {
+        let (name, args) = match item {
+            ast::Item::Enum(e) => match own.get_key_value(e.name.as_str()) {
+                Some((n, a)) => (*n, a),
+                None => continue,
+            },
+            ast::Item::Fn(f) => match f.type_param.as_deref().and_then(|r| own.get_key_value(r)) {
+                Some((n, a)) => (*n, a),
+                None => continue,
+            },
+            _ => continue,
+        };
+        let mut changed = false;
+        let mut fix = |t: &mut ast::Type| apply(t, name, args, &mut changed);
+        let mut item = item.clone();
+        match &mut item {
+            ast::Item::Enum(e) => {
+                e.variants.iter_mut().flat_map(|v| v.fields.iter_mut()).for_each(&mut fix);
+                e.params.iter_mut().for_each(|p| fix(&mut p.ty));
+            }
+            ast::Item::Fn(f) => {
+                for p in &mut f.params {
+                    match &mut p.ty {
+                        ast::ParamType::Type(t) | ast::ParamType::Variadic(t) | ast::ParamType::Seq(t) => fix(t),
+                        ast::ParamType::Fn(ps, ret) => {
+                            ps.iter_mut().for_each(&mut fix);
+                            if let Some(r) = ret {
+                                fix(r);
+                            }
+                        }
+                    }
+                }
+                f.returns.iter_mut().for_each(&mut fix);
+                f.yields.iter_mut().flatten().for_each(&mut fix);
+                if let ast::FnBody::Block(b) = &mut f.body {
+                    stmtTypes(&mut b.stmts, &mut fix);
+                }
+                plum_core::forms::mapExprs(&mut f.body, &mut |e| match e {
+                    ast::Expr::ClassCall(c) => c.generics.iter_mut().for_each(&mut fix),
+                    ast::Expr::Closure(c) => stmtTypes(&mut c.body.stmts, &mut fix),
+                    ast::Expr::Catch(c) => {
+                        if let ast::CatchHandler::Block { body, .. } = &mut c.handler {
+                            stmtTypes(&mut body.stmts, &mut fix);
+                        }
+                    }
+                    _ => {}
+                });
+            }
+            _ => unreachable!(),
+        }
+        if changed {
+            replaced.push((idx, item));
+        }
+    }
+    if replaced.is_empty() {
+        return None;
+    }
+    let mut copy = source.clone();
+    for (idx, item) in replaced {
+        copy.items[idx] = item;
+    }
+    Some(copy)
+}
 /// A generic type named without type arguments (`p: Parcel` for `enum
 /// Parcel[T]`) has no known payload representation at runtime, so it is
 /// rejected in signatures and field types. Inside the generic's own methods the

plum-examples/generics.plum CHANGED Viewed

@@ -102,6 +102,44 @@ fun strContentsOr(p: Parcel[Str], default: Int) -> Int =
     Delivered(v) => v.length()
     Lost => default
+# Inside a generic type's own methods and fields, the bare name means the
+# type applied to its own parameters: `Crate` is `Crate[T]` there.
+record Crate[T](value: T) =
+  fun same(self) -> Crate =
+    self
+  fun pick(self, other: Crate, useOther: Bool) -> Crate =
+    if useOther then other else self
+  fun viaLocal(self) -> T =
+    c: Crate := self
+    kept := List[Crate]()
+    kept.push(c)
+    kept.at(0).value
+record Chain[T](v: T, next: Chain?) =
+  fun last(self) -> T =
+    cur: Chain := self
+    while n := cur.next
+      cur = n
+    cur.v
+record Stashed[T](v: T)
+enum Stash[T] =
+  | Stashed[T]
+  | Unstashed
+  fun same(self) -> Stash =
+    self
+fun stashedOr(s: Stash[Int], default: Int) -> Int =
+  match s.same()
+    Stashed(v) => v
+    Unstashed => default
 test "Int extremes survive a generic fn"
   big := 9223372036854775807
   small := 0 - 9223372036854775807 - 1
@@ -279,3 +317,15 @@ test "a generic enum is specialized per type and matched"
   assert intContentsOr(Lost, 5) == 5
   assert strContentsOr(Delivered("abcd"), 0) == 4
   assert intContentsOr(Delivered(13), 0) + strContentsOr(Delivered("abcd"), 0) == 17
+test "a bare generic type name inside its own methods means its applied form"
+  assert Crate(value: 3).same().value == 3
+  assert Crate(value: "s").same().value == "s"
+  assert Crate(value: 1).pick(Crate(value: 2), true).value == 2
+  assert Crate(value: "a").pick(Crate(value: "b"), false).value == "a"
+  assert Crate(value: 7).viaLocal() == 7
+  assert Crate(value: "x").viaLocal() == "x"
+  assert Chain(v: 1, next: Chain(v: 2, next: Chain(v: 3, next: null))).last() == 3
+  assert Chain(v: "p", next: Chain(v: "q", next: null)).last() == "q"
+  assert stashedOr(Stashed(5), 0) == 5
+  assert stashedOr(Unstashed, 9) == 9