[][src]Enum syntax::ast::ExprKind

pub enum ExprKind {
    Box(P<Expr>),
    Array(Vec<P<Expr>>),
    Call(P<Expr>, Vec<P<Expr>>),
    MethodCall(PathSegmentVec<P<Expr>>),
    Tup(Vec<P<Expr>>),
    Binary(BinOpP<Expr>, P<Expr>),
    Unary(UnOpP<Expr>),
    Lit(Lit),
    Cast(P<Expr>, P<Ty>),
    Type(P<Expr>, P<Ty>),
    Let(P<Pat>, P<Expr>),
    If(P<Expr>, P<Block>, Option<P<Expr>>),
    While(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(CaptureByIsAsyncMovabilityP<FnDecl>, P<Expr>, Span),
    Block(P<Block>, Option<Label>),
    Async(CaptureByNodeIdP<Block>),
    Await(P<Expr>),
    TryBlock(P<Block>),
    Assign(P<Expr>, P<Expr>),
    AssignOp(BinOpP<Expr>, P<Expr>),
    Field(P<Expr>, Ident),
    Index(P<Expr>, P<Expr>),
    Range(Option<P<Expr>>, Option<P<Expr>>, RangeLimits),
    Path(Option<QSelf>, Path),
    AddrOf(BorrowKindMutabilityP<Expr>),
    Break(Option<Label>, Option<P<Expr>>),
    Continue(Option<Label>),
    Ret(Option<P<Expr>>),
    InlineAsm(P<InlineAsm>),
    Mac(Mac),
    Struct(PathVec<Field>, Option<P<Expr>>),
    Repeat(P<Expr>, AnonConst),
    Paren(P<Expr>),
    Try(P<Expr>),
    Yield(Option<P<Expr>>),
    Err,
}
⚙️ This is an internal compiler API. (rustc_private)

This crate is being loaded from the sysroot, a permanently unstable location for private compiler dependencies. It is not intended for general use. Prefer using a public version of this crate from crates.io via Cargo.toml.

Variants

Box(P<Expr>)
⚙️ This is an internal compiler API. (rustc_private)

This crate is being loaded from the sysroot, a permanently unstable location for private compiler dependencies. It is not intended for general use. Prefer using a public version of this crate from crates.io via Cargo.toml.

A box x expression.

Array(Vec<P<Expr>>)
⚙️ This is an internal compiler API. (rustc_private)

This crate is being loaded from the sysroot, a permanently unstable location for private compiler dependencies. It is not intended for general use. Prefer using a public version of this crate from crates.io via Cargo.toml.

An array ([a, b, c, d])

Call(P<Expr>, Vec<P<Expr>>)
⚙️ This is an internal compiler API. (rustc_private)

This crate is being loaded from the sysroot, a permanently unstable location for private compiler dependencies. It is not intended for general use. Prefer using a public version of this crate from crates.io via Cargo.toml.

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(PathSegmentVec<P<Expr>>)
⚙️ This is an internal compiler API. (rustc_private)

This crate is being loaded from the sysroot, a permanently unstable location for private compiler dependencies. It is not intended for general use. Prefer using a public version of this crate from crates.io via Cargo.toml.

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 an Expr 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>>)
⚙️ This is an internal compiler API. (rustc_private)

This crate is being loaded from the sysroot, a permanently unstable location for private compiler dependencies. It is not intended for general use. Prefer using a public version of this crate from crates.io via Cargo.toml.

A tuple (e.g., (a, b, c, d)).

Binary(BinOpP<Expr>, P<Expr>)
⚙️ This is an internal compiler API. (rustc_private)

This crate is being loaded from the sysroot, a permanently unstable location for private compiler dependencies. It is not intended for general use. Prefer using a public version of this crate from crates.io via Cargo.toml.

A binary operation (e.g., a + b, a * b).

Unary(UnOpP<Expr>)
⚙️ This is an internal compiler API. (rustc_private)

This crate is being loaded from the sysroot, a permanently unstable location for private compiler dependencies. It is not intended for general use. Prefer using a public version of this crate from crates.io via Cargo.toml.

A unary operation (e.g., !x, *x).

Lit(Lit)
⚙️ This is an internal compiler API. (rustc_private)

This crate is being loaded from the sysroot, a permanently unstable location for private compiler dependencies. It is not intended for general use. Prefer using a public version of this crate from crates.io via Cargo.toml.

A literal (e.g., 1, "foo").

Cast(P<Expr>, P<Ty>)
⚙️ This is an internal compiler API. (rustc_private)

This crate is being loaded from the sysroot, a permanently unstable location for private compiler dependencies. It is not intended for general use. Prefer using a public version of this crate from crates.io via Cargo.toml.

A cast (e.g., foo as f64).

Type(P<Expr>, P<Ty>)
⚙️ This is an internal compiler API. (rustc_private)

This crate is being loaded from the sysroot, a permanently unstable location for private compiler dependencies. It is not intended for general use. Prefer using a public version of this crate from crates.io via Cargo.toml.

A type ascription (e.g., 42: usize).

Let(P<Pat>, P<Expr>)
⚙️ This is an internal compiler API. (rustc_private)

This crate is being loaded from the sysroot, a permanently unstable location for private compiler dependencies. It is not intended for general use. Prefer using a public version of this crate from crates.io via Cargo.toml.

A let pat = expr expression that is only semantically allowed in the condition of if / while expressions. (e.g., if let 0 = x { .. }).

If(P<Expr>, P<Block>, Option<P<Expr>>)
⚙️ This is an internal compiler API. (rustc_private)

This crate is being loaded from the sysroot, a permanently unstable location for private compiler dependencies. It is not intended for general use. Prefer using a public version of this crate from crates.io via Cargo.toml.

An if block, with an optional else block.

if expr { block } else { expr }

While(P<Expr>, P<Block>, Option<Label>)
⚙️ This is an internal compiler API. (rustc_private)

This crate is being loaded from the sysroot, a permanently unstable location for private compiler dependencies. It is not intended for general use. Prefer using a public version of this crate from crates.io via Cargo.toml.

A while loop, with an optional label.

'label: while expr { block }

ForLoop(P<Pat>, P<Expr>, P<Block>, Option<Label>)
⚙️ This is an internal compiler API. (rustc_private)

This crate is being loaded from the sysroot, a permanently unstable location for private compiler dependencies. It is not intended for general use. Prefer using a public version of this crate from crates.io via Cargo.toml.

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>)
⚙️ This is an internal compiler API. (rustc_private)

This crate is being loaded from the sysroot, a permanently unstable location for private compiler dependencies. It is not intended for general use. Prefer using a public version of this crate from crates.io via Cargo.toml.

Conditionless loop (can be exited with break, continue, or return).

'label: loop { block }

Match(P<Expr>, Vec<Arm>)
⚙️ This is an internal compiler API. (rustc_private)

This crate is being loaded from the sysroot, a permanently unstable location for private compiler dependencies. It is not intended for general use. Prefer using a public version of this crate from crates.io via Cargo.toml.

A match block.

Closure(CaptureByIsAsyncMovabilityP<FnDecl>, P<Expr>, Span)
⚙️ This is an internal compiler API. (rustc_private)

This crate is being loaded from the sysroot, a permanently unstable location for private compiler dependencies. It is not intended for general use. Prefer using a public version of this crate from crates.io via Cargo.toml.

A closure (e.g., move |a, b, c| a + b + c).

The final span is the span of the argument block |...|.

Block(P<Block>, Option<Label>)
⚙️ This is an internal compiler API. (rustc_private)

This crate is being loaded from the sysroot, a permanently unstable location for private compiler dependencies. It is not intended for general use. Prefer using a public version of this crate from crates.io via Cargo.toml.

A block ('label: { ... }).

Async(CaptureByNodeIdP<Block>)
⚙️ This is an internal compiler API. (rustc_private)

This crate is being loaded from the sysroot, a permanently unstable location for private compiler dependencies. It is not intended for general use. Prefer using a public version of this crate from crates.io via Cargo.toml.

An async block (async move { ... }).

The NodeId is the NodeId for the closure that results from desugaring an async block, just like the NodeId field in the IsAsync enum. This is necessary in order to create a def for the closure which can be used as a parent of any child defs. Defs created during lowering cannot be made the parent of any other preexisting defs.

Await(P<Expr>)
⚙️ This is an internal compiler API. (rustc_private)

This crate is being loaded from the sysroot, a permanently unstable location for private compiler dependencies. It is not intended for general use. Prefer using a public version of this crate from crates.io via Cargo.toml.

An await expression (my_future.await).

TryBlock(P<Block>)
⚙️ This is an internal compiler API. (rustc_private)

This crate is being loaded from the sysroot, a permanently unstable location for private compiler dependencies. It is not intended for general use. Prefer using a public version of this crate from crates.io via Cargo.toml.

A try block (try { ... }).

Assign(P<Expr>, P<Expr>)
⚙️ This is an internal compiler API. (rustc_private)

This crate is being loaded from the sysroot, a permanently unstable location for private compiler dependencies. It is not intended for general use. Prefer using a public version of this crate from crates.io via Cargo.toml.

An assignment (a = foo()).

AssignOp(BinOpP<Expr>, P<Expr>)
⚙️ This is an internal compiler API. (rustc_private)

This crate is being loaded from the sysroot, a permanently unstable location for private compiler dependencies. It is not intended for general use. Prefer using a public version of this crate from crates.io via Cargo.toml.

An assignment with an operator.

E.g., a += 1.

Field(P<Expr>, Ident)
⚙️ This is an internal compiler API. (rustc_private)

This crate is being loaded from the sysroot, a permanently unstable location for private compiler dependencies. It is not intended for general use. Prefer using a public version of this crate from crates.io via Cargo.toml.

Access of a named (e.g., obj.foo) or unnamed (e.g., obj.0) struct field.

Index(P<Expr>, P<Expr>)
⚙️ This is an internal compiler API. (rustc_private)

This crate is being loaded from the sysroot, a permanently unstable location for private compiler dependencies. It is not intended for general use. Prefer using a public version of this crate from crates.io via Cargo.toml.

An indexing operation (e.g., foo[2]).

Range(Option<P<Expr>>, Option<P<Expr>>, RangeLimits)
⚙️ This is an internal compiler API. (rustc_private)

This crate is being loaded from the sysroot, a permanently unstable location for private compiler dependencies. It is not intended for general use. Prefer using a public version of this crate from crates.io via Cargo.toml.

A range (e.g., 1..2, 1.., ..2, 1..=2, ..=2).

Path(Option<QSelf>, Path)
⚙️ This is an internal compiler API. (rustc_private)

This crate is being loaded from the sysroot, a permanently unstable location for private compiler dependencies. It is not intended for general use. Prefer using a public version of this crate from crates.io via Cargo.toml.

Variable reference, possibly containing :: and/or type parameters (e.g., foo::bar::<baz>).

Optionally "qualified" (e.g., <Vec<T> as SomeTrait>::SomeType).

AddrOf(BorrowKindMutabilityP<Expr>)
⚙️ This is an internal compiler API. (rustc_private)

This crate is being loaded from the sysroot, a permanently unstable location for private compiler dependencies. It is not intended for general use. Prefer using a public version of this crate from crates.io via Cargo.toml.

A referencing operation (&a, &mut a, &raw const a or &raw mut a).

Break(Option<Label>, Option<P<Expr>>)
⚙️ This is an internal compiler API. (rustc_private)

This crate is being loaded from the sysroot, a permanently unstable location for private compiler dependencies. It is not intended for general use. Prefer using a public version of this crate from crates.io via Cargo.toml.

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

Continue(Option<Label>)
⚙️ This is an internal compiler API. (rustc_private)

This crate is being loaded from the sysroot, a permanently unstable location for private compiler dependencies. It is not intended for general use. Prefer using a public version of this crate from crates.io via Cargo.toml.

A continue, with an optional label.

Ret(Option<P<Expr>>)
⚙️ This is an internal compiler API. (rustc_private)

This crate is being loaded from the sysroot, a permanently unstable location for private compiler dependencies. It is not intended for general use. Prefer using a public version of this crate from crates.io via Cargo.toml.

A return, with an optional value to be returned.

InlineAsm(P<InlineAsm>)
⚙️ This is an internal compiler API. (rustc_private)

This crate is being loaded from the sysroot, a permanently unstable location for private compiler dependencies. It is not intended for general use. Prefer using a public version of this crate from crates.io via Cargo.toml.

Output of the asm!() macro.

Mac(Mac)
⚙️ This is an internal compiler API. (rustc_private)

This crate is being loaded from the sysroot, a permanently unstable location for private compiler dependencies. It is not intended for general use. Prefer using a public version of this crate from crates.io via Cargo.toml.

A macro invocation; pre-expansion.

Struct(PathVec<Field>, Option<P<Expr>>)
⚙️ This is an internal compiler API. (rustc_private)

This crate is being loaded from the sysroot, a permanently unstable location for private compiler dependencies. It is not intended for general use. Prefer using a public version of this crate from crates.io via Cargo.toml.

A struct literal expression.

E.g., Foo {x: 1, y: 2}, or Foo {x: 1, .. base}, where base is the Option<Expr>.

Repeat(P<Expr>, AnonConst)
⚙️ This is an internal compiler API. (rustc_private)

This crate is being loaded from the sysroot, a permanently unstable location for private compiler dependencies. It is not intended for general use. Prefer using a public version of this crate from crates.io via Cargo.toml.

An array literal constructed from one repeated element.

E.g., [1; 5]. The expression is the element to be repeated; the constant is the number of times to repeat it.

Paren(P<Expr>)
⚙️ This is an internal compiler API. (rustc_private)

This crate is being loaded from the sysroot, a permanently unstable location for private compiler dependencies. It is not intended for general use. Prefer using a public version of this crate from crates.io via Cargo.toml.

No-op: used solely so we can pretty-print faithfully.

Try(P<Expr>)
⚙️ This is an internal compiler API. (rustc_private)

This crate is being loaded from the sysroot, a permanently unstable location for private compiler dependencies. It is not intended for general use. Prefer using a public version of this crate from crates.io via Cargo.toml.

A try expression (expr?).

Yield(Option<P<Expr>>)
⚙️ This is an internal compiler API. (rustc_private)

This crate is being loaded from the sysroot, a permanently unstable location for private compiler dependencies. It is not intended for general use. Prefer using a public version of this crate from crates.io via Cargo.toml.

A yield, with an optional value to be yielded.

Err
⚙️ This is an internal compiler API. (rustc_private)

This crate is being loaded from the sysroot, a permanently unstable location for private compiler dependencies. It is not intended for general use. Prefer using a public version of this crate from crates.io via Cargo.toml.

Placeholder for an expression that wasn't syntactically well formed in some way.

Trait Implementations

impl Clone for ExprKind[src]

impl Debug for ExprKind[src]

impl Encodable for ExprKind[src]

impl Decodable for ExprKind[src]

Auto Trait Implementations

impl !Send for ExprKind

impl !Sync for ExprKind

impl Unpin for ExprKind

impl !UnwindSafe for ExprKind

impl !RefUnwindSafe for ExprKind

Blanket Implementations

impl<T> From<T> for T[src]

impl<T, U> Into<U> for T where
    U: From<T>, 
[src]

impl<T> ToOwned for T where
    T: Clone
[src]

type Owned = T

The resulting type after obtaining ownership.

impl<T, U> TryFrom<U> for T where
    U: Into<T>, 
[src]

type Error = !

The type returned in the event of a conversion error.

impl<T, U> TryInto<U> for T where
    U: TryFrom<T>, 
[src]

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.

impl<T> Borrow<T> for T where
    T: ?Sized
[src]

impl<T> BorrowMut<T> for T where
    T: ?Sized
[src]

impl<T> Any for T where
    T: 'static + ?Sized
[src]

impl<T> Erased for T[src]

impl<T> Encodable for T where
    T: UseSpecializedEncodable + ?Sized
[src]

impl<T> Decodable for T where
    T: UseSpecializedDecodable
[src]

impl<E> SpecializationError for E[src]