Enum Expr 

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

Variants

Missing

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

Path(Path)

If

Fields

condition: Idx<Expr>

then_branch: Idx<Expr>

else_branch: Option<Idx<Expr>>

Let

Fields

pat: Idx<Pat>

expr: Idx<Expr>

Block

Fields

id: Option<BlockIdLt<'static>>

statements: Box<[Statement]>

tail: Option<Idx<Expr>>

label: Option<Idx<Label>>

Const(Idx<Expr>)

Unsafe

Fields

id: Option<BlockIdLt<'static>>

statements: Box<[Statement]>

tail: Option<Idx<Expr>>

Loop

Fields

body: Idx<Expr>

label: Option<Idx<Label>>

source: LoopSource

Call

Fields

callee: Idx<Expr>

args: Box<[Idx<Expr>]>

MethodCall

Fields

receiver: Idx<Expr>

method_name: Name

args: Box<[Idx<Expr>]>

generic_args: Option<Box<GenericArgs>>

Match

Fields

expr: Idx<Expr>

arms: Box<[MatchArm]>

Continue

Fields

label: Option<Idx<Label>>

Break

Fields

expr: Option<Idx<Expr>>

label: Option<Idx<Label>>

Return

Fields

expr: Option<Idx<Expr>>

Become

Fields

expr: Idx<Expr>

Yield

Fields

expr: Option<Idx<Expr>>

Yeet

Fields

expr: Option<Idx<Expr>>

RecordLit

Fields

path: Path

fields: ThinVec<RecordLitField>

spread: RecordSpread

Field

Fields

expr: Idx<Expr>

name: Name

Await

Fields

expr: Idx<Expr>

Cast

Fields

expr: Idx<Expr>

type_ref: Idx<TypeRef>

Ref

Fields

expr: Idx<Expr>

rawness: Rawness

mutability: Mutability

Box

Fields

expr: Idx<Expr>

UnaryOp

Fields

expr: Idx<Expr>

op: UnaryOp

BinaryOp

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

Fields

lhs: Idx<Expr>

rhs: Idx<Expr>

op: Option<BinaryOp>

Assignment

Fields

target: Idx<Pat>

value: Idx<Expr>

Range

Fields

lhs: Option<Idx<Expr>>

rhs: Option<Idx<Expr>>

range_type: RangeOp

Index

Fields

base: Idx<Expr>

index: Idx<Expr>

Closure

Fields

args: Box<[Idx<Pat>]>

arg_types: Box<[Option<Idx<TypeRef>>]>

ret_type: Option<Idx<TypeRef>>

body: Idx<Expr>

closure_kind: ClosureKind

capture_by: CaptureBy

Tuple

Fields

exprs: Box<[Idx<Expr>]>

Array(Array)

Literal(Literal)

Underscore

OffsetOf(OffsetOf)

InlineAsm(InlineAsm)

IncludeBytes

Implementations

impl Expr

pub fn precedence(&self) -> ExprPrecedence

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