1b220d2 | plum

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

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

1b220d2 — Peter John 2026-07-20T15:24:15+05:30

feat(plum-checker): core generics specialization primitives

Files changed (3) hide show

plum-checker/src/lib.rs +1 -0
plum-checker/src/monomorphize.rs +167 -0
plum-checker/tests/monomorphize_tests.rs +128 -0

plum-checker/src/lib.rs CHANGED Viewed

@@ -1,4 +1,5 @@
 pub mod types;
+pub mod monomorphize;
 use std::collections::BTreeMap;
 use types::{PlumType, TypeEnv, TypeScheme, CheckError, CheckResult};

plum-checker/src/monomorphize.rs ADDED Viewed

@@ -0,0 +1,167 @@
+use std::collections::BTreeMap;
+use plum_core::ast;
+use crate::types::PlumType;
+/// A single lowercase letter (`a`, `b`, `c`, `d`, ...) is the grammar's only legal
+/// spelling for a generic type parameter — this is how we recognize one, since
+/// `ast::Fn` and `ast::Enum` (unlike `ast::Class`/`ast::Trait`) carry no explicit
+/// generics declaration list.
+pub fn is_generic_param_name(name: &str) -> bool {
+    let mut chars = name.chars();
+    match (chars.next(), chars.next()) {
+        (Some(c), None) => c.is_ascii_lowercase(),
+        _ => false,
+    }
+}
+/// The generic parameter names introduced by a `Class`, in declaration order.
+pub fn class_generic_params(c: &ast::Class) -> Vec<String> {
+    c.generics.iter().map(|g| g.name.clone()).collect()
+}
+/// The generic parameter names implicitly introduced by a `Fn` — every distinct
+/// single-lowercase-letter type name appearing in its params or return type, in
+/// first-appearance order.
+pub fn fn_generic_params(f: &ast::Fn) -> Vec<String> {
+    let mut names: Vec<String> = Vec::new();
+    let mut consider = |n: &str| {
+        if is_generic_param_name(n) && !names.iter().any(|x| x == n) {
+            names.push(n.to_string());
+        }
+    };
+    for p in &f.params {
+        match &p.ty {
+            ast::ParamType::Type(t) => consider(&t.name),
+            ast::ParamType::Variadic(t) => consider(&t.name),
+        }
+    }
+    if let Some(r) = &f.returns {
+        consider(&r.name);
+    }
+    names
+}
+/// The generic parameter names implicitly introduced by an `Enum` — every distinct
+/// single-lowercase-letter variant field type name, in first-appearance order.
+pub fn enum_generic_params(e: &ast::Enum) -> Vec<String> {
+    let mut names: Vec<String> = Vec::new();
+    for v in &e.variants {
+        for field_ty in &v.fields {
+            if is_generic_param_name(field_ty) && !names.iter().any(|x| x == field_ty) {
+                names.push(field_ty.clone());
+            }
+        }
+    }
+    names
+}
+/// A resolved binding from a generic item's parameter names to concrete types for
+/// one instantiation site, e.g. `{"a": Int}` for `Box(value: 5)`.
+#[derive(Debug, Clone)]
+pub struct Substitution(pub BTreeMap<String, PlumType>);
+impl Substitution {
+    fn get(&self, name: &str) -> Option<&PlumType> {
+        self.0.get(name)
+    }
+}
+/// Converts a resolved concrete `PlumType` back into the `ast::Type` shape needed
+/// to substitute into a declared field/param/return type position. Only ever
+/// called with types resolved from a real call-site argument's inferred type, so
+/// `TVar`/`TFun` (which never arise from a concrete argument) are an internal-error
+/// case rather than something this needs to model.
+fn plum_type_to_ast_type(t: &PlumType) -> ast::Type {
+    let name = match t {
+        PlumType::TInt => "Int".to_string(),
+        PlumType::TFloat => "Float".to_string(),
+        PlumType::TBool => "Bool".to_string(),
+        PlumType::TStr => "Str".to_string(),
+        PlumType::TUnit => "Unit".to_string(),
+        PlumType::TNamed(n) => n.clone(),
+        PlumType::TVar(_) | PlumType::TFun(_, _) => t.to_string(),
+    };
+    ast::Type { name, generics: vec![] }
+}
+fn substitute_type(ty: &ast::Type, subst: &Substitution) -> ast::Type {
+    if ty.generics.is_empty() {
+        if let Some(concrete) = subst.get(&ty.name) {
+            return plum_type_to_ast_type(concrete);
+        }
+    }
+    ast::Type {
+        name: ty.name.clone(),
+        generics: ty.generics.iter().map(|g| substitute_type(g, subst)).collect(),
+    }
+}
+/// Mangles a generic item's base name and its resolved concrete type arguments
+/// (in the item's own generic-parameter declaration order) into the internal name
+/// used for its specialized copy, e.g. `Box` + `[Int]` -> `"Box$Int"`.
+pub fn mangle(base: &str, type_args: &[PlumType]) -> String {
+    let mut out = base.to_string();
+    for t in type_args {
+        out.push('$');
+        out.push_str(&t.to_string());
+    }
+    out
+}
+/// Produces a concrete, specialized copy of a generic class under `mangled_name`,
+/// substituting every field whose declared type names one of the class's generic
+/// parameters with its resolved concrete type. The class's own `generics` list is
+/// cleared on the copy (it is now fully concrete).
+pub fn specialize_class(c: &ast::Class, subst: &Substitution, mangled_name: &str) -> ast::Class {
+    ast::Class {
+        name: mangled_name.to_string(),
+        implements: c.implements.clone(),
+        generics: vec![],
+        fields: c.fields.iter().map(|f| ast::Field {
+            name: f.name.clone(),
+            ty: substitute_type(&f.ty, subst),
+        }).collect(),
+    }
+}
+/// Produces a concrete, specialized copy of a generic function (or method) under
+/// `mangled_name`. `new_type_param` overrides the receiver-type name for a method
+/// whose receiver class was itself specialized (e.g. a method declared on `Box`
+/// becomes a method on `Box$Int`); pass the original `f.type_param.clone()`
+/// unchanged for a plain free function. The body is left structurally identical
+/// here — its own call sites are rewritten separately (Task 2), since expressions
+/// don't carry declared-type annotations the way fields/params/return types do.
+pub fn specialize_fn(f: &ast::Fn, subst: &Substitution, mangled_name: &str, new_type_param: Option<String>) -> ast::Fn {
+    ast::Fn {
+        name: mangled_name.to_string(),
+        type_param: new_type_param,
+        params: f.params.iter().map(|p| ast::Param {
+            name: p.name.clone(),
+            ty: match &p.ty {
+                ast::ParamType::Type(t) => ast::ParamType::Type(substitute_type(t, subst)),
+                ast::ParamType::Variadic(t) => ast::ParamType::Variadic(substitute_type(t, subst)),
+            },
+            default: p.default.clone(),
+        }).collect(),
+        returns: f.returns.as_ref().map(|r| {
+            let substituted = substitute_type(&ast::Type { name: r.name.clone(), generics: vec![] }, subst);
+            ast::ReturnType { name: substituted.name, generics: vec![] }
+        }),
+        body: f.body.clone(),
+    }
+}
+/// Produces a concrete, specialized copy of a generic enum under `mangled_name`,
+/// substituting every variant field type name that matches one of the enum's
+/// generic parameters with its resolved concrete type's name.
+pub fn specialize_enum(e: &ast::Enum, subst: &Substitution, mangled_name: &str) -> ast::Enum {
+    ast::Enum {
+        name: mangled_name.to_string(),
+        variants: e.variants.iter().map(|v| ast::EnumVariant {
+            name: v.name.clone(),
+            fields: v.fields.iter().map(|f| {
+                subst.get(f).map(|t| t.to_string()).unwrap_or_else(|| f.clone())
+            }).collect(),
+        }).collect(),
+    }
+}

plum-checker/tests/monomorphize_tests.rs ADDED Viewed

@@ -0,0 +1,128 @@
+use plum_checker::monomorphize::*;
+use plum_checker::types::PlumType;
+use plum_core::ast;
+#[test]
+fn is_generic_param_name_accepts_single_lowercase_letters_only() {
+    assert!(is_generic_param_name("a"));
+    assert!(is_generic_param_name("d"));
+    assert!(!is_generic_param_name("Int"));
+    assert!(!is_generic_param_name("ab"));
+    assert!(!is_generic_param_name("A"));
+    assert!(!is_generic_param_name(""));
+}
+#[test]
+fn class_generic_params_reads_declared_generics_list() {
+    let c = ast::Class {
+        name: "Box".to_string(),
+        implements: vec![],
+        generics: vec![ast::GenericParam { name: "a".to_string(), bounds: vec![] }],
+        fields: vec![ast::Field { name: "value".to_string(), ty: ast::Type { name: "a".to_string(), generics: vec![] } }],
+    };
+    assert_eq!(class_generic_params(&c), vec!["a".to_string()]);
+}
+#[test]
+fn fn_generic_params_detects_implicit_lowercase_letter_types_in_order() {
+    let f = ast::Fn {
+        name: "pair".to_string(),
+        type_param: None,
+        params: vec![
+            ast::Param { name: "first".to_string(), ty: ast::ParamType::Type(ast::Type { name: "a".to_string(), generics: vec![] }), default: None },
+            ast::Param { name: "second".to_string(), ty: ast::ParamType::Type(ast::Type { name: "b".to_string(), generics: vec![] }), default: None },
+        ],
+        returns: Some(ast::ReturnType { name: "Bool".to_string(), generics: vec![] }),
+        body: ast::FnBody::Block(ast::Block { stmts: vec![] }),
+    };
+    assert_eq!(fn_generic_params(&f), vec!["a".to_string(), "b".to_string()]);
+}
+#[test]
+fn enum_generic_params_detects_implicit_lowercase_letter_variant_fields() {
+    let e = ast::Enum {
+        name: "Option".to_string(),
+        variants: vec![
+            ast::EnumVariant { name: "Some".to_string(), fields: vec!["a".to_string()] },
+            ast::EnumVariant { name: "None".to_string(), fields: vec![] },
+        ],
+    };
+    assert_eq!(enum_generic_params(&e), vec!["a".to_string()]);
+}
+#[test]
+fn mangle_joins_base_name_and_type_args() {
+    assert_eq!(mangle("Box", &[PlumType::TInt]), "Box$Int");
+    assert_eq!(mangle("Pair", &[PlumType::TInt, PlumType::TStr]), "Pair$Int$Str");
+    assert_eq!(mangle("Green", &[]), "Green");
+}
+#[test]
+fn specialize_class_substitutes_generic_field_types_and_clears_generics_list() {
+    let c = ast::Class {
+        name: "Box".to_string(),
+        implements: vec![],
+        generics: vec![ast::GenericParam { name: "a".to_string(), bounds: vec![] }],
+        fields: vec![ast::Field { name: "value".to_string(), ty: ast::Type { name: "a".to_string(), generics: vec![] } }],
+    };
+    let mut bindings = std::collections::BTreeMap::new();
+    bindings.insert("a".to_string(), PlumType::TInt);
+    let specialized = specialize_class(&c, &Substitution(bindings), "Box$Int");
+    assert_eq!(specialized.name, "Box$Int");
+    assert!(specialized.generics.is_empty());
+    assert_eq!(specialized.fields[0].ty.name, "Int");
+}
+#[test]
+fn specialize_fn_substitutes_generic_param_and_return_types() {
+    let f = ast::Fn {
+        name: "wrap".to_string(),
+        type_param: None,
+        params: vec![ast::Param { name: "value".to_string(), ty: ast::ParamType::Type(ast::Type { name: "a".to_string(), generics: vec![] }), default: None }],
+        returns: Some(ast::ReturnType { name: "a".to_string(), generics: vec![] }),
+        body: ast::FnBody::Expr(ast::Expr::Var("value".to_string())),
+    };
+    let mut bindings = std::collections::BTreeMap::new();
+    bindings.insert("a".to_string(), PlumType::TInt);
+    let specialized = specialize_fn(&f, &Substitution(bindings), "wrap$Int", None);
+    assert_eq!(specialized.name, "wrap$Int");
+    match &specialized.params[0].ty {
+        ast::ParamType::Type(t) => assert_eq!(t.name, "Int"),
+        _ => panic!("expected ParamType::Type"),
+    }
+    assert_eq!(specialized.returns.unwrap().name, "Int");
+}
+#[test]
+fn specialize_fn_sets_new_receiver_for_a_method() {
+    let f = ast::Fn {
+        name: "getValue".to_string(),
+        type_param: Some("Box".to_string()),
+        params: vec![],
+        returns: Some(ast::ReturnType { name: "a".to_string(), generics: vec![] }),
+        body: ast::FnBody::Expr(ast::Expr::Self_),
+    };
+    let mut bindings = std::collections::BTreeMap::new();
+    bindings.insert("a".to_string(), PlumType::TStr);
+    let specialized = specialize_fn(&f, &Substitution(bindings), "getValue", Some("Box$Str".to_string()));
+    assert_eq!(specialized.name, "getValue");
+    assert_eq!(specialized.type_param, Some("Box$Str".to_string()));
+    assert_eq!(specialized.returns.unwrap().name, "Str");
+}
+#[test]
+fn specialize_enum_substitutes_generic_variant_field_names() {
+    let e = ast::Enum {
+        name: "Option".to_string(),
+        variants: vec![
+            ast::EnumVariant { name: "Some".to_string(), fields: vec!["a".to_string()] },
+            ast::EnumVariant { name: "None".to_string(), fields: vec![] },
+        ],
+    };
+    let mut bindings = std::collections::BTreeMap::new();
+    bindings.insert("a".to_string(), PlumType::TInt);
+    let specialized = specialize_enum(&e, &Substitution(bindings), "Option$Int");
+    assert_eq!(specialized.name, "Option$Int");
+    assert_eq!(specialized.variants[0].fields, vec!["Int".to_string()]);
+    assert!(specialized.variants[1].fields.is_empty());
+}