aster/aster-core/src/ast/expr.rs

use crate::ast::stmt::Stmt;

#[derive(Debug, Clone)]
pub enum Expr {
    /// 字面量：number / string / bool / nil
    Literal(Literal),

    /// 变量引用
    Variable(String),

    /// 赋值表达式：a = b
    Assign {
        name: String,
        op: AssignOp,
        value: Box<Expr>,
    },

    /// 属性访问表达式：object.name
    Get {
        object: Box<Expr>,
        name: String,
    },

    /// 属性赋值表达式：object.name = value
    Set {
        object: Box<Expr>,
        name: String,
        op: AssignOp,
        value: Box<Expr>,
    },

    /// 对象字面量：{ key: value, ... }
    ObjectLiteral {
        properties: Vec<(String, Expr)>,
    },

    /// 数组字面量：[ expr, expr, ... ]
    ArrayLiteral {
        elements: Vec<Expr>,
    },

    /// 索引访问：expr[index]
    IndexGet {
        array: Box<Expr>,
        index: Box<Expr>,
    },

    /// 索引赋值：expr[index] = value
    IndexSet {
        array: Box<Expr>,
        index: Box<Expr>,
        op: AssignOp,
        value: Box<Expr>,
    },

    /// 一元运算：!expr / -expr
    Unary {
        op: UnaryOp,
        right: Box<Expr>,
    },

    /// 二元运算：a + b
    Binary {
        left: Box<Expr>,
        op: BinaryOp,
        right: Box<Expr>,
    },

    /// 逻辑运算：&& ||
    Logical {
        left: Box<Expr>,
        op: LogicalOp,
        right: Box<Expr>,
    },

    /// 三元运算：condition ? then_branch : else_branch
    Ternary {
        condition: Box<Expr>,
        then_branch: Box<Expr>,
        else_branch: Box<Expr>,
    },

    /// 函数调用
    Call {
        callee: Box<Expr>,
        arguments: Vec<Expr>,
    },

    /// 匿名函数（为闭包预留）
    Lambda {
        params: Vec<String>,
        body: Vec<Stmt>,
    },
}

#[derive(Debug, Clone)]
pub enum Literal {
    Number(f64),
    String(String),
    Bool(bool),
    Nil,
}

#[derive(Debug, Clone, Copy)]
pub enum UnaryOp {
    Negate, // -
    Not,    // !
}

#[derive(Debug, Clone, Copy)]
pub enum BinaryOp {
    Add,
    Sub,
    Mul,
    Div,
    Mod,

    Greater,
    GreaterEqual,
    Less,
    LessEqual,

    Equal,
    NotEqual,
}

#[derive(Debug, Clone, Copy)]
pub enum LogicalOp {
    And,
    Or,
}

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum AssignOp {
    Equal,      // =
    PlusEqual,  // +=
    MinusEqual, // -=
    StarEqual,  // *=
    SlashEqual, // /=
    PercentEqual, // %=
}