Enum Expression

pub enum Expression {
    Variable(String),
    FieldAccess {
        base: Box<Expression>,
        field: String,
    },
    Index {
        base: Box<Expression>,
        index: Box<Expression>,
    },
    Deref(Box<Expression>),
    AddressOf {
        mutable: bool,
        expr: Box<Expression>,
    },
    NumberLiteral(u64),
    StringLiteral(String),
    Parenthesized(Box<Expression>),
    MethodCall {
        base: Box<Expression>,
        method: String,
        args: Vec<Expression>,
    },
    FunctionCall {
        function: String,
        args: Vec<Expression>,
    },
}

Represents a parsed expression

Variants

Variable(String)

Simple variable reference (e.g., foo)

FieldAccess

Field access (e.g., foo.bar, self.field)

Fields

base: Box<Expression>

field: String

Index

Array/slice indexing (e.g., arr[5], slice[idx])

Fields

base: Box<Expression>

index: Box<Expression>

Deref(Box<Expression>)

Pointer dereferencing (e.g., *ptr, **ptr_ptr)

AddressOf

Address-of operator (e.g., &var, &mut var)

Fields

mutable: bool

expr: Box<Expression>

NumberLiteral(u64)

Literal number (e.g., 42, 0xff)

StringLiteral(String)

String literal (e.g., "hello", "created")

Parenthesized(Box<Expression>)

Parenthesized expression (e.g., (foo))

MethodCall

Method call (e.g., foo.bar(), vec.len())

Fields

base: Box<Expression>

method: String

args: Vec<Expression>

FunctionCall

Function call (e.g., foo(), bar(1, 2))

Fields

function: String

args: Vec<Expression>

Trait Implementations

impl Clone for Expression

fn clone(&self) -> Expression

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Expression

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

Formats the value using the given formatter.

impl Display for Expression

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

Formats the value using the given formatter.

impl PartialEq for Expression

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

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

const 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 Expression