0a830c8 | plum

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

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

0a830c8 — Peter John 2026-07-19T17:22:28+05:30

refactor: restructure as Cargo workspace, add plum-core skeleton

Files changed (9) hide show

Cargo.toml +3 -9
plum-cli/Cargo.toml +7 -0
plum-cli/src/lib.rs +1 -0
plum-core/Cargo.toml +10 -0
plum-core/src/ast.rs +354 -0
plum-core/src/formatter.rs +19 -0
plum-core/src/lib.rs +6 -0
plum-core/src/parser.rs +764 -0
tooling/tree-sitter-plum/Cargo.toml +1 -1

Cargo.toml CHANGED Viewed

@@ -1,9 +1,3 @@
-[package]
+[workspace]
-name = "plum"
-version = "0.1.0"
-edition = "2021"
-[dependencies]
-baz-tree-sitter-traversal = "0.1.4"
+members = ["plum-core", "plum-cli"]
-tree-sitter = "0.24.5"
+resolver = "2"
-tree-sitter-plum = "0.1.0"

plum-cli/Cargo.toml ADDED Viewed

@@ -0,0 +1,7 @@
+[package]
+name = "plum-cli"
+version = "0.1.0"
+edition = "2021"
+[dependencies]
+plum-core = { path = "../plum-core" }

plum-cli/src/lib.rs ADDED Viewed

	@@ -0,0 +1 @@
1	+ // plum-cli library placeholder

plum-core/Cargo.toml ADDED Viewed

@@ -0,0 +1,10 @@
+[package]
+name = "plum-core"
+version = "0.1.0"
+edition = "2021"
+[dependencies]
+tree-sitter = "0.26"
+tree-sitter-plum = { path = "../tooling/tree-sitter-plum" }
+topiary-core = "0.7.3"
+topiary-tree-sitter-facade = "0.7.3"

plum-core/src/ast.rs ADDED Viewed

@@ -0,0 +1,354 @@
+#[derive(Debug, Clone, PartialEq)]
+pub struct Source {
+    pub module: Option<Module>,
+    pub imports: Vec<Import>,
+    pub items: Vec<Item>,
+}
+#[derive(Debug, Clone, PartialEq)]
+pub struct Module {
+    pub name: String,
+}
+#[derive(Debug, Clone, PartialEq)]
+pub struct Import {
+    pub path: String,
+}
+#[derive(Debug, Clone, PartialEq)]
+pub enum Item {
+    Class(Class),
+    Trait(Trait),
+    Enum(Enum),
+    Fn(Fn),
+    Const(Const),
+}
+// ---------- Type definitions ----------
+#[derive(Debug, Clone, PartialEq)]
+pub struct Class {
+    pub name: String,
+    pub implements: Vec<String>,
+    pub generics: Vec<GenericParam>,
+    pub fields: Vec<Field>,
+}
+#[derive(Debug, Clone, PartialEq)]
+pub struct GenericParam {
+    pub name: String,
+    pub bounds: Vec<String>,
+}
+#[derive(Debug, Clone, PartialEq)]
+pub struct Field {
+    pub name: String,
+    pub ty: Type,
+}
+#[derive(Debug, Clone, PartialEq)]
+pub struct Trait {
+    pub name: String,
+    pub generics: Vec<GenericParam>,
+    pub methods: Vec<TraitMethod>,
+}
+#[derive(Debug, Clone, PartialEq)]
+pub struct TraitMethod {
+    pub name: String,
+    pub params: Vec<Param>,
+    pub returns: Option<ReturnType>,
+}
+#[derive(Debug, Clone, PartialEq)]
+pub struct Enum {
+    pub name: String,
+    pub variants: Vec<EnumVariant>,
+}
+#[derive(Debug, Clone, PartialEq)]
+pub struct EnumVariant {
+    pub name: String,
+    pub fields: Vec<String>,
+}
+// ---------- Functions ----------
+#[derive(Debug, Clone, PartialEq)]
+pub struct Fn {
+    pub name: String,
+    /// Type parameter for method dispatch, e.g. `<Cat>` in `toStr<Cat>()`
+    pub type_param: Option<String>,
+    pub params: Vec<Param>,
+    pub returns: Option<ReturnType>,
+    pub body: FnBody,
+}
+#[derive(Debug, Clone, PartialEq)]
+pub struct Const {
+    pub name: String,
+    pub value: Expr,
+}
+#[derive(Debug, Clone, PartialEq)]
+pub struct Param {
+    pub name: String,
+    pub ty: ParamType,
+    pub default: Option<Expr>,
+}
+#[derive(Debug, Clone, PartialEq)]
+pub enum ParamType {
+    Type(Type),
+    Variadic(Type),
+}
+#[derive(Debug, Clone, PartialEq)]
+pub struct Type {
+    pub name: String,
+    pub generics: Vec<Type>,
+}
+#[derive(Debug, Clone, PartialEq)]
+pub struct ReturnType {
+    pub name: String,
+    pub generics: Vec<GenericParam>,
+}
+#[derive(Debug, Clone, PartialEq)]
+pub enum FnBody {
+    Expr(Expr),
+    Block(Block),
+}
+// ---------- Statements ----------
+#[derive(Debug, Clone, PartialEq)]
+pub struct Block {
+    pub stmts: Vec<Stmt>,
+}
+#[derive(Debug, Clone, PartialEq)]
+pub enum Stmt {
+    Assign(Assign),
+    Break,
+    Continue,
+    Assert(Expr),
+    For(For),
+    While(While),
+    If(If),
+    Match(Match),
+    Return(Option<Expr>),
+    Todo,
+    Expr(Expr),
+}
+#[derive(Debug, Clone, PartialEq)]
+pub struct Assign {
+    pub targets: Vec<String>,
+    pub values: Vec<Expr>,
+}
+#[derive(Debug, Clone, PartialEq)]
+pub struct For {
+    pub vars: Vec<String>,
+    pub iter: Expr,
+    pub body: Block,
+}
+#[derive(Debug, Clone, PartialEq)]
+pub struct While {
+    pub condition: Expr,
+    pub body: Block,
+}
+#[derive(Debug, Clone, PartialEq)]
+pub struct If {
+    pub condition: Expr,
+    pub body: Block,
+    pub else_ifs: Vec<ElseIf>,
+    pub else_: Option<Block>,
+}
+#[derive(Debug, Clone, PartialEq)]
+pub struct ElseIf {
+    pub condition: Expr,
+    pub body: Block,
+}
+#[derive(Debug, Clone, PartialEq)]
+pub struct Match {
+    pub subjects: Vec<Expr>,
+    pub cases: Vec<Case>,
+}
+#[derive(Debug, Clone, PartialEq)]
+pub struct Case {
+    pub patterns: Vec<CasePattern>,
+    pub body: Block,
+}
+#[derive(Debug, Clone, PartialEq)]
+pub enum CasePattern {
+    Class { name: String, fields: Vec<CasePattern> },
+    String(String),
+    Int(i64),
+    Float(f64),
+    Name(String),
+    Wildcard,
+}
+// ---------- Expressions ----------
+/// Expressions are the core of the language. Operator precedence is already
+/// resolved by the tree-sitter parser (via the PREC table in grammar.js), so
+/// the tree structure here directly reflects evaluation order.
+#[derive(Debug, Clone, PartialEq)]
+pub enum Expr {
+    /// Arithmetic / bitwise / range: `a + b`, `a .. b`, etc.
+    Binary(Box<BinaryExpr>),
+    /// Prefix `+` or `-`
+    Unary(Box<UnaryExpr>),
+    /// `&&` / `||`
+    Bool(Box<BoolExpr>),
+    /// `!expr`
+    Not(Box<Expr>),
+    /// `<`, `<=`, `==`, `!=`, `>=`, `>`, `<>`
+    Compare(Box<CompareExpr>),
+    /// `cond ? then : else`
+    Ternary(Box<TernaryExpr>),
+    /// `fnName(args…)`
+    FnCall(FnCall),
+    /// `TypeName(field: value, …)`
+    ClassCall(ClassCall),
+    /// `expr.field` or `expr.method(…)`
+    Attribute(Box<AttributeExpr>),
+    /// `{expr}` — grouped/parenthesized expression
+    Paren(Box<Expr>),
+    String(StringExpr),
+    Int(i64),
+    Float(f64),
+    Self_,
+    Var(String),
+    TypeName(String),
+}
+#[derive(Debug, Clone, PartialEq)]
+pub struct BinaryExpr {
+    pub op: BinOp,
+    pub left: Expr,
+    pub right: Expr,
+}
+#[derive(Debug, Clone, PartialEq)]
+pub enum BinOp {
+    Add,
+    Sub,
+    Mul,
+    Div,
+    Mod,
+    BitOr,
+    BitAnd,
+    Xor,
+    Shl,
+    Shr,
+    Range,
+}
+#[derive(Debug, Clone, PartialEq)]
+pub struct UnaryExpr {
+    pub op: UnOp,
+    pub operand: Expr,
+}
+#[derive(Debug, Clone, PartialEq)]
+pub enum UnOp {
+    Pos,
+    Neg,
+}
+#[derive(Debug, Clone, PartialEq)]
+pub struct BoolExpr {
+    pub op: BoolOp,
+    pub left: Expr,
+    pub right: Expr,
+}
+#[derive(Debug, Clone, PartialEq)]
+pub enum BoolOp {
+    And,
+    Or,
+}
+#[derive(Debug, Clone, PartialEq)]
+pub struct CompareExpr {
+    pub op: CmpOp,
+    pub left: Expr,
+    pub right: Expr,
+}
+#[derive(Debug, Clone, PartialEq)]
+pub enum CmpOp {
+    Lt,
+    Lte,
+    Eq,
+    Neq,
+    Gte,
+    Gt,
+    NotEq2,
+}
+#[derive(Debug, Clone, PartialEq)]
+pub struct TernaryExpr {
+    pub condition: Expr,
+    pub then: Expr,
+    pub else_: Expr,
+}
+#[derive(Debug, Clone, PartialEq)]
+pub struct FnCall {
+    pub name: String,
+    pub args: Vec<Arg>,
+}
+#[derive(Debug, Clone, PartialEq)]
+pub enum Arg {
+    Positional(Expr),
+    Keyword { name: String, value: Expr },
+    Pair { key: String, value: Expr },
+}
+#[derive(Debug, Clone, PartialEq)]
+pub struct ClassCall {
+    pub type_name: String,
+    pub fields: Vec<FieldArg>,
+}
+#[derive(Debug, Clone, PartialEq)]
+pub struct FieldArg {
+    pub name: String,
+    pub value: Expr,
+}
+#[derive(Debug, Clone, PartialEq)]
+pub struct AttributeExpr {
+    pub object: Expr,
+    pub attr: AttrKind,
+}
+#[derive(Debug, Clone, PartialEq)]
+pub enum AttrKind {
+    Field(String),
+    Method(FnCall),
+}
+#[derive(Debug, Clone, PartialEq)]
+pub struct StringExpr {
+    pub parts: Vec<StringPart>,
+}
+#[derive(Debug, Clone, PartialEq)]
+pub enum StringPart {
+    Text(String),
+    Interp(Expr),
+}

plum-core/src/formatter.rs ADDED Viewed

@@ -0,0 +1,19 @@
+// plum-core/src/formatter.rs
+#[derive(Debug)]
+pub enum FormatterError {
+    TopiaryCoreError(String),
+}
+impl std::fmt::Display for FormatterError {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            FormatterError::TopiaryCoreError(msg) => write!(f, "Topiary error: {msg}"),
+        }
+    }
+}
+impl std::error::Error for FormatterError {}
+pub fn format_source(_source: &str) -> Result<String, FormatterError> {
+    unimplemented!()
+}

plum-core/src/lib.rs ADDED Viewed

@@ -0,0 +1,6 @@
+pub mod ast;
+pub mod parser;
+pub mod formatter;
+pub use formatter::{format_source, FormatterError};
+pub use parser::AstParser;

plum-core/src/parser.rs ADDED Viewed

@@ -0,0 +1,764 @@
+use tree_sitter::Node;
+use crate::ast::*;
+pub struct AstParser<'a> {
+    source: &'a [u8],
+}
+impl<'a> AstParser<'a> {
+    pub fn new(source: &'a str) -> Self {
+        AstParser { source: source.as_bytes() }
+    }
+    fn text(&self, node: Node) -> String {
+        node.utf8_text(self.source).unwrap_or("").to_string()
+    }
+    /// Peel transparent `expression` / `primary_expression` wrapper nodes.
+    fn unwrap_expr_node<'b>(&self, node: Node<'b>) -> Node<'b> {
+        match node.kind() {
+            "expression" | "primary_expression" => {
+                node.named_child(0).map(|c| self.unwrap_expr_node(c)).unwrap_or(node)
+            }
+            _ => node,
+        }
+    }
+    /// Collect named children of `node` that have the given `kind`.
+    fn children_of_kind(&self, node: Node<'a>, kind: &str) -> Vec<Node<'a>> {
+        let mut cursor = node.walk();
+        node.named_children(&mut cursor)
+            .filter(|n| n.kind() == kind)
+            .collect()
+    }
+    // ---- top level --------------------------------------------------------
+    pub fn parse_source(&self, node: Node) -> Source {
+        assert_eq!(node.kind(), "source");
+        let mut module = None;
+        let mut imports = Vec::new();
+        let mut items = Vec::new();
+        let mut cursor = node.walk();
+        for child in node.named_children(&mut cursor) {
+            match child.kind() {
+                "module" => module = Some(self.parse_module(child)),
+                "import" => imports.push(self.parse_import(child)),
+                "class" => items.push(Item::Class(self.parse_class(child))),
+                "trait" => items.push(Item::Trait(self.parse_trait(child))),
+                "enum" => items.push(Item::Enum(self.parse_enum(child))),
+                "fn" => items.push(Item::Fn(self.parse_fn(child))),
+                "const" => items.push(Item::Const(self.parse_const(child))),
+                _ => {}
+            }
+        }
+        Source { module, imports, items }
+    }
+    fn parse_module(&self, node: Node) -> Module {
+        // module: "module" mod_identifier
+        // named_child(0) = mod_identifier
+        let name = node.named_child(0).map(|n| self.text(n)).unwrap_or_default();
+        Module { name }
+    }
+    fn parse_import(&self, node: Node) -> Import {
+        // import: "import" url — url is the only named child
+        let path = node.named_child(0).map(|n| self.text(n)).unwrap_or_default();
+        Import { path }
+    }
+    // ---- class / trait / enum ---------------------------------------------
+    fn parse_class(&self, node: Node) -> Class {
+        // class: "type" type_identifier ("(" type_identifier,* ")")? generics? "=" body
+        // Named children in order: type_identifier (name), type_identifier* (implements), field*
+        let mut cursor = node.walk();
+        let named: Vec<Node> = node.named_children(&mut cursor).collect();
+        let name = named.first().map(|n| self.text(*n)).unwrap_or_default();
+        // implements = type_identifiers that appear before any `field` node
+        let implements: Vec<String> = named[1..]
+            .iter()
+            .take_while(|n| n.kind() == "type_identifier")
+            .map(|n| self.text(*n))
+            .collect();
+        let generics = self.parse_generics_field(node);
+        let fields: Vec<Field> = named
+            .iter()
+            .filter(|n| n.kind() == "field")
+            .map(|n| self.parse_field(*n))
+            .collect();
+        Class { name, implements, generics, fields }
+    }
+    fn parse_generics_field(&self, node: Node) -> Vec<GenericParam> {
+        // generics: "(" generic_type,* ")"
+        // The generics node is not field-named in a straightforward way; look
+        // for a child whose kind is "generics".
+        let generics_node = self.children_of_kind(node, "generics").into_iter().next();
+        generics_node.map(|g| {
+            self.children_of_kind(g, "generic_type")
+                .into_iter()
+                .map(|n| self.parse_generic_type(n))
+                .collect()
+        }).unwrap_or_default()
+    }
+    fn parse_generic_type(&self, node: Node) -> GenericParam {
+        // generic_type: generic (":" sep1(type_identifier, "+"))?
+        // named_child(0) = generic (single letter)
+        // remaining named children = bound type_identifiers
+        let name = node.named_child(0).map(|n| self.text(n)).unwrap_or_default();
+        let bounds = (1..node.named_child_count())
+            .filter_map(|i| node.named_child(i as u32))
+            .map(|n| self.text(n))
+            .collect();
+        GenericParam { name, bounds }
+    }
+    fn parse_field(&self, node: Node) -> Field {
+        // class_field (aliased to field): var_identifier ":" type
+        let name = node.named_child(0).map(|n| self.text(n)).unwrap_or_default();
+        let ty = node
+            .named_child(1)
+            .map(|n| self.parse_type(n))
+            .unwrap_or(Type { name: String::new(), generics: vec![] });
+        Field { name, ty }
+    }
+    fn parse_trait(&self, node: Node) -> Trait {
+        // trait: "trait" type_identifier generics? "=" body
+        let name = node.named_child(0).map(|n| self.text(n)).unwrap_or_default();
+        let generics = self.parse_generics_field(node);
+        let methods = self.children_of_kind(node, "field")
+            .into_iter()
+            .map(|f| self.parse_trait_method(f))
+            .collect();
+        Trait { name, generics, methods }
+    }
+    fn parse_trait_method(&self, node: Node) -> TraitMethod {
+        // trait_field (aliased to field): fn_identifier "(" params ")" ("->" return_type)?
+        let name = node.named_child(0).map(|n| self.text(n)).unwrap_or_default();
+        let params = self.collect_params_from(node);
+        let returns = node
+            .named_children(&mut node.walk())
+            .find(|n| n.kind() == "return_type")
+            .map(|n| self.parse_return_type(n));
+        TraitMethod { name, params, returns }
+    }
+    fn parse_enum(&self, node: Node) -> Enum {
+        let name = node.named_child(0).map(|n| self.text(n)).unwrap_or_default();
+        let variants = self.children_of_kind(node, "field")
+            .into_iter()
+            .map(|f| self.parse_enum_variant(f))
+            .collect();
+        Enum { name, variants }
+    }
+    fn parse_enum_variant(&self, node: Node) -> EnumVariant {
+        // enum_field (aliased to field): "|" type_identifier ("(" type_identifier,* ")")?
+        // named children: type_identifier (name), type_identifier* (fields inside "()")
+        let name = node.named_child(0).map(|n| self.text(n)).unwrap_or_default();
+        let fields: Vec<String> = (1..node.named_child_count())
+            .filter_map(|i| node.named_child(i as u32))
+            .filter(|n| n.kind() == "type_identifier")
+            .map(|n| self.text(n))
+            .collect();
+        EnumVariant { name, fields }
+    }
+    // ---- functions --------------------------------------------------------
+    fn parse_fn(&self, node: Node) -> Fn {
+        // fn: fn_identifier type? "(" param,* ")" ("->" return_type)? "=" body_or_expr
+        // Named children: fn_identifier, type?, param*, return_type?, body/expr
+        let mut cursor = node.walk();
+        let named: Vec<Node> = node.named_children(&mut cursor).collect();
+        let name = named.first().map(|n| self.text(*n)).unwrap_or_default();
+        // type param — the `<Cat>` node has kind "type" and contains a type_identifier
+        let type_param = named
+            .iter()
+            .find(|n| n.kind() == "type")
+            .and_then(|t| t.named_child(0))
+            .map(|n| self.text(n));
+        let params: Vec<Param> = named
+            .iter()
+            .filter(|n| n.kind() == "param")
+            .map(|n| self.parse_param(*n))
+            .collect();
+        let returns = named
+            .iter()
+            .find(|n| n.kind() == "return_type")
+            .map(|n| self.parse_return_type(*n));
+        // body is the last named child — it is either a `body` node (block)
+        // or an expression node when the body is a single expression.
+        let body = named.last().and_then(|last| {
+            match last.kind() {
+                // Skip non-body trailing nodes
+                "fn_identifier" | "type" | "param" | "return_type" => None,
+                "body" => Some(FnBody::Block(self.parse_block(*last))),
+                _ => {
+                    let unwrapped = self.unwrap_expr_node(*last);
+                    Some(FnBody::Expr(self.parse_expression(unwrapped)))
+                }
+            }
+        }).unwrap_or(FnBody::Block(Block { stmts: vec![] }));
+        Fn { name, type_param, params, returns, body }
+    }
+    fn parse_const(&self, node: Node) -> Const {
+        // const: const_identifier "=" expression
+        let name = node.named_child(0).map(|n| self.text(n)).unwrap_or_default();
+        let value = node
+            .named_child(1)
+            .map(|n| {
+                let unwrapped = self.unwrap_expr_node(n);
+                self.parse_expression(unwrapped)
+            })
+            .unwrap_or(Expr::Int(0));
+        Const { name, value }
+    }
+    // ---- params / return type ---------------------------------------------
+    /// Collect `param` named children from any node that has them.
+    fn collect_params_from(&self, node: Node) -> Vec<Param> {
+        self.children_of_kind(node, "param")
+            .into_iter()
+            .map(|n| self.parse_param(n))
+            .collect()
+    }
+    fn parse_param(&self, node: Node) -> Param {
+        // param: var_identifier ":" (type | variadic_type) ("=" expression)?
+        let name = node.named_child(0).map(|n| self.text(n)).unwrap_or_default();
+        let ty = node.named_child(1).map(|n| {
+            if n.kind() == "variadic_type" {
+                let inner = n.named_child(0)
+                    .map(|t| self.parse_type(t))
+                    .unwrap_or(Type { name: String::new(), generics: vec![] });
+                ParamType::Variadic(inner)
+            } else {
+                ParamType::Type(self.parse_type(n))
+            }
+        }).unwrap_or(ParamType::Type(Type { name: String::new(), generics: vec![] }));
+        let default = node.named_child(2).map(|n| {
+            let unwrapped = self.unwrap_expr_node(n);
+            self.parse_expression(unwrapped)
+        });
+        Param { name, ty, default }
+    }
+    fn parse_type(&self, node: Node) -> Type {
+        // type: type_identifier ("[" type,* "]")?
+        // named_child(0) = type_identifier
+        let name = node.named_child(0).map(|n| self.text(n)).unwrap_or_else(|| self.text(node));
+        let mut cursor = node.walk();
+        let generics: Vec<Type> = node
+            .named_children(&mut cursor)
+            .skip(1)
+            .filter(|n| n.kind() == "type")
+            .map(|n| self.parse_type(n))
+            .collect();
+        Type { name, generics }
+    }
+    fn parse_return_type(&self, node: Node) -> ReturnType {
+        // return_type: type_identifier generics?
+        // named_child(0) = type_identifier
+        let name = node.named_child(0).map(|n| self.text(n)).unwrap_or_default();
+        let generics = self.parse_generics_field(node);
+        ReturnType { name, generics }
+    }
+    // ---- statements -------------------------------------------------------
+    fn parse_block(&self, node: Node) -> Block {
+        let mut cursor = node.walk();
+        let stmts = node
+            .named_children(&mut cursor)
+            .filter_map(|n| self.parse_stmt(n))
+            .collect();
+        Block { stmts }
+    }
+    fn parse_stmt(&self, node: Node) -> Option<Stmt> {
+        let node = self.unwrap_expr_node(node);
+        Some(match node.kind() {
+            "assign" => Stmt::Assign(self.parse_assign(node)),
+            "break" => Stmt::Break,
+            "continue" => Stmt::Continue,
+            "return" => {
+                let expr = node.named_child(0).map(|n| {
+                    let u = self.unwrap_expr_node(n);
+                    self.parse_expression(u)
+                });
+                Stmt::Return(expr)
+            }
+            "todo" => Stmt::Todo,
+            "assert" => {
+                let expr = node.named_child(0)
+                    .map(|n| { let u = self.unwrap_expr_node(n); self.parse_expression(u) })
+                    .unwrap_or(Expr::Int(0));
+                Stmt::Assert(expr)
+            }
+            "for" => Stmt::For(self.parse_for(node)),
+            "while" => Stmt::While(self.parse_while(node)),
+            "if" => Stmt::If(self.parse_if(node)),
+            "match" => Stmt::Match(self.parse_match(node)),
+            kind if is_expression_kind(kind) => Stmt::Expr(self.parse_expression(node)),
+            _ => return None,
+        })
+    }
+    fn parse_assign(&self, node: Node) -> Assign {
+        // assign: commaSep1(var_identifier) "=" commaSep1(expression)
+        // Named children are all var_identifiers then all expressions.
+        // We split at the first non-var_identifier.
+        let mut cursor = node.walk();
+        let named: Vec<Node> = node.named_children(&mut cursor).collect();
+        let split = named.iter().position(|n| n.kind() != "var_identifier").unwrap_or(named.len());
+        let targets = named[..split].iter().map(|n| self.text(*n)).collect();
+        let values = named[split..]
+            .iter()
+            .map(|n| { let u = self.unwrap_expr_node(*n); self.parse_expression(u) })
+            .collect();
+        Assign { targets, values }
+    }
+    fn parse_for(&self, node: Node) -> For {
+        // for: "for" commaSep1(var_identifier) "in" primary_expression body
+        // Named children: var_identifier+, primary_expression (iter), body
+        let mut cursor = node.walk();
+        let named: Vec<Node> = node.named_children(&mut cursor).collect();
+        let split = named.iter().position(|n| n.kind() != "var_identifier").unwrap_or(0);
+        let vars = named[..split].iter().map(|n| self.text(*n)).collect();
+        let iter = named.get(split)
+            .map(|n| { let u = self.unwrap_expr_node(*n); self.parse_primary_expression(u) })
+            .unwrap_or(Expr::Int(0));
+        let body = named.last()
+            .filter(|n| n.kind() == "body")
+            .map(|n| self.parse_block(*n))
+            .unwrap_or(Block { stmts: vec![] });
+        For { vars, iter, body }
+    }
+    fn parse_while(&self, node: Node) -> While {
+        // while: "while" expression body
+        let mut cursor = node.walk();
+        let named: Vec<Node> = node.named_children(&mut cursor).collect();
+        let condition = named.first()
+            .map(|n| { let u = self.unwrap_expr_node(*n); self.parse_expression(u) })
+            .unwrap_or(Expr::Int(0));
+        let body = named.last()
+            .filter(|n| n.kind() == "body")
+            .map(|n| self.parse_block(*n))
+            .unwrap_or(Block { stmts: vec![] });
+        While { condition, body }
+    }
+    fn parse_if(&self, node: Node) -> If {
+        // if: "if" expression body else_if* else?
+        let mut cursor = node.walk();
+        let named: Vec<Node> = node.named_children(&mut cursor).collect();
+        let condition = named.first()
+            .map(|n| { let u = self.unwrap_expr_node(*n); self.parse_expression(u) })
+            .unwrap_or(Expr::Int(0));
+        let body = named.get(1)
+            .filter(|n| n.kind() == "body")
+            .map(|n| self.parse_block(*n))
+            .unwrap_or(Block { stmts: vec![] });
+        let else_ifs = named.iter()
+            .filter(|n| n.kind() == "else_if")
+            .map(|n| self.parse_else_if(*n))
+            .collect();
+        let else_ = named.iter()
+            .find(|n| n.kind() == "else")
+            .and_then(|n| n.named_child(0))
+            .map(|n| self.parse_block(n));
+        If { condition, body, else_ifs, else_ }
+    }
+    fn parse_else_if(&self, node: Node) -> ElseIf {
+        // else_if: "else if" expression body
+        let mut cursor = node.walk();
+        let named: Vec<Node> = node.named_children(&mut cursor).collect();
+        let condition = named.first()
+            .map(|n| { let u = self.unwrap_expr_node(*n); self.parse_expression(u) })
+            .unwrap_or(Expr::Int(0));
+        let body = named.last()
+            .filter(|n| n.kind() == "body")
+            .map(|n| self.parse_block(*n))
+            .unwrap_or(Block { stmts: vec![] });
+        ElseIf { condition, body }
+    }
+    fn parse_match(&self, node: Node) -> Match {
+        // match: "match" commaSep1(expression) "is" case+
+        let mut cursor = node.walk();
+        let named: Vec<Node> = node.named_children(&mut cursor).collect();
+        let split = named.iter().position(|n| n.kind() == "case").unwrap_or(named.len());
+        let subjects = named[..split]
+            .iter()
+            .map(|n| { let u = self.unwrap_expr_node(*n); self.parse_expression(u) })
+            .collect();
+        let cases = named[split..]
+            .iter()
+            .filter(|n| n.kind() == "case")
+            .map(|n| self.parse_case(*n))
+            .collect();
+        Match { subjects, cases }
+    }
+    fn parse_case(&self, node: Node) -> Case {
+        // case: commaSep1(case_pattern) "=>" body
+        let mut cursor = node.walk();
+        let named: Vec<Node> = node.named_children(&mut cursor).collect();
+        let patterns = named.iter()
+            .filter(|n| n.kind() == "case_pattern")
+            .map(|n| self.parse_case_pattern(*n))
+            .collect();
+        let body = named.iter()
+            .find(|n| n.kind() == "body")
+            .map(|n| self.parse_block(*n))
+            .unwrap_or(Block { stmts: vec![] });
+        Case { patterns, body }
+    }
+    fn parse_case_pattern(&self, node: Node) -> CasePattern {
+        // case_pattern wraps: class_pattern | string | integer | float | dotted_name | "_"
+        let inner = node.named_child(0).unwrap_or(node);
+        match inner.kind() {
+            "class_pattern" => {
+                // class_pattern: dotted_name "(" case_pattern,* ")"
+                let name = inner.named_child(0).map(|n| self.text(n)).unwrap_or_default();
+                let fields = (1..inner.named_child_count())
+                    .filter_map(|i| inner.named_child(i as u32))
+                    .filter(|n| n.kind() == "case_pattern")
+                    .map(|n| self.parse_case_pattern(n))
+                    .collect();
+                CasePattern::Class { name, fields }
+            }
+            "string" => CasePattern::String(self.parse_string_raw(inner)),
+            "integer" => CasePattern::Int(self.parse_integer(inner)),
+            "float" => CasePattern::Float(self.parse_float(inner)),
+            "dotted_name" => CasePattern::Name(self.text(inner)),
+            _ => {
+                let t = self.text(inner);
+                if t == "_" { CasePattern::Wildcard } else { CasePattern::Name(t) }
+            }
+        }
+    }
+    // ---- expressions ------------------------------------------------------
+    pub fn parse_expression(&self, node: Node) -> Expr {
+        let node = self.unwrap_expr_node(node);
+        match node.kind() {
+            "comparison_operator" => self.parse_compare(node),
+            "not_operator" => {
+                let arg = node.named_child(0)
+                    .map(|n| { let u = self.unwrap_expr_node(n); self.parse_expression(u) })
+                    .unwrap_or(Expr::Int(0));
+                Expr::Not(Box::new(arg))
+            }
+            "boolean_operator" => self.parse_bool_op(node),
+            "ternary_expression" => self.parse_ternary(node),
+            _ => self.parse_primary_expression(node),
+        }
+    }
+    pub fn parse_primary_expression(&self, node: Node) -> Expr {
+        let node = self.unwrap_expr_node(node);
+        match node.kind() {
+            "binary_operator" => self.parse_binary(node),
+            "unary_operator" => self.parse_unary(node),
+            "attribute" => self.parse_attribute(node),
+            "fn_call" => Expr::FnCall(self.parse_fn_call(node)),
+            "class_call" => Expr::ClassCall(self.parse_class_call(node)),
+            "parenthesized_expression" => {
+                // parenthesized_expression: "{" expression "}"
+                let inner = node.named_child(0)
+                    .map(|n| { let u = self.unwrap_expr_node(n); self.parse_expression(u) })
+                    .unwrap_or(Expr::Int(0));
+                Expr::Paren(Box::new(inner))
+            }
+            "string" => Expr::String(self.parse_string(node)),
+            "integer" => Expr::Int(self.parse_integer(node)),
+            "float" => Expr::Float(self.parse_float(node)),
+            "self" => Expr::Self_,
+            "var_identifier" => Expr::Var(self.text(node)),
+            "type_identifier" => Expr::TypeName(self.text(node)),
+            _ => Expr::Var(self.text(node)),
+        }
+    }
+    fn parse_binary(&self, node: Node) -> Expr {
+        // binary_operator: primary_expression op primary_expression
+        // "operator" is an unnamed child; left/right are field-named
+        let op_text = self.find_unnamed_operator(node);
+        let op = match op_text.as_str() {
+            "+" => BinOp::Add,
+            "-" => BinOp::Sub,
+            "*" => BinOp::Mul,
+            "/" => BinOp::Div,
+            "%" => BinOp::Mod,
+            "|" => BinOp::BitOr,
+            "&" => BinOp::BitAnd,
+            "^" => BinOp::Xor,
+            "<<" => BinOp::Shl,
+            ">>" => BinOp::Shr,
+            ".." => BinOp::Range,
+            _ => BinOp::Add,
+        };
+        let mut cursor = node.walk();
+        let named: Vec<Node> = node.named_children(&mut cursor).collect();
+        let left = named.first()
+            .map(|n| { let u = self.unwrap_expr_node(*n); self.parse_primary_expression(u) })
+            .unwrap_or(Expr::Int(0));
+        let right = named.last()
+            .map(|n| { let u = self.unwrap_expr_node(*n); self.parse_primary_expression(u) })
+            .unwrap_or(Expr::Int(0));
+        Expr::Binary(Box::new(BinaryExpr { op, left, right }))
+    }
+    fn parse_unary(&self, node: Node) -> Expr {
+        let op_text = self.find_unnamed_operator(node);
+        let op = if op_text == "-" { UnOp::Neg } else { UnOp::Pos };
+        let operand = node.named_child(0)
+            .map(|n| { let u = self.unwrap_expr_node(n); self.parse_primary_expression(u) })
+            .unwrap_or(Expr::Int(0));
+        Expr::Unary(Box::new(UnaryExpr { op, operand }))
+    }
+    fn parse_bool_op(&self, node: Node) -> Expr {
+        let op_text = self.find_unnamed_operator(node);
+        let op = if op_text == "&&" { BoolOp::And } else { BoolOp::Or };
+        let mut cursor = node.walk();
+        let named: Vec<Node> = node.named_children(&mut cursor).collect();
+        let left = named.first()
+            .map(|n| { let u = self.unwrap_expr_node(*n); self.parse_expression(u) })
+            .unwrap_or(Expr::Int(0));
+        let right = named.last()
+            .map(|n| { let u = self.unwrap_expr_node(*n); self.parse_expression(u) })
+            .unwrap_or(Expr::Int(0));
+        Expr::Bool(Box::new(BoolExpr { op, left, right }))
+    }
+    fn parse_compare(&self, node: Node) -> Expr {
+        let op_text = self.find_unnamed_operator(node);
+        let op = match op_text.as_str() {
+            "<" => CmpOp::Lt,
+            "<=" => CmpOp::Lte,
+            "==" => CmpOp::Eq,
+            "!=" => CmpOp::Neq,
+            ">=" => CmpOp::Gte,
+            ">" => CmpOp::Gt,
+            "<>" => CmpOp::NotEq2,
+            _ => CmpOp::Eq,
+        };
+        let mut cursor = node.walk();
+        let named: Vec<Node> = node.named_children(&mut cursor).collect();
+        let left = named.first()
+            .map(|n| { let u = self.unwrap_expr_node(*n); self.parse_primary_expression(u) })
+            .unwrap_or(Expr::Int(0));
+        let right = named.last()
+            .map(|n| { let u = self.unwrap_expr_node(*n); self.parse_primary_expression(u) })
+            .unwrap_or(Expr::Int(0));
+        Expr::Compare(Box::new(CompareExpr { op, left, right }))
+    }
+    fn parse_ternary(&self, node: Node) -> Expr {
+        // ternary_expression: expression "?" expression ":" expression
+        let mut cursor = node.walk();
+        let named: Vec<Node> = node.named_children(&mut cursor).collect();
+        let condition = named.first()
+            .map(|n| { let u = self.unwrap_expr_node(*n); self.parse_expression(u) })
+            .unwrap_or(Expr::Int(0));
+        let then = named.get(1)
+            .map(|n| { let u = self.unwrap_expr_node(*n); self.parse_expression(u) })
+            .unwrap_or(Expr::Int(0));
+        let else_ = named.get(2)
+            .map(|n| { let u = self.unwrap_expr_node(*n); self.parse_expression(u) })
+            .unwrap_or(Expr::Int(0));
+        Expr::Ternary(Box::new(TernaryExpr { condition, then, else_ }))
+    }
+    fn parse_attribute(&self, node: Node) -> Expr {
+        // attribute: primary_expression "." (var_identifier | fn_call)
+        let mut cursor = node.walk();
+        let named: Vec<Node> = node.named_children(&mut cursor).collect();
+        let object = named.first()
+            .map(|n| { let u = self.unwrap_expr_node(*n); self.parse_primary_expression(u) })
+            .unwrap_or(Expr::Int(0));
+        let attr = named.get(1).map(|n| {
+            if n.kind() == "fn_call" {
+                AttrKind::Method(self.parse_fn_call(*n))
+            } else {
+                AttrKind::Field(self.text(*n))
+            }
+        }).unwrap_or(AttrKind::Field(String::new()));
+        Expr::Attribute(Box::new(AttributeExpr { object, attr }))
+    }
+    fn parse_fn_call(&self, node: Node) -> FnCall {
+        // fn_call: fn_identifier fn_argument_list
+        let name = node.named_child(0).map(|n| self.text(n)).unwrap_or_default();
+        let args = node.named_child(1)
+            .map(|args_node| {
+                let mut cursor = args_node.walk();
+                args_node.named_children(&mut cursor)
+                    .map(|n| self.parse_arg(n))
+                    .collect()
+            })
+            .unwrap_or_default();
+        FnCall { name, args }
+    }
+    fn parse_arg(&self, node: Node) -> Arg {
+        match node.kind() {
+            "keyword_argument" => {
+                // keyword_argument: var_identifier "=" expression
+                let name = node.named_child(0).map(|n| self.text(n)).unwrap_or_default();
+                let value = node.named_child(1)
+                    .map(|n| { let u = self.unwrap_expr_node(n); self.parse_expression(u) })
+                    .unwrap_or(Expr::Int(0));
+                Arg::Keyword { name, value }
+            }
+            "pair_argument" => {
+                // pair_argument: string "=>" expression
+                let key = node.named_child(0).map(|n| self.parse_string_raw(n)).unwrap_or_default();
+                let value = node.named_child(1)
+                    .map(|n| { let u = self.unwrap_expr_node(n); self.parse_expression(u) })
+                    .unwrap_or(Expr::Int(0));
+                Arg::Pair { key, value }
+            }
+            _ => {
+                let u = self.unwrap_expr_node(node);
+                Arg::Positional(self.parse_expression(u))
+            }
+        }
+    }
+    fn parse_class_call(&self, node: Node) -> ClassCall {
+        // class_call: type_identifier class_argument_list
+        let type_name = node.named_child(0).map(|n| self.text(n)).unwrap_or_default();
+        let fields = node.named_child(1)
+            .map(|args_node| {
+                // class_argument_list: "(" (var_identifier ":" expression),* ")"
+                // Named children alternate: var_identifier, expression, ...
+                let mut cursor = args_node.walk();
+                let named: Vec<Node> = args_node.named_children(&mut cursor).collect();
+                named.chunks(2).filter_map(|chunk| {
+                    if chunk.len() == 2 {
+                        let name = self.text(chunk[0]);
+                        let u = self.unwrap_expr_node(chunk[1]);
+                        Some(FieldArg { name, value: self.parse_expression(u) })
+                    } else {
+                        None
+                    }
+                }).collect()
+            })
+            .unwrap_or_default();
+        ClassCall { type_name, fields }
+    }
+    // ---- string literals --------------------------------------------------
+    fn parse_string(&self, node: Node) -> StringExpr {
+        let mut cursor = node.walk();
+        let parts = node
+            .named_children(&mut cursor)
+            .filter_map(|n| match n.kind() {
+                "string_content" => Some(StringPart::Text(self.text(n))),
+                "interpolation" => {
+                    n.named_child(0).map(|e| {
+                        let u = self.unwrap_expr_node(e);
+                        StringPart::Interp(self.parse_primary_expression(u))
+                    })
+                }
+                _ => None,
+            })
+            .collect();
+        StringExpr { parts }
+    }
+    fn parse_string_raw(&self, node: Node) -> String {
+        let full = self.text(node);
+        full.trim_matches('"').to_string()
+    }
+    // ---- numeric literals -------------------------------------------------
+    fn parse_integer(&self, node: Node) -> i64 {
+        let s = self.text(node).replace('_', "");
+        if s.starts_with("0x") || s.starts_with("0X") {
+            i64::from_str_radix(&s[2..], 16).unwrap_or(0)
+        } else if s.starts_with("0b") || s.starts_with("0B") {
+            i64::from_str_radix(&s[2..], 2).unwrap_or(0)
+        } else {
+            s.parse().unwrap_or(0)
+        }
+    }
+    fn parse_float(&self, node: Node) -> f64 {
+        let s = self.text(node).trim_end_matches(['f', 'F']).replace('_', "");
+        s.parse().unwrap_or(0.0)
+    }
+    // ---- helpers ----------------------------------------------------------
+    /// Find the text of the first unnamed (punctuation/operator) non-whitespace child.
+    fn find_unnamed_operator(&self, node: Node) -> String {
+        let mut cursor = node.walk();
+        for child in node.children(&mut cursor) {
+            if !child.is_named() {
+                let t = self.text(child);
+                if !t.trim().is_empty() {
+                    return t;
+                }
+            }
+        }
+        String::new()
+    }
+}
+fn is_expression_kind(kind: &str) -> bool {
+    matches!(
+        kind,
+        "binary_operator"
+            | "unary_operator"
+            | "boolean_operator"
+            | "not_operator"
+            | "comparison_operator"
+            | "ternary_expression"
+            | "attribute"
+            | "fn_call"
+            | "class_call"
+            | "parenthesized_expression"
+            | "string"
+            | "integer"
+            | "float"
+            | "self"
+            | "var_identifier"
+            | "type_identifier"
+    )
+}

tooling/tree-sitter-plum/Cargo.toml CHANGED Viewed

@@ -29,4 +29,4 @@ tree-sitter-language = "0.1"
 cc = "1.1.22"
 [dev-dependencies]
-tree-sitter = "0.24.5"
+tree-sitter = "0.26"