#[non_exhaustive]pub enum Expr {
Show 40 variants
Array(ExprArray),
Assign(ExprAssign),
Async(ExprAsync),
Await(ExprAwait),
Binary(ExprBinary),
Block(ExprBlock),
Break(ExprBreak),
Call(ExprCall),
Cast(ExprCast),
Closure(ExprClosure),
Const(ExprConst),
Continue(ExprContinue),
Field(ExprField),
ForLoop(ExprForLoop),
Group(ExprGroup),
If(ExprIf),
Index(ExprIndex),
Infer(ExprInfer),
Let(ExprLet),
Lit(ExprLit),
Loop(ExprLoop),
Macro(ExprMacro),
Match(ExprMatch),
MethodCall(ExprMethodCall),
Paren(ExprParen),
Path(ExprPath),
Range(ExprRange),
RawAddr(ExprRawAddr),
Reference(ExprReference),
Repeat(ExprRepeat),
Return(ExprReturn),
Struct(ExprStruct),
Try(ExprTry),
TryBlock(ExprTryBlock),
Tuple(ExprTuple),
Unary(ExprUnary),
Unsafe(ExprUnsafe),
Verbatim(TokenStream),
While(ExprWhile),
Yield(ExprYield),
}
full
or derive
only.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
Array(ExprArray)
A slice literal expression: [a, b, c, d]
.
Assign(ExprAssign)
An assignment expression: a = compute()
.
Async(ExprAsync)
An async block: async { ... }
.
Await(ExprAwait)
An await expression: fut.await
.
Binary(ExprBinary)
A binary operation: a + b
, a += b
.
Block(ExprBlock)
A blocked scope: { ... }
.
Break(ExprBreak)
A break
, with an optional label to break and an optional
expression.
Call(ExprCall)
A function call expression: invoke(a, b)
.
Cast(ExprCast)
A cast expression: foo as f64
.
Closure(ExprClosure)
A closure expression: |a, b| a + b
.
Const(ExprConst)
A const block: const { ... }
.
Continue(ExprContinue)
A continue
, with an optional label.
Field(ExprField)
Access of a named struct field (obj.k
) or unnamed tuple struct
field (obj.0
).
ForLoop(ExprForLoop)
A for loop: for pat in expr { ... }
.
Group(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)
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)
A square bracketed indexing expression: vector[2]
.
Infer(ExprInfer)
The inferred value of a const generic argument, denoted _
.
Let(ExprLet)
A let
guard: let Some(x) = opt
.
Lit(ExprLit)
A literal in place of an expression: 1
, "foo"
.
Loop(ExprLoop)
Conditionless loop: loop { ... }
.
Macro(ExprMacro)
A macro invocation expression: format!("{}", q)
.
Match(ExprMatch)
A match
expression: match n { Some(n) => {}, None => {} }
.
MethodCall(ExprMethodCall)
A method call expression: x.foo::<T>(a, b)
.
Paren(ExprParen)
A parenthesized expression: (a + b)
.
Path(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)
A range expression: 1..2
, 1..
, ..2
, 1..=2
, ..=2
.
RawAddr(ExprRawAddr)
Address-of operation: &raw const place
or &raw mut place
.
Reference(ExprReference)
A referencing operation: &a
or &mut a
.
Repeat(ExprRepeat)
An array literal constructed from one repeated element: [0u8; N]
.
Return(ExprReturn)
A return
, with an optional value to be returned.
Struct(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)
A try-expression: expr?
.
TryBlock(ExprTryBlock)
A try block: try { ... }
.
Tuple(ExprTuple)
A tuple expression: (a, b, c, d)
.
Unary(ExprUnary)
A unary operation: !x
, *x
.
Unsafe(ExprUnsafe)
An unsafe block: unsafe { ... }
.
Verbatim(TokenStream)
Tokens in expression position not interpreted by Syn.
While(ExprWhile)
A while loop: while expr { ... }
.
Yield(ExprYield)
A yield expression: yield expr
.
Implementations§
Source§impl Expr
impl Expr
Sourcepub const PLACEHOLDER: Self = _
pub const PLACEHOLDER: Self = _
An unspecified invalid expression.
use quote::ToTokens;
use std::mem;
use syn::{parse_quote, Expr};
fn unparenthesize(e: &mut Expr) {
while let Expr::Paren(paren) = e {
*e = mem::replace(&mut *paren.expr, Expr::PLACEHOLDER);
}
}
fn main() {
let mut e: Expr = parse_quote! { ((1 + 1)) };
unparenthesize(&mut e);
assert_eq!("1 + 1", e.to_token_stream().to_string());
}
Sourcepub fn parse_without_eager_brace(input: ParseStream<'_>) -> Result<Expr>
Available on crate features full
and parsing
only.
pub fn parse_without_eager_brace(input: ParseStream<'_>) -> Result<Expr>
full
and parsing
only.An alternative to the primary Expr::parse
parser (from the Parse
trait) for ambiguous syntactic positions in which a trailing brace
should not be taken as part of the expression.
Rust grammar has an ambiguity where braces sometimes turn a path
expression into a struct initialization and sometimes do not. In the
following code, the expression S {}
is one expression. Presumably
there is an empty struct struct S {}
defined somewhere which it is
instantiating.
let _ = *S {};
// parsed by rustc as: `*(S {})`
We would want to parse the above using Expr::parse
after the =
token.
But in the following, S {}
is not a struct init expression.
if *S {} {}
// parsed by rustc as:
//
// if (*S) {
// /* empty block */
// }
// {
// /* another empty block */
// }
For that reason we would want to parse if-conditions using
Expr::parse_without_eager_brace
after the if
token. Same for similar
syntactic positions such as the condition expr after a while
token or
the expr at the top of a match
.
The Rust grammar’s choices around which way this ambiguity is resolved at various syntactic positions is fairly arbitrary. Really either parse behavior could work in most positions, and language designers just decide each case based on which is more likely to be what the programmer had in mind most of the time.
if return S {} {}
// parsed by rustc as:
//
// if (return (S {})) {
// }
//
// but could equally well have been this other arbitrary choice:
//
// if (return S) {
// }
// {}
Note the grammar ambiguity on trailing braces is distinct from
precedence and is not captured by assigning a precedence level to the
braced struct init expr in relation to other operators. This can be
illustrated by return 0..S {}
vs match 0..S {}
. The former parses as
return (0..(S {}))
implying tighter precedence for struct init than
..
, while the latter parses as match (0..S) {}
implying tighter
precedence for ..
than struct init, a contradiction.
Sourcepub fn parse_with_earlier_boundary_rule(input: ParseStream<'_>) -> Result<Expr>
Available on crate features full
and parsing
only.
pub fn parse_with_earlier_boundary_rule(input: ParseStream<'_>) -> Result<Expr>
full
and parsing
only.An alternative to the primary Expr::parse
parser (from the Parse
trait) for syntactic positions in which expression boundaries are placed
more eagerly than done by the typical expression grammar. This includes
expressions at the head of a statement or in the right-hand side of a
match
arm.
Compare the following cases:
let _ = match result {
() if guard => if cond { f } else { g }
() => false,
};
let _ = || {
if cond { f } else { g }
()
};
let _ = [if cond { f } else { g } ()];
The same sequence of tokens if cond { f } else { g } ()
appears in
expression position 3 times. The first two syntactic positions use eager
placement of expression boundaries, and parse as Expr::If
, with the
adjacent ()
becoming Pat::Tuple
or Expr::Tuple
. In contrast, the
third case uses standard expression boundaries and parses as
Expr::Call
.
As with parse_without_eager_brace
, this ambiguity in the Rust
grammar is independent of precedence.
Sourcepub fn peek(input: ParseStream<'_>) -> bool
Available on crate feature parsing
only.
pub fn peek(input: ParseStream<'_>) -> bool
parsing
only.Returns whether the next token in the parse stream is one that might possibly form the beginning of an expr.
This classification is a load-bearing part of the grammar of some Rust
expressions, notably return
and break
. For example return < …
will
never parse <
as a binary operator regardless of what comes after,
because <
is a legal starting token for an expression and so it’s
required to be continued as a return value, such as return <Struct as Trait>::CONST
. Meanwhile return > …
treats the >
as a binary
operator because it cannot be a starting token for any Rust expression.
Trait Implementations§
Source§impl From<ExprAssign> for Expr
impl From<ExprAssign> for Expr
Source§fn from(e: ExprAssign) -> Expr
fn from(e: ExprAssign) -> Expr
Source§impl From<ExprBinary> for Expr
impl From<ExprBinary> for Expr
Source§fn from(e: ExprBinary) -> Expr
fn from(e: ExprBinary) -> Expr
Source§impl From<ExprClosure> for Expr
impl From<ExprClosure> for Expr
Source§fn from(e: ExprClosure) -> Expr
fn from(e: ExprClosure) -> Expr
Source§impl From<ExprContinue> for Expr
impl From<ExprContinue> for Expr
Source§fn from(e: ExprContinue) -> Expr
fn from(e: ExprContinue) -> Expr
Source§impl From<ExprForLoop> for Expr
impl From<ExprForLoop> for Expr
Source§fn from(e: ExprForLoop) -> Expr
fn from(e: ExprForLoop) -> Expr
Source§impl From<ExprMethodCall> for Expr
impl From<ExprMethodCall> for Expr
Source§fn from(e: ExprMethodCall) -> Expr
fn from(e: ExprMethodCall) -> Expr
Source§impl From<ExprRawAddr> for Expr
impl From<ExprRawAddr> for Expr
Source§fn from(e: ExprRawAddr) -> Expr
fn from(e: ExprRawAddr) -> Expr
Source§impl From<ExprReference> for Expr
impl From<ExprReference> for Expr
Source§fn from(e: ExprReference) -> Expr
fn from(e: ExprReference) -> Expr
Source§impl From<ExprRepeat> for Expr
impl From<ExprRepeat> for Expr
Source§fn from(e: ExprRepeat) -> Expr
fn from(e: ExprRepeat) -> Expr
Source§impl From<ExprReturn> for Expr
impl From<ExprReturn> for Expr
Source§fn from(e: ExprReturn) -> Expr
fn from(e: ExprReturn) -> Expr
Source§impl From<ExprStruct> for Expr
impl From<ExprStruct> for Expr
Source§fn from(e: ExprStruct) -> Expr
fn from(e: ExprStruct) -> Expr
Source§impl From<ExprTryBlock> for Expr
impl From<ExprTryBlock> for Expr
Source§fn from(e: ExprTryBlock) -> Expr
fn from(e: ExprTryBlock) -> Expr
Source§impl From<ExprUnsafe> for Expr
impl From<ExprUnsafe> for Expr
Source§fn from(e: ExprUnsafe) -> Expr
fn from(e: ExprUnsafe) -> Expr
Source§impl Parse for Expr
Available on crate feature parsing
only.
impl Parse for Expr
parsing
only.fn parse(input: ParseStream<'_>) -> Result<Self>
Source§impl ToTokens for Expr
Available on crate feature printing
only.
impl ToTokens for Expr
printing
only.Source§fn to_tokens(&self, tokens: &mut TokenStream)
fn to_tokens(&self, tokens: &mut TokenStream)
Source§fn to_token_stream(&self) -> TokenStream
fn to_token_stream(&self) -> TokenStream
Source§fn into_token_stream(self) -> TokenStreamwhere
Self: Sized,
fn into_token_stream(self) -> TokenStreamwhere
Self: Sized,
impl Eq for Expr
extra-traits
only.Auto Trait Implementations§
impl Freeze for Expr
impl RefUnwindSafe for Expr
impl !Send for Expr
impl !Sync for Expr
impl Unpin for Expr
impl UnwindSafe for Expr
Blanket Implementations§
Source§impl<T> BorrowMut<T> for Twhere
T: ?Sized,
impl<T> BorrowMut<T> for Twhere
T: ?Sized,
Source§fn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
Source§impl<T> CloneToUninit for Twhere
T: Clone,
impl<T> CloneToUninit for Twhere
T: Clone,
Source§impl<T> Spanned for Twhere
T: Spanned + ?Sized,
impl<T> Spanned for Twhere
T: Spanned + ?Sized,
Source§fn span(&self) -> Span
fn span(&self) -> Span
parsing
and printing
only.Span
covering the complete contents of this syntax tree
node, or Span::call_site()
if this node is empty.