sqlexpr-congo-rust 1.0.0

//! Arena allocator for AST nodes. Generated by CongoCC Parser Generator. Do not edit.

use crate::tokens::Token;
use std::fmt;

/// Type-safe index for nodes in the arena
#[derive(Copy, Clone, Debug, PartialEq, Eq, Hash)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct NodeId(pub usize);
impl fmt::Display for NodeId {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(f, "NodeId({})", self.0)
    }
}

/// Type-safe index for tokens in the arena
#[derive(Copy, Clone, Debug, PartialEq, Eq, Hash)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct TokenId(pub usize);

/// Arena that owns all AST nodes and tokens
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct Arena {
    /// All AST nodes
    nodes: Vec<AstNode>,
    /// All tokens
    tokens: Vec<Token>,
}

impl Arena {
    /// Create a new empty arena
    pub fn new() -> Self {
        Arena {
            nodes: Vec::new(),
            tokens: Vec::new(),
        }
    }

    /// Allocate a new node in the arena
    pub fn alloc_node(&mut self, node: AstNode) -> NodeId {
        let id = NodeId(self.nodes.len());
        self.nodes.push(node);
        id
    }

    /// Get a reference to a node
    pub fn get_node(&self, id: NodeId) -> &AstNode {
        &self.nodes[id.0]
    }

    /// Get a mutable reference to a node
    pub fn get_node_mut(&mut self, id: NodeId) -> &mut AstNode {
        &mut self.nodes[id.0]
    }

    /// Allocate a new token in the arena
    pub fn alloc_token(&mut self, token: Token) -> TokenId {
        let id = TokenId(self.tokens.len());
        self.tokens.push(token);
        id
    }

    /// Get a reference to a token
    pub fn get_token(&self, id: TokenId) -> &Token {
        &self.tokens[id.0]
    }

    /// Pretty print the AST starting from the given node
    pub fn pretty_print(&self, root: NodeId, indent: usize, input: &str) -> String {
        let mut result = format!("AST: \"{}\"\n", input);
        self.pretty_print_impl(root, indent + 1, &mut result);
        result
    }

    /// Check if a node is a pass-through (single child, no semantic value)
    fn is_passthrough(&self, node_id: NodeId) -> bool {
        match self.get_node(node_id) {
            AstNode::JmsSelector(n) => n.children.len() == 1,
            AstNode::OrExpression(n) => n.children.len() == 1,
            AstNode::AndExpression(n) => n.children.len() == 1,
            AstNode::EqualityExpression(n) => n.children.len() == 1 && n.operators.is_empty(),
            AstNode::ComparisonExpression(n) => n.children.len() == 1 && n.operators.is_empty(),
            AstNode::AddExpression(n) => n.children.len() == 1 && n.operators.is_empty(),
            AstNode::MultExpr(n) => n.children.len() == 1 && n.operators.is_empty(),
            AstNode::UnaryExpr(n) => n.children.len() == 1 && n.operator.is_none(),
            AstNode::PrimaryExpr(_) => false,
            AstNode::Literal(_) => false,
            AstNode::StringLiteral(n) => n.children.len() == 1,
            AstNode::Variable(n) => n.children.len() == 1,
        }
    }

    /// Get the first child of a node (if any)
    fn first_child(&self, node_id: NodeId) -> Option<NodeId> {
        match self.get_node(node_id) {
            AstNode::JmsSelector(n) => n.children.first().copied(),
            AstNode::OrExpression(n) => n.children.first().copied(),
            AstNode::AndExpression(n) => n.children.first().copied(),
            AstNode::EqualityExpression(n) => n.children.first().copied(),
            AstNode::ComparisonExpression(n) => n.children.first().copied(),
            AstNode::AddExpression(n) => n.children.first().copied(),
            AstNode::MultExpr(n) => n.children.first().copied(),
            AstNode::UnaryExpr(n) => n.children.first().copied(),
            AstNode::PrimaryExpr(n) => n.children.first().copied(),
            AstNode::Literal(n) => n.children.first().copied(),
            AstNode::StringLiteral(n) => n.children.first().copied(),
            AstNode::Variable(n) => n.children.first().copied(),
        }
    }

    fn pretty_print_impl(&self, node_id: NodeId, indent: usize, result: &mut String) {
        // Skip pass-through nodes
        if self.is_passthrough(node_id) {
            if let Some(child) = self.first_child(node_id) {
                self.pretty_print_impl(child, indent, result);
            }
            return;
        }

        let indent_str = "  ".repeat(indent);
        match self.get_node(node_id) {
            AstNode::JmsSelector(node) => {
                if node.children.is_empty() {
                    let value = &self.get_token(node.begin_token).image;
                    result.push_str(&format!("{}JmsSelector(\"{}\")\n", indent_str, value));
                } else {
                    result.push_str(&format!("{}JmsSelector\n", indent_str));
                    for child in &node.children {
                        self.pretty_print_impl(*child, indent + 1, result);
                    }
                }
            }
            AstNode::OrExpression(node) => {
                if node.children.len() > 1 {
                    result.push_str(&format!("{}OrExpression [OR x{}]\n", indent_str, node.children.len() - 1));
                } else {
                    result.push_str(&format!("{}OrExpression\n", indent_str));
                }
                for child in &node.children {
                    self.pretty_print_impl(*child, indent + 1, result);
                }
            }
            AstNode::AndExpression(node) => {
                if node.children.len() > 1 {
                    result.push_str(&format!("{}AndExpression [AND x{}]\n", indent_str, node.children.len() - 1));
                } else {
                    result.push_str(&format!("{}AndExpression\n", indent_str));
                }
                for child in &node.children {
                    self.pretty_print_impl(*child, indent + 1, result);
                }
            }
            AstNode::EqualityExpression(node) => {
                if !node.operators.is_empty() {
                    let ops: Vec<&str> = node.operators.iter()
                        .map(|op| match op {
                            EqualityOp::Equal => "=",
                            EqualityOp::NotEqual => "<>",
                            EqualityOp::IsNull => "IS NULL",
                            EqualityOp::IsNotNull => "IS NOT NULL",
                        })
                        .collect();
                    result.push_str(&format!("{}EqualityExpression [{}]\n", indent_str, ops.join(", ")));
                } else if node.children.is_empty() {
                    let value = &self.get_token(node.begin_token).image;
                    result.push_str(&format!("{}EqualityExpression(\"{}\")\n", indent_str, value));
                } else {
                    result.push_str(&format!("{}EqualityExpression\n", indent_str));
                }
                for child in &node.children {
                    self.pretty_print_impl(*child, indent + 1, result);
                }
            }
            AstNode::ComparisonExpression(node) => {
                if !node.operators.is_empty() {
                    let ops: Vec<&str> = node.operators.iter()
                        .map(|op| match op {
                            ComparisonOp::GreaterThan => ">",
                            ComparisonOp::GreaterThanEqual => ">=",
                            ComparisonOp::LessThan => "<",
                            ComparisonOp::LessThanEqual => "<=",
                            ComparisonOp::Like => "LIKE",
                            ComparisonOp::NotLike => "NOT LIKE",
                            ComparisonOp::LikeEscape => "LIKE ESCAPE",
                            ComparisonOp::NotLikeEscape => "NOT LIKE ESCAPE",
                            ComparisonOp::Between => "BETWEEN",
                            ComparisonOp::NotBetween => "NOT BETWEEN",
                            ComparisonOp::In => "IN",
                            ComparisonOp::NotIn => "NOT IN",
                        })
                        .collect();
                    result.push_str(&format!("{}ComparisonExpression [{}]\n", indent_str, ops.join(", ")));
                } else if node.children.is_empty() {
                    let value = &self.get_token(node.begin_token).image;
                    result.push_str(&format!("{}ComparisonExpression(\"{}\")\n", indent_str, value));
                } else {
                    result.push_str(&format!("{}ComparisonExpression\n", indent_str));
                }
                for child in &node.children {
                    self.pretty_print_impl(*child, indent + 1, result);
                }
            }
            AstNode::AddExpression(node) => {
                if !node.operators.is_empty() {
                    let ops: Vec<&str> = node.operators.iter()
                        .map(|op| match op {
                            AddOp::Plus => "+",
                            AddOp::Minus => "-",
                        })
                        .collect();
                    result.push_str(&format!("{}AddExpression [{}]\n", indent_str, ops.join(", ")));
                } else {
                    result.push_str(&format!("{}AddExpression\n", indent_str));
                }
                for child in &node.children {
                    self.pretty_print_impl(*child, indent + 1, result);
                }
            }
            AstNode::MultExpr(node) => {
                if !node.operators.is_empty() {
                    let ops: Vec<&str> = node.operators.iter()
                        .map(|op| match op {
                            MultExprOp::Star => "*",
                            MultExprOp::Slash => "/",
                            MultExprOp::Percent => "%",
                        })
                        .collect();
                    result.push_str(&format!("{}MultExpr [{}]\n", indent_str, ops.join(", ")));
                } else {
                    result.push_str(&format!("{}MultExpr\n", indent_str));
                }
                for child in &node.children {
                    self.pretty_print_impl(*child, indent + 1, result);
                }
            }
            AstNode::UnaryExpr(node) => {
                if let Some(op) = &node.operator {
                    let op_str = match op {
                        UnaryOp::Plus => "+",
                        UnaryOp::Negate => "-",
                        UnaryOp::Not => "NOT",
                    };
                    result.push_str(&format!("{}UnaryExpr [{}]\n", indent_str, op_str));
                } else if node.children.is_empty() {
                    let value = &self.get_token(node.begin_token).image;
                    result.push_str(&format!("{}UnaryExpr(\"{}\")\n", indent_str, value));
                } else {
                    result.push_str(&format!("{}UnaryExpr\n", indent_str));
                }
                for child in &node.children {
                    self.pretty_print_impl(*child, indent + 1, result);
                }
            }
            AstNode::PrimaryExpr(node) => {
                if node.children.is_empty() {
                    let token = self.get_token(node.begin_token);
                    result.push_str(&format!("{}PrimaryExpr(\"{}\")\n", indent_str, token.image));
                } else {
                    result.push_str(&format!("{}PrimaryExpr\n", indent_str));
                    for child in &node.children {
                        self.pretty_print_impl(*child, indent + 1, result);
                    }
                }
            }
            AstNode::Literal(node) => {
                if node.children.is_empty() {
                    let token = self.get_token(node.begin_token);
                    result.push_str(&format!("{}Literal(\"{}\")\n", indent_str, token.image));
                } else {
                    result.push_str(&format!("{}Literal\n", indent_str));
                    for child in &node.children {
                        self.pretty_print_impl(*child, indent + 1, result);
                    }
                }
            }
            AstNode::StringLiteral(node) => {
                if node.children.is_empty() {
                    let value = &self.get_token(node.begin_token).image;
                    result.push_str(&format!("{}StringLiteral(\"{}\")\n", indent_str, value));
                } else {
                    result.push_str(&format!("{}StringLiteral\n", indent_str));
                    for child in &node.children {
                        self.pretty_print_impl(*child, indent + 1, result);
                    }
                }
            }
            AstNode::Variable(node) => {
                if node.children.is_empty() {
                    let value = &self.get_token(node.begin_token).image;
                    result.push_str(&format!("{}Variable(\"{}\")\n", indent_str, value));
                } else {
                    result.push_str(&format!("{}Variable\n", indent_str));
                    for child in &node.children {
                        self.pretty_print_impl(*child, indent + 1, result);
                    }
                }
            }
        }
    }
}

impl Default for Arena {
    fn default() -> Self {
        Self::new()
    }
}

/// Enum containing all AST node types
#[derive(Debug, Clone)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub enum AstNode {
    /// AST node: JmsSelector
    JmsSelector(JmsSelectorNode),
    /// AST node: orExpression
    OrExpression(OrExpressionNode),
    /// AST node: andExpression
    AndExpression(AndExpressionNode),
    /// AST node: equalityExpression
    EqualityExpression(EqualityExpressionNode),
    /// AST node: comparisonExpression
    ComparisonExpression(ComparisonExpressionNode),
    /// AST node: addExpression
    AddExpression(AddExpressionNode),
    /// AST node: multExpr
    MultExpr(MultExprNode),
    /// AST node: unaryExpr
    UnaryExpr(UnaryExprNode),
    /// AST node: primaryExpr
    PrimaryExpr(PrimaryExprNode),
    /// AST node: literal
    Literal(LiteralNode),
    /// AST node: stringLiteral
    StringLiteral(StringLiteralNode),
    /// AST node: variable
    Variable(VariableNode),
}

/// Operator for addExpression
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub enum AddOp {
    /// +
    Plus,
    /// -
    Minus,
}

/// Operator for multExpr
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub enum MultExprOp {
    /// *
    Star,
    /// /
    Slash,
    /// %
    Percent,
}

/// Operator for equalityExpression
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub enum EqualityOp {
    /// =
    Equal,
    /// <>
    NotEqual,
    /// IS NULL
    IsNull,
    /// IS NOT NULL
    IsNotNull,
}

/// Operator for comparisonExpression
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub enum ComparisonOp {
    /// >
    GreaterThan,
    /// >=
    GreaterThanEqual,
    /// <
    LessThan,
    /// <=
    LessThanEqual,
    /// LIKE
    Like,
    /// NOT LIKE
    NotLike,
    /// LIKE with ESCAPE clause
    LikeEscape,
    /// NOT LIKE with ESCAPE clause
    NotLikeEscape,
    /// BETWEEN
    Between,
    /// NOT BETWEEN
    NotBetween,
    /// IN
    In,
    /// NOT IN
    NotIn,
}

/// Operator for unaryExpr
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub enum UnaryOp {
    /// +
    Plus,
    /// -
    Negate,
    /// NOT
    Not,
}

/// AST node for JmsSelector production
#[derive(Debug, Clone)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct JmsSelectorNode {
    /// Parent node (if any)
    pub parent: Option<NodeId>,
    /// Child nodes
    pub children: Vec<NodeId>,
    /// First token of this node
    pub begin_token: TokenId,
    /// Last token of this node
    pub end_token: TokenId,
}

impl JmsSelectorNode {
    /// Create a new JmsSelector node
    pub fn new(begin_token: TokenId, end_token: TokenId) -> Self {
        JmsSelectorNode {
            parent: None,
            children: Vec::new(),
            begin_token,
            end_token,
        }
    }

}

/// AST node for orExpression production
#[derive(Debug, Clone)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct OrExpressionNode {
    /// Parent node (if any)
    pub parent: Option<NodeId>,
    /// Child nodes
    pub children: Vec<NodeId>,
    /// First token of this node
    pub begin_token: TokenId,
    /// Last token of this node
    pub end_token: TokenId,
}

impl OrExpressionNode {
    /// Create a new orExpression node
    pub fn new(begin_token: TokenId, end_token: TokenId) -> Self {
        OrExpressionNode {
            parent: None,
            children: Vec::new(),
            begin_token,
            end_token,
        }
    }

}

/// AST node for andExpression production
#[derive(Debug, Clone)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct AndExpressionNode {
    /// Parent node (if any)
    pub parent: Option<NodeId>,
    /// Child nodes
    pub children: Vec<NodeId>,
    /// First token of this node
    pub begin_token: TokenId,
    /// Last token of this node
    pub end_token: TokenId,
}

impl AndExpressionNode {
    /// Create a new andExpression node
    pub fn new(begin_token: TokenId, end_token: TokenId) -> Self {
        AndExpressionNode {
            parent: None,
            children: Vec::new(),
            begin_token,
            end_token,
        }
    }

}

/// AST node for equalityExpression production
#[derive(Debug, Clone)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct EqualityExpressionNode {
    /// Parent node (if any)
    pub parent: Option<NodeId>,
    /// Child nodes
    pub children: Vec<NodeId>,
    /// Operators applied in this expression
    pub operators: Vec<EqualityOp>,
    /// First token of this node
    pub begin_token: TokenId,
    /// Last token of this node
    pub end_token: TokenId,
}

impl EqualityExpressionNode {
    /// Create a new equalityExpression node
    pub fn new(begin_token: TokenId, end_token: TokenId) -> Self {
        EqualityExpressionNode {
            parent: None,
            children: Vec::new(),
            operators: Vec::new(),
            begin_token,
            end_token,
        }
    }

}

/// AST node for comparisonExpression production
#[derive(Debug, Clone)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct ComparisonExpressionNode {
    /// Parent node (if any)
    pub parent: Option<NodeId>,
    /// Child nodes
    pub children: Vec<NodeId>,
    /// Operators applied in this expression
    pub operators: Vec<ComparisonOp>,
    /// First token of this node
    pub begin_token: TokenId,
    /// Last token of this node
    pub end_token: TokenId,
}

impl ComparisonExpressionNode {
    /// Create a new comparisonExpression node
    pub fn new(begin_token: TokenId, end_token: TokenId) -> Self {
        ComparisonExpressionNode {
            parent: None,
            children: Vec::new(),
            operators: Vec::new(),
            begin_token,
            end_token,
        }
    }

}

/// AST node for addExpression production
#[derive(Debug, Clone)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct AddExpressionNode {
    /// Parent node (if any)
    pub parent: Option<NodeId>,
    /// Child nodes
    pub children: Vec<NodeId>,
    /// Operators between children: operators[i] is between children[i] and children[i+1]
    pub operators: Vec<AddOp>,
    /// First token of this node
    pub begin_token: TokenId,
    /// Last token of this node
    pub end_token: TokenId,
}

impl AddExpressionNode {
    /// Create a new addExpression node
    pub fn new(begin_token: TokenId, end_token: TokenId) -> Self {
        AddExpressionNode {
            parent: None,
            children: Vec::new(),
            operators: Vec::new(),
            begin_token,
            end_token,
        }
    }

    /// Get the left operand (first child)
    pub fn left<'a>(&self, arena: &'a Arena) -> &'a AstNode {
        arena.get_node(self.children[0])
    }

    /// Get the right operand (second child for binary case)
    pub fn right<'a>(&self, arena: &'a Arena) -> Option<&'a AstNode> {
        self.children.get(1).map(|id| arena.get_node(*id))
    }

    /// Get operator at index (between children[i] and children[i+1])
    pub fn op(&self, index: usize) -> Option<AddOp> {
        self.operators.get(index).copied()
    }

    /// Get first operator (for binary expressions)
    pub fn first_op(&self) -> Option<AddOp> {
        self.operators.first().copied()
    }

    /// Iterator over (operator, operand) pairs after the first operand
    pub fn op_operand_pairs(&self) -> impl Iterator<Item = (AddOp, NodeId)> + '_ {
        self.operators.iter().copied().zip(self.children.iter().skip(1).copied())
    }
}

/// AST node for multExpr production
#[derive(Debug, Clone)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct MultExprNode {
    /// Parent node (if any)
    pub parent: Option<NodeId>,
    /// Child nodes
    pub children: Vec<NodeId>,
    /// Operators between children: operators[i] is between children[i] and children[i+1]
    pub operators: Vec<MultExprOp>,
    /// First token of this node
    pub begin_token: TokenId,
    /// Last token of this node
    pub end_token: TokenId,
}

impl MultExprNode {
    /// Create a new multExpr node
    pub fn new(begin_token: TokenId, end_token: TokenId) -> Self {
        MultExprNode {
            parent: None,
            children: Vec::new(),
            operators: Vec::new(),
            begin_token,
            end_token,
        }
    }

    /// Get the left operand (first child)
    pub fn left<'a>(&self, arena: &'a Arena) -> &'a AstNode {
        arena.get_node(self.children[0])
    }

    /// Get the right operand (second child for binary case)
    pub fn right<'a>(&self, arena: &'a Arena) -> Option<&'a AstNode> {
        self.children.get(1).map(|id| arena.get_node(*id))
    }

    /// Get operator at index (between children[i] and children[i+1])
    pub fn op(&self, index: usize) -> Option<MultExprOp> {
        self.operators.get(index).copied()
    }

    /// Get first operator (for binary expressions)
    pub fn first_op(&self) -> Option<MultExprOp> {
        self.operators.first().copied()
    }

    /// Iterator over (operator, operand) pairs after the first operand
    pub fn op_operand_pairs(&self) -> impl Iterator<Item = (MultExprOp, NodeId)> + '_ {
        self.operators.iter().copied().zip(self.children.iter().skip(1).copied())
    }
}

/// AST node for unaryExpr production
#[derive(Debug, Clone)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct UnaryExprNode {
    /// Parent node (if any)
    pub parent: Option<NodeId>,
    /// Child nodes
    pub children: Vec<NodeId>,
    /// Prefix unary operator (if any)
    pub operator: Option<UnaryOp>,
    /// First token of this node
    pub begin_token: TokenId,
    /// Last token of this node
    pub end_token: TokenId,
}

impl UnaryExprNode {
    /// Create a new unaryExpr node
    pub fn new(begin_token: TokenId, end_token: TokenId) -> Self {
        UnaryExprNode {
            parent: None,
            children: Vec::new(),
            operator: None,
            begin_token,
            end_token,
        }
    }

}

/// AST node for primaryExpr production
#[derive(Debug, Clone)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct PrimaryExprNode {
    /// Parent node (if any)
    pub parent: Option<NodeId>,
    /// Child nodes
    pub children: Vec<NodeId>,
    /// First token of this node
    pub begin_token: TokenId,
    /// Last token of this node
    pub end_token: TokenId,
}

impl PrimaryExprNode {
    /// Create a new primaryExpr node
    pub fn new(begin_token: TokenId, end_token: TokenId) -> Self {
        PrimaryExprNode {
            parent: None,
            children: Vec::new(),
            begin_token,
            end_token,
        }
    }

    /// Get the token image (the actual value as string)
    pub fn value<'a>(&self, arena: &'a Arena) -> &'a str {
        &arena.get_token(self.begin_token).image
    }
}

/// AST node for literal production
#[derive(Debug, Clone)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct LiteralNode {
    /// Parent node (if any)
    pub parent: Option<NodeId>,
    /// Child nodes
    pub children: Vec<NodeId>,
    /// First token of this node
    pub begin_token: TokenId,
    /// Last token of this node
    pub end_token: TokenId,
}

impl LiteralNode {
    /// Create a new literal node
    pub fn new(begin_token: TokenId, end_token: TokenId) -> Self {
        LiteralNode {
            parent: None,
            children: Vec::new(),
            begin_token,
            end_token,
        }
    }

    /// Get the token image (the actual value as string)
    pub fn value<'a>(&self, arena: &'a Arena) -> &'a str {
        &arena.get_token(self.begin_token).image
    }
}

/// AST node for stringLiteral production
#[derive(Debug, Clone)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct StringLiteralNode {
    /// Parent node (if any)
    pub parent: Option<NodeId>,
    /// Child nodes
    pub children: Vec<NodeId>,
    /// First token of this node
    pub begin_token: TokenId,
    /// Last token of this node
    pub end_token: TokenId,
}

impl StringLiteralNode {
    /// Create a new stringLiteral node
    pub fn new(begin_token: TokenId, end_token: TokenId) -> Self {
        StringLiteralNode {
            parent: None,
            children: Vec::new(),
            begin_token,
            end_token,
        }
    }

}

/// AST node for variable production
#[derive(Debug, Clone)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct VariableNode {
    /// Parent node (if any)
    pub parent: Option<NodeId>,
    /// Child nodes
    pub children: Vec<NodeId>,
    /// First token of this node
    pub begin_token: TokenId,
    /// Last token of this node
    pub end_token: TokenId,
}

impl VariableNode {
    /// Create a new variable node
    pub fn new(begin_token: TokenId, end_token: TokenId) -> Self {
        VariableNode {
            parent: None,
            children: Vec::new(),
            begin_token,
            end_token,
        }
    }

}