1ecfcf4 | plum | pyrossh

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

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

1ecfcf4 — Peter John 2026-11-01T18:24:09+05:30

T2: resolve + plan recorder

Files changed (4) hide show

plum-core/src/lib.rs +1 -0
plum-core/src/loader.rs +4 -0
plum-core/src/unions.rs +192 -0
plum-core/tests/unions_test.rs +127 -0

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 unions;
 pub use formatter::{
     formatSource, formatSourceWithOpts, inlineSingleStatementCaseBodies, FormatterError,

plum-core/src/loader.rs CHANGED Viewed

@@ -72,6 +72,10 @@ pub fn loadAndMergeWithOverrides(
         formLoops: false,
         primitives: prims,
     };
+    let memberErrors = crate::unions::resolveMembers(&mut merged);
+    if !memberErrors.is_empty() {
+        return Err(memberErrors.join("\n"));
+    }
     crate::forms::prepareForms(&mut merged);
     Ok(merged)
 }

plum-core/src/unions.rs ADDED Viewed

@@ -0,0 +1,192 @@
+//! Enums as unions of member types: member resolution and the plan recorder.
+//!
+//! `resolveMembers` turns each member variant of `enum Shape = Circle | Red`
+//! into a hidden positional variant `Shape__Circle(Circle)`; tags stay as they
+//! are. The checker records where unions are used (`UnionPlan`) and a later
+//! pass rewrites the program from that plan.
+use crate::ast::{Enum, EnumVariant, Item, Source, Type};
+use std::cell::{Cell, RefCell};
+use std::collections::HashMap;
+/// Types the compiler provides without an item in the source.
+const BUILTIN_MEMBERS: &[&str] = &["Int", "Float", "Byte"];
+/// `Shape__Circle`: the hidden variant that wraps member `Circle` of `Shape`.
+pub fn hiddenVariant(enumName: &str, member: &str) -> String {
+    format!("{enumName}__{member}")
+}
+fn isKnownType(source: &Source, name: &str) -> bool {
+    BUILTIN_MEMBERS.contains(&name)
+        || source.primitives.iter().any(|p| p.name == name)
+        || source.items.iter().any(|i| match i {
+            Item::Enum(e) => e.name == name,
+            Item::ErrorSet(s) => s.name == name,
+            _ => false,
+        })
+}
+/// Resolves every member variant of every enum in place. Returns one error
+/// message per problem. Safe to run twice: already hidden variants are skipped.
+pub fn resolveMembers(source: &mut Source) -> Vec<String> {
+    let mut errors = Vec::new();
+    // Decide per (enum, variant) first, then mutate: `isKnownType` borrows `source`.
+    let mut decisions: Vec<(usize, usize, bool)> = Vec::new();
+    for (ii, item) in source.items.iter().enumerate() {
+        let Item::Enum(e) = item else { continue };
+        if e.isValue || e.isRecord {
+            continue;
+        }
+        let pending: Vec<usize> = e
+            .variants
+            .iter()
+            .enumerate()
+            .filter(|(_, v)| match &v.member {
+                Some(m) => v.name != hiddenVariant(&e.name, &m.name),
+                None => false,
+            })
+            .map(|(vi, _)| vi)
+            .collect();
+        // Duplicate base names among members (resolved or not).
+        let mut bases: Vec<&str> = Vec::new();
+        let mut dup = false;
+        for v in &e.variants {
+            if let Some(m) = &v.member {
+                if bases.contains(&m.name.as_str()) && isKnownOrGeneric(source, e, m) {
+                    errors.push(format!(
+                        "enum {} has two {} members; a pattern '{}' would be ambiguous",
+                        e.name, m.name, m.name
+                    ));
+                    dup = true;
+                    break;
+                }
+                bases.push(&m.name);
+            }
+        }
+        if dup {
+            continue;
+        }
+        for vi in pending {
+            let v = &e.variants[vi];
+            let m = v.member.as_ref().unwrap();
+            // A variant named like its own enum is never a member.
+            let isMember = m.name != e.name
+                && (isKnownType(source, &m.name) || !m.generics.is_empty());
+            if isMember && !isKnownType(source, &m.name) {
+                errors.push(format!("unknown member type {}", m.name));
+                continue;
+            }
+            decisions.push((ii, vi, isMember));
+        }
+    }
+    for (ii, vi, isMember) in decisions {
+        let Item::Enum(e) = &mut source.items[ii] else { continue };
+        let enumName = e.name.clone();
+        let v: &mut EnumVariant = &mut e.variants[vi];
+        if isMember {
+            let m = v.member.clone().unwrap();
+            v.name = hiddenVariant(&enumName, &m.name);
+            v.fields = vec![m];
+            v.field_names = Vec::new();
+        } else {
+            v.member = None;
+        }
+    }
+    errors
+}
+/// A repeated name counts as a duplicate member only if it would resolve to a
+/// member (a repeated tag is a different, older problem).
+fn isKnownOrGeneric(source: &Source, e: &Enum, m: &Type) -> bool {
+    m.name != e.name && (isKnownType(source, &m.name) || !m.generics.is_empty())
+}
+/// Errors for the removed forms: inline payloads and a lone self-named variant.
+/// Written here, switched on by the migration task.
+pub fn legacyErrors(source: &Source) -> Vec<String> {
+    let mut errors = Vec::new();
+    for item in &source.items {
+        let Item::Enum(e) = item else { continue };
+        if e.isValue || e.isRecord {
+            continue;
+        }
+        for v in &e.variants {
+            if v.name == e.name {
+                errors.push(format!(
+                    "enum {0} has a single variant named {0} — write record {0}(...)",
+                    e.name
+                ));
+            } else if v.member.is_none() && v.values.is_empty() && !v.fields.is_empty() {
+                errors.push(format!(
+                    "inline variant payloads are removed: declare record {0}(...) and list {0} in enum {1}",
+                    v.name, e.name
+                ));
+            }
+        }
+    }
+    errors
+}
+/// The hidden variant of `enumName` that wraps member `member` (a base name).
+pub fn memberOf(source: &Source, enumName: &str, member: &str) -> Option<String> {
+    source.items.iter().find_map(|i| match i {
+        Item::Enum(e) if e.name == enumName => e.variants.iter().find_map(|v| {
+            let m = v.member.as_ref()?;
+            (m.name == member && v.name == hiddenVariant(enumName, member)).then(|| v.name.clone())
+        }),
+        _ => None,
+    })
+}
+// ---- plan recorder ----------------------------------------------------
+/// Where the checker found union uses, keyed by AST node address.
+#[derive(Debug, Clone, Default, PartialEq)]
+pub struct UnionPlan {
+    /// expression address -> hidden variant to wrap it in
+    pub wraps: HashMap<usize, String>,
+    /// pattern address -> hidden variant it matches
+    pub patterns: HashMap<usize, String>,
+    /// case address -> (subject, hidden variant, fresh binding name)
+    pub narrowings: HashMap<usize, (String, String, String)>,
+    /// call address -> hidden variants to dispatch over
+    pub dispatches: HashMap<usize, Vec<String>>,
+}
+thread_local! {
+    static PLAN: RefCell<UnionPlan> = RefCell::new(UnionPlan::default());
+    static FRESH: Cell<usize> = const { Cell::new(0) };
+}
+/// Starts a new plan: clears the recorder and the fresh-name counter.
+pub fn beginPlan() {
+    PLAN.with(|p| *p.borrow_mut() = UnionPlan::default());
+    FRESH.with(|c| c.set(0));
+}
+pub fn recordWrap(exprAddr: usize, variant: String) {
+    PLAN.with(|p| p.borrow_mut().wraps.insert(exprAddr, variant));
+}
+pub fn recordPattern(patAddr: usize, variant: String) {
+    PLAN.with(|p| p.borrow_mut().patterns.insert(patAddr, variant));
+}
+/// Records a narrowing; the binding gets the fresh name `<subject>__n<k>`.
+pub fn recordNarrow(caseAddr: usize, subject: String, variant: String) {
+    let k = FRESH.with(|c| {
+        c.set(c.get() + 1);
+        c.get()
+    });
+    let fresh = format!("{subject}__n{k}");
+    PLAN.with(|p| p.borrow_mut().narrowings.insert(caseAddr, (subject, variant, fresh)));
+}
+pub fn recordDispatch(callAddr: usize, variants: Vec<String>) {
+    PLAN.with(|p| p.borrow_mut().dispatches.insert(callAddr, variants));
+}
+/// Returns the recorded plan and clears the recorder.
+pub fn takePlan() -> UnionPlan {
+    PLAN.with(|p| std::mem::take(&mut *p.borrow_mut()))
+}

plum-core/tests/unions_test.rs ADDED Viewed

@@ -0,0 +1,127 @@
+#![allow(non_snake_case)]
+use plum_core::ast::*;
+use plum_core::unions::*;
+use plum_core::AstParser;
+fn parse(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).parseSource(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 ty(n: &str) -> Type {
+    Type { name: n.to_string(), generics: vec![] }
+}
+#[test]
+fn hiddenVariantName() {
+    assert_eq!(hiddenVariant("Shape", "Circle"), "Shape__Circle");
+}
+#[test]
+fn resolvesMemberAndTag() {
+    let mut s = parse("struct Circle(r: Float)\nenum Shape = Circle | Red");
+    assert!(resolveMembers(&mut s).is_empty());
+    let e = enumOf(&s, "Shape");
+    assert_eq!(e.variants[0].name, "Shape__Circle");
+    assert_eq!(e.variants[0].fields, vec![ty("Circle")]);
+    assert_eq!(e.variants[0].member, Some(ty("Circle")));
+    assert_eq!(e.variants[1].name, "Red");
+    assert!(e.variants[1].fields.is_empty());
+    assert_eq!(e.variants[1].member, None);
+}
+#[test]
+fn narrowFreshNames() {
+    beginPlan();
+    recordNarrow(0x10, "s".into(), "Shape__Circle".into());
+    recordNarrow(0x20, "s".into(), "Shape__Square".into());
+    let p = takePlan();
+    assert_eq!(p.narrowings[&0x10], ("s".into(), "Shape__Circle".into(), "s__n1".into()));
+    assert_eq!(p.narrowings[&0x20].2, "s__n2");
+    assert!(takePlan().narrowings.is_empty());
+    beginPlan();
+    recordNarrow(0x10, "s".into(), "V".into());
+    assert_eq!(takePlan().narrowings[&0x10].2, "s__n1");
+}
+#[test]
+fn recordsOtherKinds() {
+    beginPlan();
+    recordWrap(1, "A__B".into());
+    recordPattern(2, "A__B".into());
+    recordDispatch(3, vec!["A__B".into()]);
+    let p = takePlan();
+    assert_eq!(p.wraps[&1], "A__B");
+    assert_eq!(p.patterns[&2], "A__B");
+    assert_eq!(p.dispatches[&3], vec!["A__B".to_string()]);
+}
+#[test]
+fn dup_base_name() {
+    let mut s = parse("struct List(n: Int)\nenum Js = List[Int] | List[Str]");
+    assert_eq!(
+        resolveMembers(&mut s),
+        vec!["enum Js has two List members; a pattern 'List' would be ambiguous"]
+    );
+}
+#[test]
+fn member_in_two_enums() {
+    let mut s = parse("struct Circle(r: Float)\nenum Shape = Circle | Red\nenum Round = Circle | Blue");
+    assert!(resolveMembers(&mut s).is_empty());
+    assert_eq!(enumOf(&s, "Shape").variants[0].name, "Shape__Circle");
+    assert_eq!(enumOf(&s, "Round").variants[0].name, "Round__Circle");
+}
+#[test]
+fn idempotent() {
+    let mut s = parse("struct Circle(r: Float)\nenum Shape = Circle | Red");
+    resolveMembers(&mut s);
+    let once = s.clone();
+    assert!(resolveMembers(&mut s).is_empty());
+    assert_eq!(s, once);
+}
+#[test]
+fn memberOfLookup() {
+    let mut s = parse("struct Circle(r: Float)\nenum Shape = Circle | Red");
+    resolveMembers(&mut s);
+    assert_eq!(memberOf(&s, "Shape", "Circle"), Some("Shape__Circle".to_string()));
+    assert_eq!(memberOf(&s, "Shape", "Oval"), None);
+    assert_eq!(memberOf(&s, "Shape", "Red"), None);
+}
+#[test]
+fn unknownGenericMember() {
+    let mut s = parse("enum Js = Nope[Int]");
+    assert_eq!(resolveMembers(&mut s), vec!["unknown member type Nope"]);
+}
+#[test]
+fn builtinMember() {
+    let mut s = parse("enum Num = Int | Float");
+    assert!(resolveMembers(&mut s).is_empty());
+    assert_eq!(enumOf(&s, "Num").variants[0].name, "Num__Int");
+}
+#[test]
+fn legacyErrorsReported() {
+    let s = parse("enum Sh =\n  | Circle(r: Float)\nenum User =\n  | User(n: Int)\n");
+    let errs = legacyErrors(&s);
+    assert_eq!(errs.len(), 2);
+    assert!(errs[0].starts_with("inline variant payloads are removed: declare record Circle(...)"));
+    assert!(errs[1].contains("enum User has a single variant named User"));
+}