hakorune/src/ast/nodes.rs

//! Lightweight wrapper structs around ASTNode variants (non-breaking).
//!
//! Purpose: provide a gentle path to work with structured nodes via
//! TryFrom/From without changing the canonical AST enum. This enables
//! gradual refactors in builders by converting once at the boundary and
//! then matching on small, typed wrappers.

use super::{ASTNode, Span};

// ----------------
// Statements
// ----------------

#[derive(Debug, Clone)]
pub struct AssignStmt {
    pub target: Box<ASTNode>,
    pub value: Box<ASTNode>,
    pub span: Span,
}

impl TryFrom<ASTNode> for AssignStmt {
    type Error = ASTNode;
    fn try_from(node: ASTNode) -> Result<Self, Self::Error> {
        match node {
            ASTNode::Assignment { target, value, span } => Ok(AssignStmt { target, value, span }),
            other => Err(other),
        }
    }
}

impl From<AssignStmt> for ASTNode {
    fn from(s: AssignStmt) -> Self {
        ASTNode::Assignment { target: s.target, value: s.value, span: s.span }
    }
}

#[derive(Debug, Clone)]
pub struct ReturnStmt {
    pub value: Option<Box<ASTNode>>,
    pub span: Span,
}

impl TryFrom<ASTNode> for ReturnStmt {
    type Error = ASTNode;
    fn try_from(node: ASTNode) -> Result<Self, Self::Error> {
        match node {
            ASTNode::Return { value, span } => Ok(ReturnStmt { value, span }),
            other => Err(other),
        }
    }
}

impl From<ReturnStmt> for ASTNode {
    fn from(s: ReturnStmt) -> Self {
        ASTNode::Return { value: s.value, span: s.span }
    }
}

#[derive(Debug, Clone)]
pub struct IfStmt {
    pub condition: Box<ASTNode>,
    pub then_body: Vec<ASTNode>,
    pub else_body: Option<Vec<ASTNode>>,
    pub span: Span,
}

impl TryFrom<ASTNode> for IfStmt {
    type Error = ASTNode;
    fn try_from(node: ASTNode) -> Result<Self, Self::Error> {
        match node {
            ASTNode::If { condition, then_body, else_body, span } => Ok(IfStmt { condition, then_body, else_body, span }),
            other => Err(other),
        }
    }
}

impl From<IfStmt> for ASTNode {
    fn from(s: IfStmt) -> Self {
        ASTNode::If { condition: s.condition, then_body: s.then_body, else_body: s.else_body, span: s.span }
    }
}

// ----------------
// Expressions
// ----------------

#[derive(Debug, Clone)]
pub struct BinaryExpr {
    pub operator: super::BinaryOperator,
    pub left: Box<ASTNode>,
    pub right: Box<ASTNode>,
    pub span: Span,
}

impl TryFrom<ASTNode> for BinaryExpr {
    type Error = ASTNode;
    fn try_from(node: ASTNode) -> Result<Self, Self::Error> {
        match node {
            ASTNode::BinaryOp { operator, left, right, span } =>
                Ok(BinaryExpr { operator, left, right, span }),
            other => Err(other),
        }
    }
}

impl From<BinaryExpr> for ASTNode {
    fn from(e: BinaryExpr) -> Self {
        ASTNode::BinaryOp { operator: e.operator, left: e.left, right: e.right, span: e.span }
    }
}

#[derive(Debug, Clone)]
pub struct CallExpr {
    pub name: String,
    pub arguments: Vec<ASTNode>,
    pub span: Span,
}

impl TryFrom<ASTNode> for CallExpr {
    type Error = ASTNode;
    fn try_from(node: ASTNode) -> Result<Self, Self::Error> {
        match node {
            ASTNode::FunctionCall { name, arguments, span } => Ok(CallExpr { name, arguments, span }),
            other => Err(other),
        }
    }
}

impl From<CallExpr> for ASTNode {
    fn from(c: CallExpr) -> Self {
        ASTNode::FunctionCall { name: c.name, arguments: c.arguments, span: c.span }
    }
}

#[derive(Debug, Clone)]
pub struct MethodCallExpr {
    pub object: Box<ASTNode>,
    pub method: String,
    pub arguments: Vec<ASTNode>,
    pub span: Span,
}

impl TryFrom<ASTNode> for MethodCallExpr {
    type Error = ASTNode;
    fn try_from(node: ASTNode) -> Result<Self, Self::Error> {
        match node {
            ASTNode::MethodCall { object, method, arguments, span } =>
                Ok(MethodCallExpr { object, method, arguments, span }),
            other => Err(other),
        }
    }
}

impl From<MethodCallExpr> for ASTNode {
    fn from(m: MethodCallExpr) -> Self {
        ASTNode::MethodCall { object: m.object, method: m.method, arguments: m.arguments, span: m.span }
    }
}

#[derive(Debug, Clone)]
pub struct FieldAccessExpr {
    pub object: Box<ASTNode>,
    pub field: String,
    pub span: Span,
}

impl TryFrom<ASTNode> for FieldAccessExpr {
    type Error = ASTNode;
    fn try_from(node: ASTNode) -> Result<Self, Self::Error> {
        match node {
            ASTNode::FieldAccess { object, field, span } =>
                Ok(FieldAccessExpr { object, field, span }),
            other => Err(other),
        }
    }
}

impl From<FieldAccessExpr> for ASTNode {
    fn from(f: FieldAccessExpr) -> Self {
        ASTNode::FieldAccess { object: f.object, field: f.field, span: f.span }
    }
}