Enum Expr

pub enum Expr {
    Literal(Literal),
    Binary(Binary),
    Unary(Unary),
    Variable(Variable),
    Parenthesized(Parenthesized),
    Call(CallExpr),
    Assign(Assign),
    Vec(VecExpr),
    Access(AccessExpr),
    Spread(Spread),
    Null(Token),
    StructConstructor(StructConstructor),
    ThenElse(ThenElse),
    Object(ObjectExpr),
}

Enum representing an expression in the AST. Expressions include literals, binary operations, unary operations, and more.

Variants

Literal(Literal)

A literal value (e.g., number, string).

Binary(Binary)

A binary operation (e.g., a + b).

Unary(Unary)

A unary operation (e.g., -a).

Variable(Variable)

A variable reference.

Parenthesized(Parenthesized)

A parenthesized expression to override precedence.

Call(CallExpr)

A function call expression.

Assign(Assign)

An assignment expression (e.g., a = b).

Vec(VecExpr)

A vector (list) of expressions.

Access(AccessExpr)

An access expression (e.g., struct.name, arr[0], Person::new).

Spread(Spread)

A spread operator for variadic arguments. (e.g., ...args)

Null(Token)

Null literal.

StructConstructor(StructConstructor)

Struct constructor. (e.g., MyStruct { field: value })

ThenElse(ThenElse)

Then-else expression. (e.g., if condition then value else other)

Object(ObjectExpr)

Object expression.

Implementations

impl Expr

pub fn into_stmt(self) -> Stmt

Converts the expression into a statement.

Returns

A Stmt::Expr variant containing the expression.

pub fn into_variable(self) -> Variable

Converts the expression into a variable.

Panics

Panics if the expression is not a Variable variant.

Returns

The Variable struct contained within the expression.

pub fn new_null(token: Token) -> Expr

Creates a new null literal expression.

pub fn new_field_access(base: Expr, field: Expr, token: Token) -> Expr

Creates a new field access expression.

Arguments

• base - The base expression being accessed.
• field - The name of the field to access.
• token - The token representing the ‘.’ operator.

Returns

A new Expr::Access variant with AccessKind::Field.

pub fn new_spread(token: Token, expr: Expr) -> Expr

Create a new spread expression.

Arguments

• token - The token representing the spread operator.
• expr - The expression to spread.

Returns

A new Expr::Spread variant.

pub fn new_index_access(base: Expr, index: Expr, token: Token) -> Expr

Creates a new index access expression.

Arguments

• base - The base expression being accessed.
• index - The index expression.
• token - The token representing the ‘[’ and ‘]’ operators.

Returns

A new Expr::Access variant with AccessKind::Index.

pub fn new_then_else( condition: Expr, then_expr: Expr, else_expr: Expr, then_token: Token, else_token: Token, ) -> Expr

Creates a new then-else expression.

Arguments

• condition - The condition expression.
• then_expr - The expression to evaluate if the condition is true.
• else_expr - The expression to evaluate if the condition is false.
• then_token - The token representing the then keyword.
• else_token - The token representing the else keyword.

Returns

A new Expr::ThenElse variant.

pub fn new_unary(operator: UnOperator, expr: Expr, token: Token) -> Expr

Creates a new unary expression.

Arguments

• operator - The unary operator.
• expr - The operand expression.
• token - The token representing the unary operation.

Returns

A new Expr::Unary variant.

pub fn new_assign(left: Expr, op: AssignOperator, right: Expr) -> Expr

Creates a new assignment expression.

Arguments

• ident - The token representing the variable identifier.
• token - The token representing the assignment operation.
• value - The expression to assign.

Returns

A new Expr::Assign variant.

pub fn new_binary(left: Expr, operator: BinOperator, right: Expr) -> Expr

Creates a new binary expression.

Arguments

• left - The left operand expression.
• operator - The binary operator.
• right - The right operand expression.

Returns

A new Expr::Binary variant.

pub fn new_integer(token: Token, value: i64) -> Expr

Creates a new integer literal expression.

Arguments

• token - The token representing the integer literal.
• value - The integer value.

Returns

A new Expr::Literal variant with LiteralType::Int.

pub fn new_float(token: Token, value: f64) -> Expr

Creates a new floating-point literal expression.

Arguments

• token - The token representing the float literal.
• value - The floating-point value.

Returns

A new Expr::Literal variant with LiteralType::Float.

pub fn new_bool(token: Token, value: bool) -> Expr

Creates a new boolean literal expression.

Arguments

• token - The token representing the boolean literal.
• value - The boolean value.

Returns

A new Expr::Literal variant with LiteralType::Bool.

pub fn new_variable(ident: Token, name: String) -> Expr

Creates a new variable expression.

Arguments

• ident - The token representing the variable identifier.
• name - The name of the variable.

Returns

A new Expr::Variable variant.

pub fn new_call(callee: String, args: Vec<Expr>, token: Token) -> Expr

Creates a new function call expression.

Arguments

• callee - The name of the function being called.
• args - The list of argument expressions.
• token - The token representing the function call.

Returns

A new Expr::Call variant.

pub fn new_string(token: Token, value: String) -> Expr

Creates a new string literal expression.

Arguments

• token - The token representing the string literal.
• value - The string value.

Returns

A new Expr::Literal variant with LiteralType::String.

pub fn new_char(token: Token, value: char) -> Expr

Creates a new character literal expression.

Arguments

• token - The token representing the character literal.
• value - The character value.

Returns

A new Expr::Literal variant with LiteralType::Char.

pub fn new_parenthesized(expr: Expr) -> Expr

Creates a new parenthesized expression.

Arguments

• expr - The expression to be parenthesized.

Returns

A new Expr::Parenthesized variant.

pub fn new_vec(exprs: Vec<Expr>) -> Expr

Creates a new vector expression.

Arguments

• exprs - The list of expressions in the vector.

Returns

A new Expr::Vec variant.

pub fn new_struct_constructor( name: String, fields: Vec<(String, Expr)>, token: Token, ) -> Expr

Creates a new struct constructor expression.

Arguments

• name - The name of the struct being constructed.
• fields - The field values for the struct.
• token - The token representing the struct constructor.

Returns

A new Expr::StructConstructor variant.

pub fn new_static_method_access(base: Expr, method: Expr, token: Token) -> Expr

Creates a new static method access expression.

Arguments

• base - The base expression being accessed.
• method - The method expression.
• token - The token representing the ‘::’ operator.

Returns

A new Expr::Access variant with AccessKind::StaticMethod.

pub fn new_object( fields: IndexMap<String, Expr>, braces: (Token, Token), ) -> Expr

Creates a new object expression.

Arguments

• fields - The key-value pairs in the object.
• braces - The tokens representing the opening and closing braces.

Returns

A new Expr::Object variant.

Trait Implementations

impl Clone for Expr

fn clone(&self) -> Expr

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Expr

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl From<Expr> for Stmt

fn from(expr: Expr) -> Stmt

Converts an Expr into a Stmt::Expr.

Arguments

• expr - The expression to convert into a statement.

Returns

A Stmt::Expr variant containing the provided expression.

impl GetSpan for Expr

fn span(&self) -> TextSpan

Returns the TextSpan associated with the expression in the source code.

impl PartialEq for Expr

fn eq(&self, other: &Expr) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl StructuralPartialEq for Expr