Enum syntax::ast::ExprKind
[−]
[src]
pub enum ExprKind { Box(P<Expr>), InPlace(P<Expr>, P<Expr>), Array(Vec<P<Expr>>), Call(P<Expr>, Vec<P<Expr>>), MethodCall(PathSegment, Vec<P<Expr>>), Tup(Vec<P<Expr>>), Binary(BinOp, P<Expr>, P<Expr>), Unary(UnOp, P<Expr>), Lit(P<Lit>), Cast(P<Expr>, P<Ty>), Type(P<Expr>, P<Ty>), If(P<Expr>, P<Block>, Option<P<Expr>>), IfLet(Vec<P<Pat>>, P<Expr>, P<Block>, Option<P<Expr>>), While(P<Expr>, P<Block>, Option<Label>), WhileLet(Vec<P<Pat>>, P<Expr>, P<Block>, Option<Label>), ForLoop(P<Pat>, P<Expr>, P<Block>, Option<Label>), Loop(P<Block>, Option<Label>), Match(P<Expr>, Vec<Arm>), Closure(CaptureBy, Movability, P<FnDecl>, P<Expr>, Span), Block(P<Block>), Catch(P<Block>), Assign(P<Expr>, P<Expr>), AssignOp(BinOp, P<Expr>, P<Expr>), Field(P<Expr>, SpannedIdent), TupField(P<Expr>, Spanned<usize>), Index(P<Expr>, P<Expr>), Range(Option<P<Expr>>, Option<P<Expr>>, RangeLimits), Path(Option<QSelf>, Path), AddrOf(Mutability, P<Expr>), Break(Option<Label>, Option<P<Expr>>), Continue(Option<Label>), Ret(Option<P<Expr>>), InlineAsm(P<InlineAsm>), Mac(Mac), Struct(Path, Vec<Field>, Option<P<Expr>>), Repeat(P<Expr>, P<Expr>), Paren(P<Expr>), Try(P<Expr>), Yield(Option<P<Expr>>), }
Variants
Box(P<Expr>)
A box x
expression.
InPlace(P<Expr>, P<Expr>)
First expr is the place; second expr is the value.
Array(Vec<P<Expr>>)
An array ([a, b, c, d]
)
Call(P<Expr>, Vec<P<Expr>>)
A function call
The first field resolves to the function itself, and the second field is the list of arguments. This also represents calling the constructor of tuple-like ADTs such as tuple structs and enum variants.
MethodCall(PathSegment, Vec<P<Expr>>)
A method call (x.foo::<'static, Bar, Baz>(a, b, c, d)
)
The PathSegment
represents the method name and its generic arguments
(within the angle brackets).
The first element of the vector of Expr
s is the expression that evaluates
to the object on which the method is being called on (the receiver),
and the remaining elements are the rest of the arguments.
Thus, x.foo::<Bar, Baz>(a, b, c, d)
is represented as
ExprKind::MethodCall(PathSegment { foo, [Bar, Baz] }, [x, a, b, c, d])
.
Tup(Vec<P<Expr>>)
A tuple ((a, b, c ,d)
)
Binary(BinOp, P<Expr>, P<Expr>)
A binary operation (For example: a + b
, a * b
)
Unary(UnOp, P<Expr>)
A unary operation (For example: !x
, *x
)
Lit(P<Lit>)
A literal (For example: 1
, "foo"
)
Cast(P<Expr>, P<Ty>)
A cast (foo as f64
)
Type(P<Expr>, P<Ty>)
If(P<Expr>, P<Block>, Option<P<Expr>>)
An if
block, with an optional else block
if expr { block } else { expr }
IfLet(Vec<P<Pat>>, P<Expr>, P<Block>, Option<P<Expr>>)
An if let
expression with an optional else block
if let pat = expr { block } else { expr }
This is desugared to a match
expression.
While(P<Expr>, P<Block>, Option<Label>)
A while loop, with an optional label
'label: while expr { block }
WhileLet(Vec<P<Pat>>, P<Expr>, P<Block>, Option<Label>)
A while-let loop, with an optional label
'label: while let pat = expr { block }
This is desugared to a combination of loop
and match
expressions.
ForLoop(P<Pat>, P<Expr>, P<Block>, Option<Label>)
A for loop, with an optional label
'label: for pat in expr { block }
This is desugared to a combination of loop
and match
expressions.
Loop(P<Block>, Option<Label>)
Conditionless loop (can be exited with break, continue, or return)
'label: loop { block }
Match(P<Expr>, Vec<Arm>)
A match
block.
Closure(CaptureBy, Movability, P<FnDecl>, P<Expr>, Span)
A closure (for example, move |a, b, c| a + b + c
)
The final span is the span of the argument block |...|
Block(P<Block>)
A block ({ ... }
)
Catch(P<Block>)
A catch block (catch { ... }
)
Assign(P<Expr>, P<Expr>)
An assignment (a = foo()
)
AssignOp(BinOp, P<Expr>, P<Expr>)
An assignment with an operator
For example, a += 1
.
Field(P<Expr>, SpannedIdent)
Access of a named struct field (obj.foo
)
TupField(P<Expr>, Spanned<usize>)
Access of an unnamed field of a struct or tuple-struct
For example, foo.0
.
Index(P<Expr>, P<Expr>)
An indexing operation (foo[2]
)
Range(Option<P<Expr>>, Option<P<Expr>>, RangeLimits)
A range (1..2
, 1..
, ..2
, 1...2
, 1...
, ...2
)
Path(Option<QSelf>, Path)
Variable reference, possibly containing ::
and/or type
parameters, e.g. foo::bar::
Optionally "qualified",
E.g. <Vec<T> as SomeTrait>::SomeType
.
AddrOf(Mutability, P<Expr>)
A referencing operation (&a
or &mut a
)
Break(Option<Label>, Option<P<Expr>>)
A break
, with an optional label to break, and an optional expression
Continue(Option<Label>)
A continue
, with an optional label
Ret(Option<P<Expr>>)
A return
, with an optional value to be returned
InlineAsm(P<InlineAsm>)
Output of the asm!()
macro
Mac(Mac)
A macro invocation; pre-expansion
Struct(Path, Vec<Field>, Option<P<Expr>>)
A struct literal expression.
For example, Foo {x: 1, y: 2}
, or
Foo {x: 1, .. base}
, where base
is the Option<Expr>
.
Repeat(P<Expr>, P<Expr>)
An array literal constructed from one repeated element.
For example, [1; 5]
. The first expression is the element
to be repeated; the second is the number of times to repeat it.
Paren(P<Expr>)
No-op: used solely so we can pretty-print faithfully
Try(P<Expr>)
expr?
Yield(Option<P<Expr>>)
A yield
, with an optional value to be yielded
Trait Implementations
impl Clone for ExprKind
[src]
fn clone(&self) -> ExprKind
[src]
Returns a copy of the value. Read more
fn clone_from(&mut self, source: &Self)
1.0.0[src]
Performs copy-assignment from source
. Read more
impl PartialEq for ExprKind
[src]
fn eq(&self, __arg_0: &ExprKind) -> bool
[src]
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, __arg_0: &ExprKind) -> bool
[src]
This method tests for !=
.
impl Eq for ExprKind
[src]
impl Encodable for ExprKind
[src]
impl Decodable for ExprKind
[src]
impl Hash for ExprKind
[src]
fn hash<__H: Hasher>(&self, __arg_0: &mut __H)
[src]
Feeds this value into the given [Hasher
]. Read more
fn hash_slice<H>(data: &[Self], state: &mut H) where
H: Hasher,
1.3.0[src]
H: Hasher,
Feeds a slice of this type into the given [Hasher
]. Read more