Enum syn::Expr[−][src]

#[non_exhaustive]
pub enum Expr {
Show 40 variants
    Array(ExprArray),
    Assign(ExprAssign),
    AssignOp(ExprAssignOp),
    Async(ExprAsync),
    Await(ExprAwait),
    Binary(ExprBinary),
    Block(ExprBlock),
    Box(ExprBox),
    Break(ExprBreak),
    Call(ExprCall),
    Cast(ExprCast),
    Closure(ExprClosure),
    Continue(ExprContinue),
    Field(ExprField),
    ForLoop(ExprForLoop),
    Group(ExprGroup),
    If(ExprIf),
    Index(ExprIndex),
    Let(ExprLet),
    Lit(ExprLit),
    Loop(ExprLoop),
    Macro(ExprMacro),
    Match(ExprMatch),
    MethodCall(ExprMethodCall),
    Paren(ExprParen),
    Path(ExprPath),
    Range(ExprRange),
    Reference(ExprReference),
    Repeat(ExprRepeat),
    Return(ExprReturn),
    Struct(ExprStruct),
    Try(ExprTry),
    TryBlock(ExprTryBlock),
    Tuple(ExprTuple),
    Type(ExprType),
    Unary(ExprUnary),
    Unsafe(ExprUnsafe),
    Verbatim(TokenStream),
    While(ExprWhile),
    Yield(ExprYield),
}

Expand description

A Rust expression.

This type is available only if Syn is built with the "derive" or "full" feature, but most of the variants are not available unless “full” is enabled.

Syntax tree enums

This type is a syntax tree enum. In Syn this and other syntax tree enums are designed to be traversed using the following rebinding idiom.

let expr: Expr = /* ... */;
match expr {
    Expr::MethodCall(expr) => {
        /* ... */
    }
    Expr::Cast(expr) => {
        /* ... */
    }
    Expr::If(expr) => {
        /* ... */
    }

    /* ... */

We begin with a variable expr of type Expr that has no fields (because it is an enum), and by matching on it and rebinding a variable with the same name expr we effectively imbue our variable with all of the data fields provided by the variant that it turned out to be. So for example above if we ended up in the MethodCall case then we get to use expr.receiver, expr.args etc; if we ended up in the If case we get to use expr.cond, expr.then_branch, expr.else_branch.

This approach avoids repeating the variant names twice on every line.

// Repetitive; recommend not doing this.
match expr {
    Expr::MethodCall(ExprMethodCall { method, args, .. }) => {

In general, the name to which a syntax tree enum variant is bound should be a suitable name for the complete syntax tree enum type.

// Binding is called `base` which is the name I would use if I were
// assigning `*discriminant.base` without an `if let`.
if let Expr::Tuple(base) = *discriminant.base {

A sign that you may not be choosing the right variable names is if you see names getting repeated in your code, like accessing receiver.receiver or pat.pat or cond.cond.

Variants (Non-exhaustive)

This enum is marked as non-exhaustive

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

`Array(ExprArray)`

Tuple Fields

0: ExprArray

A slice literal expression: [a, b, c, d].

`Assign(ExprAssign)`

Tuple Fields

0: ExprAssign

An assignment expression: a = compute().

`AssignOp(ExprAssignOp)`

Tuple Fields

0: ExprAssignOp

A compound assignment expression: counter += 1.

`Async(ExprAsync)`

Tuple Fields

0: ExprAsync

An async block: async { ... }.

`Await(ExprAwait)`

Tuple Fields

0: ExprAwait

An await expression: fut.await.

`Binary(ExprBinary)`

Tuple Fields

0: ExprBinary

A binary operation: a + b, a * b.

`Block(ExprBlock)`

Tuple Fields

0: ExprBlock

A blocked scope: { ... }.

`Box(ExprBox)`

Tuple Fields

0: ExprBox

A box expression: box f.

`Break(ExprBreak)`

Tuple Fields

0: ExprBreak

A break, with an optional label to break and an optional expression.

`Call(ExprCall)`

Tuple Fields

0: ExprCall

A function call expression: invoke(a, b).

`Cast(ExprCast)`

Tuple Fields

0: ExprCast

A cast expression: foo as f64.

`Closure(ExprClosure)`

Tuple Fields

0: ExprClosure

A closure expression: |a, b| a + b.

`Continue(ExprContinue)`

Tuple Fields

0: ExprContinue

A continue, with an optional label.

`Field(ExprField)`

Tuple Fields

0: ExprField

Access of a named struct field (obj.k) or unnamed tuple struct field (obj.0).

`ForLoop(ExprForLoop)`

Tuple Fields

0: ExprForLoop

A for loop: for pat in expr { ... }.

`Group(ExprGroup)`

Tuple Fields

0: ExprGroup

An expression contained within invisible delimiters.

This variant is important for faithfully representing the precedence of expressions and is related to None-delimited spans in a TokenStream.

`If(ExprIf)`

Tuple Fields

0: ExprIf

An if expression with an optional else block: if expr { ... } else { ... }.

The else branch expression may only be an If or Block expression, not any of the other types of expression.

`Index(ExprIndex)`

Tuple Fields

0: ExprIndex

A square bracketed indexing expression: vector[2].

`Let(ExprLet)`

Tuple Fields

0: ExprLet

A let guard: let Some(x) = opt.

`Lit(ExprLit)`

Tuple Fields

0: ExprLit

A literal in place of an expression: 1, "foo".

`Loop(ExprLoop)`

Tuple Fields

0: ExprLoop

Conditionless loop: loop { ... }.

`Macro(ExprMacro)`

Tuple Fields

0: ExprMacro

A macro invocation expression: format!("{}", q).

`Match(ExprMatch)`

Tuple Fields

0: ExprMatch

A match expression: match n { Some(n) => {}, None => {} }.

`MethodCall(ExprMethodCall)`

Tuple Fields

0: ExprMethodCall

A method call expression: x.foo::<T>(a, b).

`Paren(ExprParen)`

Tuple Fields

0: ExprParen

A parenthesized expression: (a + b).

`Path(ExprPath)`

Tuple Fields

0: ExprPath

A path like std::mem::replace possibly containing generic parameters and a qualified self-type.

A plain identifier like x is a path of length 1.

`Range(ExprRange)`

Tuple Fields

0: ExprRange

A range expression: 1..2, 1.., ..2, 1..=2, ..=2.

`Reference(ExprReference)`

Tuple Fields

0: ExprReference

A referencing operation: &a or &mut a.

`Repeat(ExprRepeat)`

Tuple Fields

0: ExprRepeat

An array literal constructed from one repeated element: [0u8; N].

`Return(ExprReturn)`

Tuple Fields

0: ExprReturn

A return, with an optional value to be returned.

`Struct(ExprStruct)`

Tuple Fields

0: ExprStruct

A struct literal expression: Point { x: 1, y: 1 }.

The rest provides the value of the remaining fields as in S { a: 1, b: 1, ..rest }.

`Try(ExprTry)`

Tuple Fields

0: ExprTry

A try-expression: expr?.

`TryBlock(ExprTryBlock)`

Tuple Fields

0: ExprTryBlock

A try block: try { ... }.

`Tuple(ExprTuple)`

Tuple Fields

0: ExprTuple

A tuple expression: (a, b, c, d).

`Type(ExprType)`

Tuple Fields

0: ExprType

A type ascription expression: foo: f64.

`Unary(ExprUnary)`

Tuple Fields

0: ExprUnary

A unary operation: !x, *x.

`Unsafe(ExprUnsafe)`

Tuple Fields

0: ExprUnsafe

An unsafe block: unsafe { ... }.

`Verbatim(TokenStream)`

Tuple Fields

0: TokenStream

Tokens in expression position not interpreted by Syn.

`While(ExprWhile)`

Tuple Fields

0: ExprWhile

A while loop: while expr { ... }.

`Yield(ExprYield)`

Tuple Fields

0: ExprYield

A yield expression: yield expr.