Enum Expr

pub enum Expr {
    Missing,
    Path(Path),
    If {
        condition: ExprId,
        then_branch: ExprId,
        else_branch: Option<ExprId>,
    },
    Let {
        pat: PatId,
        expr: ExprId,
    },
    Block {
        id: Option<BlockId>,
        statements: Box<[Statement]>,
        tail: Option<ExprId>,
        label: Option<LabelId>,
    },
    Async {
        id: Option<BlockId>,
        statements: Box<[Statement]>,
        tail: Option<ExprId>,
    },
    Const(ExprId),
    Unsafe {
        id: Option<BlockId>,
        statements: Box<[Statement]>,
        tail: Option<ExprId>,
    },
    Loop {
        body: ExprId,
        label: Option<LabelId>,
    },
    Call {
        callee: ExprId,
        args: Box<[ExprId]>,
    },
    MethodCall {
        receiver: ExprId,
        method_name: Name,
        args: Box<[ExprId]>,
        generic_args: Option<Box<GenericArgs>>,
    },
    Match {
        expr: ExprId,
        arms: Box<[MatchArm]>,
    },
    Continue {
        label: Option<LabelId>,
    },
    Break {
        expr: Option<ExprId>,
        label: Option<LabelId>,
    },
    Return {
        expr: Option<ExprId>,
    },
    Become {
        expr: ExprId,
    },
    Yield {
        expr: Option<ExprId>,
    },
    Yeet {
        expr: Option<ExprId>,
    },
    RecordLit {
        path: Option<Box<Path>>,
        fields: Box<[RecordLitField]>,
        spread: Option<ExprId>,
    },
    Field {
        expr: ExprId,
        name: Name,
    },
    Await {
        expr: ExprId,
    },
    Cast {
        expr: ExprId,
        type_ref: TypeRefId,
    },
    Ref {
        expr: ExprId,
        rawness: Rawness,
        mutability: Mutability,
    },
    Box {
        expr: ExprId,
    },
    UnaryOp {
        expr: ExprId,
        op: UnaryOp,
    },
    BinaryOp {
        lhs: ExprId,
        rhs: ExprId,
        op: Option<BinaryOp>,
    },
    Assignment {
        target: PatId,
        value: ExprId,
    },
    Range {
        lhs: Option<ExprId>,
        rhs: Option<ExprId>,
        range_type: RangeOp,
    },
    Index {
        base: ExprId,
        index: ExprId,
    },
    Closure {
        args: Box<[PatId]>,
        arg_types: Box<[Option<TypeRefId>]>,
        ret_type: Option<TypeRefId>,
        body: ExprId,
        closure_kind: ClosureKind,
        capture_by: CaptureBy,
    },
    Tuple {
        exprs: Box<[ExprId]>,
    },
    Array(Array),
    Literal(Literal),
    Underscore,
    OffsetOf(OffsetOf),
    InlineAsm(InlineAsm),
}

Variants

Missing

This is produced if the syntax tree does not have a required expression piece.

Path(Path)

If

Fields

condition: ExprId

then_branch: ExprId

else_branch: Option<ExprId>

Let

Fields

pat: PatId

expr: ExprId

Block

Fields

id: Option<BlockId>

statements: Box<[Statement]>

tail: Option<ExprId>

label: Option<LabelId>

Async

Fields

id: Option<BlockId>

statements: Box<[Statement]>

tail: Option<ExprId>

Const(ExprId)

Unsafe

Fields

id: Option<BlockId>

statements: Box<[Statement]>

tail: Option<ExprId>

Loop

Fields

body: ExprId

label: Option<LabelId>

Call

Fields

callee: ExprId

args: Box<[ExprId]>

MethodCall

Fields

receiver: ExprId

method_name: Name

args: Box<[ExprId]>

generic_args: Option<Box<GenericArgs>>

Match

Fields

expr: ExprId

arms: Box<[MatchArm]>

Continue

Fields

label: Option<LabelId>

Break

Fields

expr: Option<ExprId>

label: Option<LabelId>

Return

Fields

expr: Option<ExprId>

Become

Fields

expr: ExprId

Yield

Fields

expr: Option<ExprId>

Yeet

Fields

expr: Option<ExprId>

RecordLit

Fields

path: Option<Box<Path>>

fields: Box<[RecordLitField]>

spread: Option<ExprId>

Field

Fields

expr: ExprId

name: Name

Await

Fields

expr: ExprId

Cast

Fields

expr: ExprId

type_ref: TypeRefId

Ref

Fields

expr: ExprId

rawness: Rawness

mutability: Mutability

Box

Fields

expr: ExprId

UnaryOp

Fields

expr: ExprId

op: UnaryOp

BinaryOp

op cannot be bare = (but can be op=), these are lowered to Assignment instead.

Fields

lhs: ExprId

rhs: ExprId

op: Option<BinaryOp>

Assignment

Fields

target: PatId

value: ExprId

Range

Fields

lhs: Option<ExprId>

rhs: Option<ExprId>

range_type: RangeOp

Index

Fields

base: ExprId

index: ExprId

Closure

Fields

args: Box<[PatId]>

arg_types: Box<[Option<TypeRefId>]>

ret_type: Option<TypeRefId>

body: ExprId

closure_kind: ClosureKind

capture_by: CaptureBy

Tuple

Fields

exprs: Box<[ExprId]>

Array(Array)

Literal(Literal)

Underscore

OffsetOf(OffsetOf)

InlineAsm(InlineAsm)

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

Formats the value using the given formatter.

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

impl StructuralPartialEq for Expr