plum

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 unwrapExprNode<'b>(&self, node: Node<'b>) -> Node<'b> {

        match node.kind() {

            "expression" | "primary_expression" => {

                node.named_child(0).map(|c| self.unwrapExprNode(c)).unwrap_or(node)

            }

            _ => node,

        }

    }

    /// Collect named children of `node` that have the given `kind`.

    fn childrenOfKind(&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 parseSource(&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.parseModule(child)),

                "import" => imports.push(self.parseImport(child)),

                "class" => {

                    let c = self.parseClass(child);

                    let nested = self.collectNestedFns(child, &c.name);

                    items.push(Item::Class(c));

                    items.extend(nested.into_iter().map(Item::Fn));

                }

                "trait" => items.push(Item::Trait(self.parseTrait(child))),

                "enum" => {

                    let e = self.parseEnum(child);

                    let nested = self.collectNestedFns(child, &e.name);

                    items.push(Item::Enum(e));

                    items.extend(nested.into_iter().map(Item::Fn));

                }

                "fn" => items.push(Item::Fn(self.parseFn(child))),

                "const" => items.push(Item::Const(self.parseConst(child))),

                _ => {}

            }

        }

        Source { module, imports, items }

    }

    fn parseModule(&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 parseImport(&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 ---------------------------------------------

    /// Collects any `fn` named children nested directly inside a class/enum body and

    /// parses each as an ordinary top-level `Fn`, with `type_param` forced to `owner`

    /// regardless of whatever the nested `fn` itself parsed (a nested method's receiver

    /// is implicit from its enclosing declaration; if it also carries its own explicit,

    /// redundant `<Receiver>` annotation, that's simply overridden, not treated as a

    /// conflict/error).

    fn collectNestedFns(&self, node: Node, owner: &str) -> Vec<Fn> {

        self.childrenOfKind(node, "fn")

            .into_iter()

            .map(|n| {

                let mut f = self.parseFn(n);

                f.type_param = Some(owner.to_string());

                f

            })

            .collect()

    }

    fn parseClass(&self, node: Node) -> Class {

        // class: "type" type_identifier generics? ("(" type_identifier,* ")")? "=" body

        // Named children in order: type_identifier (name), generics? (declaration), 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();

        // Skip the optional `generics` declaration node before looking for implements.

        let after_generics = if named.get(1).map(|n| n.kind()) == Some("generics") { 2 } else { 1 };

        // implements = type_identifiers that appear before any `field` node

        let implements: Vec<String> = named[after_generics..]

            .iter()

            .take_while(|n| n.kind() == "type_identifier")

            .map(|n| self.text(*n))

            .collect();

        let generics = self.parseGenericsField(node);

        let fields: Vec<Field> = named

            .iter()

            .filter(|n| n.kind() == "field")

            .map(|n| self.parseField(*n))

            .collect();

        Class { name, implements, generics, fields }

    }

    fn parseGenericsField(&self, node: Node) -> Vec<GenericParam> {

        // generics: "[" generic_type,* "]"  where  generic_type: generic (":" sep1(type_identifier, "+"))?

        //

        // `generic_type` is `inline`d in the grammar, so the `generics` node has NO

        // `generic_type` children — its named children are the single-uppercase-letter

        // `generic` nodes, each optionally followed by their bound `type_identifier`

        // nodes, all flattened together. Reconstruct each `GenericParam` by starting a

        // new one at every `generic` node and attaching any following

        // `type_identifier`s as its bounds until the next `generic` node.

        let Some(generics_node) = self.childrenOfKind(node, "generics").into_iter().next() else {

            return Vec::new();

        };

        let mut cursor = generics_node.walk();

        let mut params: Vec<GenericParam> = Vec::new();

        for child in generics_node.named_children(&mut cursor) {

            match child.kind() {

                "generic" => {

                    params.push(GenericParam { name: self.text(child), bounds: Vec::new() });

                }

                "type_identifier" => {

                    if let Some(last) = params.last_mut() {

                        last.bounds.push(self.text(child));

                    }

                }

                _ => {}

            }

        }

        params

    }

    fn parseField(&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.parseType(n))

            .unwrap_or(Type { name: String::new(), generics: vec![] });

        Field { name, ty }

    }

    fn parseTrait(&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.parseGenericsField(node);

        let methods = self.childrenOfKind(node, "field")

            .into_iter()

            .map(|f| self.parseTraitMethod(f))

            .collect();

        Trait { name, generics, methods }

    }

    fn parseTraitMethod(&self, node: Node) -> TraitMethod {

        // trait_field (aliased to field): fn_identifier "(" params ")" ("->" type)?

        let name = node.named_child(0).map(|n| self.text(n)).unwrap_or_default();

        let params = self.collectParamsFrom(node);

        // As with `parseFn`'s `returns` field, the grammar's `returns` field

        // wraps the whole `optional(seq("->", $.type))`, so

        // `child_by_field_name("returns")` resolves to the anonymous "->"

        // token, not the `type` node. Unlike `parseFn`, a trait method has

        // no receiver annotation, so there's at most one `type`-kind named

        // child here, and it's unambiguously the return type when present.

        let returns = node

            .named_children(&mut node.walk())

            .find(|n| n.kind() == "type")

            .map(|n| self.parseType(n));

        TraitMethod { name, params, returns }

    }

    fn parseEnum(&self, node: Node) -> Enum {

        let name = node.named_child(0).map(|n| self.text(n)).unwrap_or_default();

        let params = self.childrenOfKind(node, "enum_param")

            .into_iter()

            .map(|n| self.parseEnumParam(n))

            .collect();

        let variants = self.childrenOfKind(node, "field")

            .into_iter()

            .map(|f| self.parseEnumVariant(f))

            .collect();

        Enum { name, params, variants }

    }

    fn parseEnumParam(&self, node: Node) -> EnumParam {

        // enum_param: 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.parseType(n))

            .unwrap_or(Type { name: String::new(), generics: vec![] });

        EnumParam { name, ty }

    }

    fn parseEnumVariant(&self, node: Node) -> EnumVariant {

        // enum_field (aliased to field): "|" type_identifier

        //   ("[" (type_identifier | generic),* "]")?     -- existing: generic type payload

        //   | ("(" expression,* ")")?                    -- new: discriminant value literals

        // named children after the name: either type_identifier/generic (fields) or

        // expression (values) — the two are disjoint child-kind sets, never mixed.

        let name = node.named_child(0).map(|n| self.text(n)).unwrap_or_default();

        let rest: Vec<Node> = (1..node.named_child_count())

            .filter_map(|i| node.named_child(i as u32))

            .collect();

        let fields: Vec<String> = rest.iter()

            .filter(|n| matches!(n.kind(), "type_identifier" | "generic"))

            .map(|n| self.text(*n))

            .collect();

        let values: Vec<Expr> = rest.iter()

            .filter(|n| n.kind() == "expression")

            .map(|n| { let u = self.unwrapExprNode(*n); self.parseExpression(u) })

            .collect();

        EnumVariant { name, fields, values }

    }

    // ---- functions --------------------------------------------------------

    fn parseFn(&self, node: Node) -> Fn {

        // fn: "fun" fn_identifier "(" param,* ")" ("->" type)? "=" body_or_expr

        // Named children: fn_identifier, param*, type?, body/expr

        //

        // `type_param` (the method's receiver, e.g. `Cat` in a method nested inside

        // `type Cat = ...`) is never set here — a bare `fn` node has no receiver of

        // its own; `parseSource`'s `collectNestedFns` forces it afterward for any

        // `fn` nested inside a `class`/`enum` body. There is no top-level

        // `<Receiver>` annotation syntax to parse.

        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();

        let params: Vec<Param> = named

            .iter()

            .filter(|n| n.kind() == "param")

            .map(|n| self.parseParam(*n))

            .collect();

        // The grammar's `returns` field wraps the whole `optional(seq("->", $.type))`,

        // so `child_by_field_name("returns")` resolves to the anonymous `"->"` token,

        // not the `type` node — find the `type`-kind named child instead.

        let returns = named

            .iter()

            .find(|n| n.kind() == "type")

            .map(|n| self.parseType(*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. Genuinely

        // absent (`extern fun foo(...)` with no `=`) parses as `FnBody::Extern`;

        // whether that's actually valid here is `plum-checker`'s job, not the

        // parser's — it must agree with `is_extern` below.

        let body = named.last().and_then(|last| {

            match last.kind() {

                // Skip non-body trailing nodes

                "fn_identifier" | "type" | "param" | "self" => None,

                "body" => Some(FnBody::Block(self.parseBlock(*last))),

                _ => {

                    let unwrapped = self.unwrapExprNode(*last);

                    Some(FnBody::Expr(self.parseExpression(unwrapped)))

                }

            }

        }).unwrap_or(FnBody::Extern);

        let is_extern = node.child_by_field_name("externKw").is_some();

        Fn { name, type_param: None, is_extern, params, returns, body }

    }

    fn parseConst(&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.unwrapExprNode(n);

                self.parseExpression(unwrapped)

            })

            .unwrap_or(Expr::Int(0));

        Const { name, value }

    }

    // ---- params / return type ---------------------------------------------

    /// Collect `param` named children from any node that has them.

    fn collectParamsFrom(&self, node: Node) -> Vec<Param> {

        self.childrenOfKind(node, "param")

            .into_iter()

            .map(|n| self.parseParam(n))

            .collect()

    }

    fn parseParam(&self, node: Node) -> Param {

        // param: var_identifier ":" (type | variadic_type | fn_value_type) ("=" expression)?

        let name = node.named_child(0).map(|n| self.text(n)).unwrap_or_default();

        let ty = node.named_child(1).map(|n| match n.kind() {

            "variadic_type" => {

                let inner = n.named_child(0)

                    .map(|t| self.parseType(t))

                    .unwrap_or(Type { name: String::new(), generics: vec![] });

                ParamType::Variadic(inner)

            }

            "fn_value_type" => self.parseFnValueType(n),

            _ => ParamType::Type(self.parseType(n)),

        }).unwrap_or(ParamType::Type(Type { name: String::new(), generics: vec![] }));

        let default = node.named_child(2).map(|n| {

            let unwrapped = self.unwrapExprNode(n);

            self.parseExpression(unwrapped)

        });

        Param { name, ty, default }

    }

    fn parseFnValueType(&self, node: Node) -> ParamType {

        // fn_value_type: "fn" "(" field("params", type,*) ")" ("->" field("returns", type))?

        // The "returns" field (if present) is a distinct field from "params", so the

        // two are disambiguated unambiguously by field name, not by counting/position

        // among same-kind "type" children — the same idiom `fn`'s own `returns` field

        // already uses.

        let returns_node = node.child_by_field_name("returns");

        let param_types: Vec<Type> = self.childrenOfKind(node, "type")

            .into_iter()

            .filter(|n| Some(*n) != returns_node)

            .map(|n| self.parseType(n))

            .collect();

        let ret = returns_node.map(|n| Box::new(self.parseType(n)));

        ParamType::Fn(param_types, ret)

    }

    fn parseType(&self, node: Node) -> Type {

        // type: type_identifier ("[" type,* "]")? | generic | "[" "]" element:type

        // A slice type (e.g. `[]Byte`) is flattened to a single reserved name

        // `"[]" + element_name` rather than a real generics list — the checker

        // treats it as a fixed builtin (only `[]Byte` is accepted), not a

        // monomorphized generic, so there's no template to carry args for.

        if let Some(element) = node.child_by_field_name("element") {

            let elem = self.parseType(element);

            return Type { name: format!("[]{}", elem.name), generics: vec![] };

        }

        // 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.parseType(n))

            .collect();

        Type { name, generics }

    }

    // ---- statements -------------------------------------------------------

    fn parseBlock(&self, node: Node) -> Block {

        let mut cursor = node.walk();

        let stmts = node

            .named_children(&mut cursor)

            .filter_map(|n| self.parseStmt(n))

            .collect();

        Block { stmts }

    }

    fn parseStmt(&self, node: Node) -> Option<Stmt> {

        let node = self.unwrapExprNode(node);

        Some(match node.kind() {

            "assign" => Stmt::Assign(self.parseAssign(node)),

            "break" => Stmt::Break,

            "continue" => Stmt::Continue,

            "return" => {

                let expr = node.named_child(0).map(|n| {

                    let u = self.unwrapExprNode(n);

                    self.parseExpression(u)

                });

                Stmt::Return(expr)

            }

            "todo" => Stmt::Todo,

            "assert" => {

                let expr = node.named_child(0)

                    .map(|n| { let u = self.unwrapExprNode(n); self.parseExpression(u) })

                    .unwrap_or(Expr::Int(0));

                Stmt::Assert(expr)

            }

            "for" => Stmt::For(self.parseFor(node)),

            "while" => Stmt::While(self.parseWhile(node)),

            "if" => Stmt::If(self.parseIf(node)),

            "match" => Stmt::Match(self.parseMatch(node)),

            kind if isExpressionKind(kind) => Stmt::Expr(self.parseExpression(node)),

            _ => return None,

        })

    }

    fn parseAssign(&self, node: Node) -> Assign {

        // assign: commaSep1(choice(var_identifier, field_target)) "=" commaSep1(expression)

        // Named children are all targets (var_identifier | field_target) then all

        // expressions. We split at the first child that is neither.

        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" && n.kind() != "field_target")

            .unwrap_or(named.len());

        let targets = named[..split]

            .iter()

            .map(|n| self.parseAssignTarget(*n))

            .collect();

        let values = named[split..]

            .iter()

            .map(|n| { let u = self.unwrapExprNode(*n); self.parseExpression(u) })

            .collect();

        let declare = node.child_by_field_name("op").map(|n| self.text(n) == ":=").unwrap_or(false);

        Assign { targets, values, declare }

    }

    fn parseAssignTarget(&self, node: Node) -> AssignTarget {

        match node.kind() {

            "field_target" => {

                // field_target: object: primary_expression "." member: fn_identifier

                let object_node = node.child_by_field_name("object").expect("field_target has an object");

                let member = node

                    .child_by_field_name("member")

                    .map(|n| self.text(n))

                    .unwrap_or_default();

                let object = self.parsePrimaryExpression(self.unwrapExprNode(object_node));

                AssignTarget::Field(Box::new(object), member)

            }

            _ => AssignTarget::Var(self.text(node)),

        }

    }

    fn parseFor(&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.unwrapExprNode(*n); self.parsePrimaryExpression(u) })

            .unwrap_or(Expr::Int(0));

        let body = named.last()

            .filter(|n| n.kind() == "body")

            .map(|n| self.parseBlock(*n))

            .unwrap_or(Block { stmts: vec![] });

        For { vars, iter, body }

    }

    fn parseWhile(&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.unwrapExprNode(*n); self.parseExpression(u) })

            .unwrap_or(Expr::Int(0));

        let body = named.last()

            .filter(|n| n.kind() == "body")

            .map(|n| self.parseBlock(*n))

            .unwrap_or(Block { stmts: vec![] });

        While { condition, body }

    }

    fn parseIf(&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.unwrapExprNode(*n); self.parseExpression(u) })

            .unwrap_or(Expr::Int(0));

        let body = named.get(1)

            .filter(|n| n.kind() == "body")

            .map(|n| self.parseBlock(*n))

            .unwrap_or(Block { stmts: vec![] });

        let else_ifs = named.iter()

            .filter(|n| n.kind() == "else_if")

            .map(|n| self.parseElseIf(*n))

            .collect();

        let else_ = named.iter()

            .find(|n| n.kind() == "else")

            .and_then(|n| n.named_child(0))

            .map(|n| self.parseBlock(n));

        If { condition, body, else_ifs, else_ }

    }

    fn parseElseIf(&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.unwrapExprNode(*n); self.parseExpression(u) })

            .unwrap_or(Expr::Int(0));

        let body = named.last()

            .filter(|n| n.kind() == "body")

            .map(|n| self.parseBlock(*n))

            .unwrap_or(Block { stmts: vec![] });

        ElseIf { condition, body }

    }

    fn parseMatch(&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.unwrapExprNode(*n); self.parseExpression(u) })

            .collect();

        let cases = named[split..]

            .iter()

            .filter(|n| n.kind() == "case")

            .map(|n| self.parseCase(*n))

            .collect();

        Match { subjects, cases }

    }

    fn parseCase(&self, node: Node) -> Case {

        // case: commaSep1(case_pattern) "=>" (expression | 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.parseCasePattern(*n))

            .collect();

        let body = named.iter()

            .find(|n| n.kind() != "case_pattern")

            .map(|n| {

                if n.kind() == "body" {

                    self.parseBlock(*n)

                } else {

                    let unwrapped = self.unwrapExprNode(*n);

                    Block { stmts: vec![Stmt::Expr(self.parseExpression(unwrapped))] }

                }

            })

            .unwrap_or(Block { stmts: vec![] });

        Case { patterns, body }

    }

    fn parseCasePattern(&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.parseCasePattern(n))

                    .collect();

                CasePattern::Class { name, fields }

            }

            "string" => CasePattern::String(self.parseStringRaw(inner)),

            "integer" => CasePattern::Int(self.parseInteger(inner)),

            "float" => CasePattern::Float(self.parseFloat(inner)),

            "dotted_name" => CasePattern::Name(self.text(inner)),

            _ => {

                let t = self.text(inner);

                if t == "_" { CasePattern::Wildcard } else { CasePattern::Name(t) }

            }

        }

    }

    // ---- expressions ------------------------------------------------------

    pub fn parseExpression(&self, node: Node) -> Expr {

        let node = self.unwrapExprNode(node);

        match node.kind() {

            "comparison_operator" => self.parseCompare(node),

            "not_operator" => {

                let arg = node.named_child(0)

                    .map(|n| { let u = self.unwrapExprNode(n); self.parseExpression(u) })

                    .unwrap_or(Expr::Int(0));

                Expr::Not(Box::new(arg))

            }

            "boolean_operator" => self.parseBoolOp(node),

            "ternary_expression" => self.parseTernary(node),

            "closure" => Expr::Closure(Box::new(self.parseClosure(node))),

            _ => self.parsePrimaryExpression(node),

        }

    }

    fn parseClosure(&self, node: Node) -> Closure {

        // closure: "|" var_identifier,* "|" (expression | body)

        let params: Vec<String> = self.childrenOfKind(node, "var_identifier")

            .into_iter()

            .map(|n| self.text(n))

            .collect();

        // The body is either an indented `body` block or a single inline expression

        // (`|v| v`); normalize the inline form into a one-statement block so codegen and

        // the checker only ever see a `Block`.

        let body = match self.childrenOfKind(node, "body").into_iter().next() {

            Some(block_node) => self.parseBlock(block_node),

            None => match node.child_by_field_name("body") {

                Some(expr_node) => {

                    let unwrapped = self.unwrapExprNode(expr_node);

                    Block { stmts: vec![Stmt::Expr(self.parseExpression(unwrapped))] }

                }

                None => Block { stmts: vec![] },

            },

        };

        Closure { params, body }

    }

    pub fn parsePrimaryExpression(&self, node: Node) -> Expr {

        let node = self.unwrapExprNode(node);

        match node.kind() {

            "binary_operator" => self.parseBinary(node),

            "unary_operator" => self.parseUnary(node),

            "attribute" => self.parseAttribute(node),

            "fn_call" => Expr::FnCall(self.parseFnCall(node)),

            "class_call" => Expr::ClassCall(self.parseClassCall(node)),

            "parenthesized_expression" => {

                // parenthesized_expression: "{" expression "}"

                let inner = node.named_child(0)

                    .map(|n| { let u = self.unwrapExprNode(n); self.parseExpression(u) })

                    .unwrap_or(Expr::Int(0));

                Expr::Paren(Box::new(inner))

            }

            "string" => Expr::String(self.parseString(node)),

            "integer" => Expr::Int(self.parseInteger(node)),

            "float" => Expr::Float(self.parseFloat(node)),

            "self" => Expr::Self_,

            "var_identifier" => Expr::Var(self.text(node)),

            "type_identifier" => Expr::TypeName(self.text(node)),

            // A SCREAMING_CASE const reference (e.g. `MAX_FLOAT_VALUE`) — reuses the

            // `TypeName` path, which already resolves a matching top-level const's

            // real type/value (see plum-checker's `inferExpr` and

            // plum-wasm-codegen's `CURRENT_CONSTS`).

            "const_identifier" => Expr::TypeName(self.text(node)),

            _ => Expr::Var(self.text(node)),

        }

    }

    fn parseBinary(&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.findUnnamedOperator(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::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.unwrapExprNode(*n); self.parsePrimaryExpression(u) })

            .unwrap_or(Expr::Int(0));

        let right = named.last()

            .map(|n| { let u = self.unwrapExprNode(*n); self.parsePrimaryExpression(u) })

            .unwrap_or(Expr::Int(0));

        Expr::Binary(Box::new(BinaryExpr { op, left, right }))

    }

    fn parseUnary(&self, node: Node) -> Expr {

        let op_text = self.findUnnamedOperator(node);

        let op = if op_text == "-" { UnOp::Neg } else { UnOp::Pos };

        let operand = node.named_child(0)

            .map(|n| { let u = self.unwrapExprNode(n); self.parsePrimaryExpression(u) })

            .unwrap_or(Expr::Int(0));

        Expr::Unary(Box::new(UnaryExpr { op, operand }))

    }

    fn parseBoolOp(&self, node: Node) -> Expr {

        let op_text = self.findUnnamedOperator(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.unwrapExprNode(*n); self.parseExpression(u) })

            .unwrap_or(Expr::Int(0));

        let right = named.last()

            .map(|n| { let u = self.unwrapExprNode(*n); self.parseExpression(u) })

            .unwrap_or(Expr::Int(0));

        Expr::Bool(Box::new(BoolExpr { op, left, right }))

    }

    fn parseCompare(&self, node: Node) -> Expr {

        let op_text = self.findUnnamedOperator(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.unwrapExprNode(*n); self.parsePrimaryExpression(u) })

            .unwrap_or(Expr::Int(0));

        let right = named.last()

            .map(|n| { let u = self.unwrapExprNode(*n); self.parsePrimaryExpression(u) })

            .unwrap_or(Expr::Int(0));

        Expr::Compare(Box::new(CompareExpr { op, left, right }))

    }

    fn parseTernary(&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.unwrapExprNode(*n); self.parseExpression(u) })

            .unwrap_or(Expr::Int(0));

        let then = named.get(1)

            .map(|n| { let u = self.unwrapExprNode(*n); self.parseExpression(u) })

            .unwrap_or(Expr::Int(0));

        let else_ = named.get(2)

            .map(|n| { let u = self.unwrapExprNode(*n); self.parseExpression(u) })

            .unwrap_or(Expr::Int(0));

        Expr::Ternary(Box::new(TernaryExpr { condition, then, else_ }))

    }

    fn parseAttribute(&self, node: Node) -> Expr {

        // attribute: primary_expression "." fn_identifier fn_argument_list?

        // The member name is always fn_identifier (a superset of var_identifier); an

        // optional trailing argument list distinguishes a method call from field access.

        let mut cursor = node.walk();

        let named: Vec<Node> = node.named_children(&mut cursor).collect();

        let object = named.first()

            .map(|n| { let u = self.unwrapExprNode(*n); self.parsePrimaryExpression(u) })

            .unwrap_or(Expr::Int(0));

        let member = named.get(1).map(|n| self.text(*n)).unwrap_or_default();

        let attr = match named.get(2) {

            Some(args_node) => {

                let mut acursor = args_node.walk();

                let args = args_node.named_children(&mut acursor)

                    .map(|n| self.parseArg(n))

                    .collect();

                AttrKind::Method(FnCall { name: member, args })

            }

            None => AttrKind::Field(member),

        };

        Expr::Attribute(Box::new(AttributeExpr { object, attr }))

    }

    fn parseFnCall(&self, node: Node) -> FnCall {

        // fn_call: var_identifier fn_argument_list (the callee lexes as var_identifier

        // to avoid an identifier-token tie with all-lowercase, no-underscore names)

        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.parseArg(n))

                    .collect()

            })

            .unwrap_or_default();

        FnCall { name, args }

    }

    fn parseArg(&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.unwrapExprNode(n); self.parseExpression(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.parseStringRaw(n)).unwrap_or_default();

                let value = node.named_child(1)

                    .map(|n| { let u = self.unwrapExprNode(n); self.parseExpression(u) })

                    .unwrap_or(Expr::Int(0));

                Arg::Pair { key, value }

            }

            _ => {

                let u = self.unwrapExprNode(node);

                Arg::Positional(self.parseExpression(u))

            }

        }

    }

    fn parseClassCall(&self, node: Node) -> ClassCall {

        // class_call: type_identifier ("[" type,* "]")? class_argument_list

        let type_name = node.child_by_field_name("type").map(|n| self.text(n)).unwrap_or_default();

        // Filtering by NODE KIND (rather than the "generics" field, which

        // tree-sitter attaches once per repeated element, not as a single

        // group) — mirrors `parseType`'s own handling of a type's nested

        // generics list, and sidesteps the optional bracket entirely: if it

        // wasn't written, there are simply no "type" children to find.

        let generics: Vec<Type> = {

            let mut cursor = node.walk();

            node.named_children(&mut cursor)

                .filter(|n| n.kind() == "type")

                .map(|n| self.parseType(n))

                .collect()

        };

        let fields = node.child_by_field_name("arguments")

            .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.unwrapExprNode(chunk[1]);

                        Some(FieldArg { name, value: self.parseExpression(u) })

                    } else {

                        None

                    }

                }).collect()

            })

            .unwrap_or_default();

        ClassCall { type_name, fields, generics }

    }

    // ---- string literals --------------------------------------------------

    fn parseString(&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(decodeEscapes(&self.text(n)))),

                "interpolation" => {

                    n.named_child(0).map(|e| {

                        let u = self.unwrapExprNode(e);

                        StringPart::Interp(self.parsePrimaryExpression(u))

                    })

                }

                _ => None,

            })

            .collect();

        StringExpr { parts }

    }

    fn parseStringRaw(&self, node: Node) -> String {

        let full = self.text(node);

        full.trim_matches('"').to_string()

    }

    // ---- numeric literals -------------------------------------------------

    fn parseInteger(&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 parseFloat(&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 findUnnamedOperator(&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()

    }

}

/// Decodes a string literal's raw source text (the grammar's `escape_sequence`

/// is matched at the lexer level but never actually interpreted anywhere — the

/// parser just handed back the literal source bytes, backslashes and all)

/// into its real content: `\n`/`\t`/`\\`/`\"`/etc single-char escapes, `\NNN`

/// (1-3 decimal digits), `\xXX`, `\uXXXX`, `\UXXXXXXXX`. An unrecognized escape

/// (including `\N{...}`) is passed through unchanged rather than erroring —

/// this only ever runs on text the grammar already accepted as a valid

/// `escape_sequence`, so "unrecognized" only means "not decoded yet."

fn decodeEscapes(s: &str) -> String {

    let chars: Vec<char> = s.chars().collect();

    let mut out = String::with_capacity(chars.len());

    let mut i = 0;

    while i < chars.len() {

        if chars[i] != '\\' || i + 1 >= chars.len() {

            out.push(chars[i]);

            i += 1;

            continue;

        }

        let next = chars[i + 1];

        match next {

            'n' => { out.push('\n'); i += 2; }

            't' => { out.push('\t'); i += 2; }

            'r' => { out.push('\r'); i += 2; }

            'a' => { out.push('\u{07}'); i += 2; }

            'b' => { out.push('\u{08}'); i += 2; }

            'f' => { out.push('\u{0C}'); i += 2; }

            'v' => { out.push('\u{0B}'); i += 2; }

            '\\' => { out.push('\\'); i += 2; }

            '\'' => { out.push('\''); i += 2; }

            '"' => { out.push('"'); i += 2; }

            '\n' => { i += 2; } // escaped literal newline: line continuation, emits nothing

            'x' => match decodeHexEscape(&chars, i + 2, 2) {

                Some((ch, consumed)) => { out.push(ch); i += 2 + consumed; }

                None => { out.push(chars[i]); i += 1; }

            },

            'u' => match decodeHexEscape(&chars, i + 2, 4) {

                Some((ch, consumed)) => { out.push(ch); i += 2 + consumed; }

                None => { out.push(chars[i]); i += 1; }

            },

            'U' => match decodeHexEscape(&chars, i + 2, 8) {

                Some((ch, consumed)) => { out.push(ch); i += 2 + consumed; }

                None => { out.push(chars[i]); i += 1; }

            },

            d if d.is_ascii_digit() => {

                let mut j = i + 1;

                while j < chars.len() && j < i + 4 && chars[j].is_ascii_digit() {

                    j += 1;

                }

                let digits: String = chars[i + 1..j].iter().collect();

                match digits.parse::<u32>().ok().and_then(char::from_u32) {

                    Some(ch) => { out.push(ch); i = j; }

                    None => { out.push(chars[i]); i += 1; }

                }

            }

            _ => { out.push(chars[i]); i += 1; } // e.g. `\N{...}` — pass through raw

        }

    }

    out

}

/// Decodes exactly `width` hex digits starting at `start` into a `char`, if

/// `start..start+width` are all present and form a valid codepoint. Returns

/// `(decoded_char, width)` on success so the caller advances past all of them.

fn decodeHexEscape(chars: &[char], start: usize, width: usize) -> Option<(char, usize)> {

    if start + width > chars.len() {

        return None;

    }

    let hex: String = chars[start..start + width].iter().collect();

    u32::from_str_radix(&hex, 16).ok().and_then(char::from_u32).map(|ch| (ch, width))

}

fn isExpressionKind(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"

    )

}