Enum Expr 

pub enum Expr {
    Int(IntLit),
    Float(FloatLit),
    String(StringLit),
    Char(CharLit),
    Bool(BoolLit),
    Unit(UnitLit),
    Ident(Ident),
    Binary(BinaryExpr),
    Unary(UnaryExpr),
    Paren(ParenExpr),
    Block(BlockExpr),
    If(IfExpr),
    Match(MatchExpr),
    While(WhileExpr),
    For(ForExpr),
    Loop(LoopExpr),
    Call(CallExpr),
    Break(BreakExpr),
    Continue(ContinueExpr),
    Return(ReturnExpr),
    StructLit(StructLitExpr),
    Field(FieldExpr),
    MethodCall(MethodCallExpr),
    IntrinsicCall(IntrinsicCallExpr),
    ArrayLit(ArrayLitExpr),
    Index(IndexExpr),
    Path(PathExpr),
    EnumStructLit(EnumStructLitExpr),
    AssocFnCall(AssocFnCallExpr),
    SelfExpr(SelfExpr),
    Comptime(ComptimeBlockExpr),
    ComptimeUnrollFor(ComptimeUnrollForExpr),
    Checked(CheckedBlockExpr),
    TypeLit(TypeLitExpr),
    Tuple(TupleExpr),
    TupleIndex(TupleIndexExpr),
    Range(RangeExpr),
    AnonFn(AnonFnExpr),
    Error(Span),
}

An expression.

Variants

Int(IntLit)

Integer literal

Float(FloatLit)

Floating-point literal

String(StringLit)

String literal

Char(CharLit)

Character literal — Unicode scalar value (ADR-0071)

Bool(BoolLit)

Boolean literal

Unit(UnitLit)

Unit literal (explicit () or implicit unit for blocks without final expression)

Ident(Ident)

Identifier reference (variable)

Binary(BinaryExpr)

Binary operation (e.g., a + b)

Unary(UnaryExpr)

Unary operation (e.g., -x)

Paren(ParenExpr)

Parenthesized expression (e.g., (a + b))

Block(BlockExpr)

Block with statements and final expression

If(IfExpr)

If expression (e.g., if cond { a } else { b })

Match(MatchExpr)

Match expression (e.g., match x { 1 => a, _ => b })

While(WhileExpr)

While expression (e.g., while cond { body })

For(ForExpr)

For-in expression (e.g., for x in arr { body })

Loop(LoopExpr)

Loop expression - infinite loop (e.g., loop { body })

Call(CallExpr)

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

Break(BreakExpr)

Break statement (exits the innermost loop)

Continue(ContinueExpr)

Continue statement (skips to the next iteration of the innermost loop)

Return(ReturnExpr)

Return statement (returns a value from the current function)

StructLit(StructLitExpr)

Struct literal (e.g., Point { x: 1, y: 2 })

Field(FieldExpr)

Field access (e.g., point.x)

MethodCall(MethodCallExpr)

Method call (e.g., point.distance())

IntrinsicCall(IntrinsicCallExpr)

Intrinsic call (e.g., @dbg(42))

ArrayLit(ArrayLitExpr)

Array literal (e.g., [1, 2, 3])

Index(IndexExpr)

Array indexing (e.g., arr[0])

Path(PathExpr)

Path expression (e.g., Color::Red)

EnumStructLit(EnumStructLitExpr)

Enum struct variant literal (e.g., Shape::Circle { radius: 5 })

AssocFnCall(AssocFnCallExpr)

Associated function call (e.g., Point::origin())

SelfExpr(SelfExpr)

Self expression (e.g., self in method bodies)

Comptime(ComptimeBlockExpr)

Comptime block expression (e.g., comptime { 1 + 2 })

ComptimeUnrollFor(ComptimeUnrollForExpr)

Comptime unroll for expression (e.g., comptime_unroll for field in info.fields { ... })

Checked(CheckedBlockExpr)

Checked block expression (e.g., checked { @ptr_read(p) })

TypeLit(TypeLitExpr)

Type literal expression (e.g., i32 used as a value in generic function calls)

Tuple(TupleExpr)

Tuple literal expression (e.g., (1, true), (42,)) (ADR-0048)

TupleIndex(TupleIndexExpr)

Tuple index expression (e.g., t.0, t.1) (ADR-0048)

Range(RangeExpr)

Range expression for slice subscripts (ADR-0064): .., a.., ..b, a..b, a..b :s. Only legal as the index of an IndexExpr; sema rejects bare ranges in other positions.

AnonFn(AnonFnExpr)

Anonymous function expression (e.g., fn(x: i32) -> i32 { x + 1 }) (ADR-0055)

Error(Span)

Error node for recovered parse errors. Used by error recovery to continue parsing after a syntax error.

Implementations

impl Expr

pub fn span(&self) -> Span

Get the span of this expression.

Trait Implementations

impl Clone for Expr

fn clone(&self) -> Expr

Returns a duplicate 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<'de> Deserialize<'de> for Expr

fn deserialize<__D>( __deserializer: __D, ) -> Result<Expr, <__D as Deserializer<'de>>::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

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 RemapSpurs for Expr

fn remap_spurs(&mut self, table: &[Spur])

impl Serialize for Expr

fn serialize<__S>( &self, __serializer: __S, ) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for Expr

impl StructuralPartialEq for Expr