# Enum rustc_middle::thir::ExprKind

source ·

    pub enum ExprKind<'tcx> {
    Show 46 variants    Scope {
            region_scope: Scope,
            lint_level: LintLevel,
            value: ExprId,
        },
        Box {
            value: ExprId,
        },
        If {
            if_then_scope: Scope,
            cond: ExprId,
            then: ExprId,
            else_opt: Option<ExprId>,
        },
        Call {
            ty: Ty<'tcx>,
            fun: ExprId,
            args: Box<[ExprId]>,
            from_hir_call: bool,
            fn_span: Span,
        },
        Deref {
            arg: ExprId,
        },
        Binary {
            op: BinOp,
            lhs: ExprId,
            rhs: ExprId,
        },
        LogicalOp {
            op: LogicalOp,
            lhs: ExprId,
            rhs: ExprId,
        },
        Unary {
            op: UnOp,
            arg: ExprId,
        },
        Cast {
            source: ExprId,
        },
        Use {
            source: ExprId,
        },
        NeverToAny {
            source: ExprId,
        },
        PointerCoercion {
            cast: PointerCoercion,
            source: ExprId,
        },
        Loop {
            body: ExprId,
        },
        Let {
            expr: ExprId,
            pat: Box<Pat<'tcx>>,
        },
        Match {
            scrutinee: ExprId,
            scrutinee_hir_id: HirId,
            arms: Box<[ArmId]>,
            match_source: MatchSource,
        },
        Block {
            block: BlockId,
        },
        Assign {
            lhs: ExprId,
            rhs: ExprId,
        },
        AssignOp {
            op: BinOp,
            lhs: ExprId,
            rhs: ExprId,
        },
        Field {
            lhs: ExprId,
            variant_index: VariantIdx,
            name: FieldIdx,
        },
        Index {
            lhs: ExprId,
            index: ExprId,
        },
        VarRef {
            id: LocalVarId,
        },
        UpvarRef {
            closure_def_id: DefId,
            var_hir_id: LocalVarId,
        },
        Borrow {
            borrow_kind: BorrowKind,
            arg: ExprId,
        },
        AddressOf {
            mutability: Mutability,
            arg: ExprId,
        },
        Break {
            label: Scope,
            value: Option<ExprId>,
        },
        Continue {
            label: Scope,
        },
        Return {
            value: Option<ExprId>,
        },
        Become {
            value: ExprId,
        },
        ConstBlock {
            did: DefId,
            args: GenericArgsRef<'tcx>,
        },
        Repeat {
            value: ExprId,
            count: Const<'tcx>,
        },
        Array {
            fields: Box<[ExprId]>,
        },
        Tuple {
            fields: Box<[ExprId]>,
        },
        Adt(Box<AdtExpr<'tcx>>),
        PlaceTypeAscription {
            source: ExprId,
            user_ty: Option<Box<CanonicalUserType<'tcx>>>,
        },
        ValueTypeAscription {
            source: ExprId,
            user_ty: Option<Box<CanonicalUserType<'tcx>>>,
        },
        Closure(Box<ClosureExpr<'tcx>>),
        Literal {
            lit: &'tcx Lit,
            neg: bool,
        },
        NonHirLiteral {
            lit: ScalarInt,
            user_ty: Option<Box<CanonicalUserType<'tcx>>>,
        },
        ZstLiteral {
            user_ty: Option<Box<CanonicalUserType<'tcx>>>,
        },
        NamedConst {
            def_id: DefId,
            args: GenericArgsRef<'tcx>,
            user_ty: Option<Box<CanonicalUserType<'tcx>>>,
        },
        ConstParam {
            param: ParamConst,
            def_id: DefId,
        },
        StaticRef {
            alloc_id: AllocId,
            ty: Ty<'tcx>,
            def_id: DefId,
        },
        InlineAsm(Box<InlineAsmExpr<'tcx>>),
        OffsetOf {
            container: Ty<'tcx>,
            fields: &'tcx List<(VariantIdx, FieldIdx)>,
        },
        ThreadLocalRef(DefId),
        Yield {
            value: ExprId,
        },
    }

## Variants§

§

### Scope

`Scope`s are used to explicitly mark destruction scopes, and to track the `HirId` of the expressions within the scope.

#### Fields

§`region_scope: Scope`
§`lint_level: LintLevel`
§`value: ExprId`
§

### Box

A `box <value>` expression.

#### Fields

§`value: ExprId`
§

### If

An `if` expression.

#### Fields

§`if_then_scope: Scope`
§`cond: ExprId`
§`then: ExprId`
§`else_opt: Option<ExprId>`
§

### Call

A function call. Method calls and overloaded operators are converted to plain function calls.

#### Fields

§`ty: Ty<'tcx>`

The type of the function. This is often a `FnDef` or a `FnPtr`.

§`fun: ExprId`

The function itself.

§`args: Box<[ExprId]>`

The arguments passed to the function.

Note: in some cases (like calling a closure), the function call `f(...args)` gets rewritten as a call to a function trait method (e.g. `FnOnce::call_once(f, (...args))`).

§`from_hir_call: bool`

Whether this is from an overloaded operator rather than a function call from HIR. `true` for overloaded function call.

§`fn_span: Span`

The span of the function, without the dot and receiver (e.g. `foo(a, b)` in `x.foo(a, b)`).

§

### Deref

A non-overloaded dereference.

#### Fields

§`arg: ExprId`
§

### Binary

A non-overloaded binary operation.

#### Fields

§`op: BinOp`
§`lhs: ExprId`
§`rhs: ExprId`
§

### LogicalOp

A logical operation. This is distinct from `BinaryOp` because the operands need to be lazily evaluated.

#### Fields

§`op: LogicalOp`
§`lhs: ExprId`
§`rhs: ExprId`
§

### Unary

A non-overloaded unary operation. Note that here the deref (`*`) operator is represented by `ExprKind::Deref`.

#### Fields

§`op: UnOp`
§`arg: ExprId`
§

### Cast

A cast: `<source> as <type>`. The type we cast to is the type of the parent expression.

#### Fields

§`source: ExprId`
§

### Use

Forces its contents to be treated as a value expression, not a place expression. This is inserted in some places where an operation would otherwise be erased completely (e.g. some no-op casts), but we still need to ensure that its operand is treated as a value and not a place.

#### Fields

§`source: ExprId`
§

### NeverToAny

A coercion from `!` to any type.

#### Fields

§`source: ExprId`
§

### PointerCoercion

A pointer coercion. More information can be found in `PointerCoercion`. Pointer casts that cannot be done by coercions are represented by `ExprKind::Cast`.

#### Fields

§`cast: PointerCoercion`
§`source: ExprId`
§

### Loop

A `loop` expression.

#### Fields

§`body: ExprId`
§

### Let

Special expression representing the `let` part of an `if let` or similar construct (including `if let` guards in match arms, and let-chains formed by `&&`).

This isn’t considered a real expression in surface Rust syntax, so it can only appear in specific situations, such as within the condition of an `if`.

(Not to be confused with `StmtKind::Let`, which is a normal `let` statement.)

#### Fields

§`expr: ExprId`
§`pat: Box<Pat<'tcx>>`
§

### Match

A `match` expression.

#### Fields

§`scrutinee: ExprId`
§`scrutinee_hir_id: HirId`
§`arms: Box<[ArmId]>`
§`match_source: MatchSource`
§

### Block

A block.

#### Fields

§`block: BlockId`
§

### Assign

An assignment: `lhs = rhs`.

#### Fields

§`lhs: ExprId`
§`rhs: ExprId`
§

### AssignOp

A non-overloaded operation assignment, e.g. `lhs += rhs`.

#### Fields

§`op: BinOp`
§`lhs: ExprId`
§`rhs: ExprId`
§

### Field

Access to a field of a struct, a tuple, an union, or an enum.

#### Fields

§`lhs: ExprId`
§`variant_index: VariantIdx`

Variant containing the field.

§`name: FieldIdx`

This can be a named (`.foo`) or unnamed (`.0`) field.

§

### Index

A non-overloaded indexing operation.

#### Fields

§`lhs: ExprId`
§`index: ExprId`
§

### VarRef

A local variable.

#### Fields

§`id: LocalVarId`
§

### UpvarRef

Used to represent upvars mentioned in a closure/coroutine

#### Fields

§`closure_def_id: DefId`

DefId of the closure/coroutine

§`var_hir_id: LocalVarId`

HirId of the root variable

§

### Borrow

A borrow, e.g. `&arg`.

#### Fields

§`borrow_kind: BorrowKind`
§`arg: ExprId`
§

### AddressOf

A `&raw [const|mut] $place_expr` raw borrow resulting in type `*[const|mut] T`.

#### Fields

§`mutability: Mutability`
§`arg: ExprId`
§

### Break

A `break` expression.

#### Fields

§`label: Scope`
§`value: Option<ExprId>`
§

### Continue

A `continue` expression.

#### Fields

§`label: Scope`
§

### Return

A `return` expression.

#### Fields

§`value: Option<ExprId>`
§

### Become

A `become` expression.

#### Fields

§`value: ExprId`
§

### ConstBlock

An inline `const` block, e.g. `const {}`.

#### Fields

§`did: DefId`
§`args: GenericArgsRef<'tcx>`
§

### Repeat

An array literal constructed from one repeated element, e.g. `[1; 5]`.

#### Fields

§`value: ExprId`
§`count: Const<'tcx>`
§

### Array

An array, e.g. `[a, b, c, d]`.

#### Fields

§`fields: Box<[ExprId]>`
§

### Tuple

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

#### Fields

§`fields: Box<[ExprId]>`
§

### Adt(Box<AdtExpr<'tcx>>)

An ADT constructor, e.g. `Foo {x: 1, y: 2}`.

§

### PlaceTypeAscription

A type ascription on a place.

#### Fields

§`source: ExprId`
§`user_ty: Option<Box<CanonicalUserType<'tcx>>>`

Type that the user gave to this expression

§

### ValueTypeAscription

A type ascription on a value, e.g. `42: i32`.

#### Fields

§`source: ExprId`
§`user_ty: Option<Box<CanonicalUserType<'tcx>>>`

Type that the user gave to this expression

§

### Closure(Box<ClosureExpr<'tcx>>)

A closure definition.

§

### Literal

A literal.

#### Fields

§`lit: &'tcx Lit`
§`neg: bool`
§

### NonHirLiteral

For literals that don’t correspond to anything in the HIR

#### Fields

§`lit: ScalarInt`
§`user_ty: Option<Box<CanonicalUserType<'tcx>>>`
§

### ZstLiteral

A literal of a ZST type.

#### Fields

§`user_ty: Option<Box<CanonicalUserType<'tcx>>>`
§

### NamedConst

Associated constants and named constants

#### Fields

§`def_id: DefId`
§`args: GenericArgsRef<'tcx>`
§`user_ty: Option<Box<CanonicalUserType<'tcx>>>`
§

### ConstParam

#### Fields

§`param: ParamConst`
§`def_id: DefId`
§

### StaticRef

A literal containing the address of a `static`.

This is only distinguished from `Literal` so that we can register some info for diagnostics.

#### Fields

§`alloc_id: AllocId`
§`ty: Ty<'tcx>`
§`def_id: DefId`
§

### InlineAsm(Box<InlineAsmExpr<'tcx>>)

Inline assembly, i.e. `asm!()`.

§

### OffsetOf

Field offset (`offset_of!`)

#### Fields

§`container: Ty<'tcx>`
§`fields: &'tcx List<(VariantIdx, FieldIdx)>`
§

### ThreadLocalRef(DefId)

An expression taking a reference to a thread local.

§

### Yield

A `yield` expression.

#### Fields

§`value: ExprId`

## Trait Implementations§

source§

### impl<'tcx> Clone for ExprKind<'tcx>

source§

#### fn clone(&self) -> ExprKind<'tcx>

Returns a copy of the value. Read more
1.0.0 · source§

#### fn clone_from(&mut self, source: &Self)

Performs copy-assignment from `source`. Read more
source§

### impl<'tcx> Debug for ExprKind<'tcx>

source§

#### fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter. Read more
source§

### impl<'tcx, '__ctx> HashStable<StableHashingContext<'__ctx>> for ExprKind<'tcx>

source§

#### fn hash_stable( &self, __hcx: &mut StableHashingContext<'__ctx>, __hasher: &mut StableHasher )

## Auto Trait Implementations§

§

### impl<'tcx> DynSend for ExprKind<'tcx>

§

### impl<'tcx> DynSync for ExprKind<'tcx>

§

### impl<'tcx> Freeze for ExprKind<'tcx>

§

### impl<'tcx> !RefUnwindSafe for ExprKind<'tcx>

§

### impl<'tcx> Send for ExprKind<'tcx>

§

### impl<'tcx> Sync for ExprKind<'tcx>

§

### impl<'tcx> Unpin for ExprKind<'tcx>

§

### impl<'tcx> !UnwindSafe for ExprKind<'tcx>

## Blanket Implementations§

source§

### impl<T> Aligned for T

source§

#### const ALIGN: Alignment = _

Alignment of `Self`.
source§

### impl<T> Any for T
where T: 'static + ?Sized,

source§

#### fn type_id(&self) -> TypeId

Gets the `TypeId` of `self`. Read more
source§

### impl<T> Borrow<T> for T
where T: ?Sized,

source§

#### fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
source§

### impl<T> BorrowMut<T> for T
where T: ?Sized,

source§

#### fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
source§

### impl<T, R> CollectAndApply<T, R> for T

source§

#### fn collect_and_apply<I, F>(iter: I, f: F) -> R
where I: Iterator<Item = T>, F: FnOnce(&[T]) -> R,

Equivalent to `f(&iter.collect::<Vec<_>>())`.

§

#### type Output = R

source§

### impl<Tcx, T> DepNodeParams<Tcx> for T
where Tcx: DepContext, T: for<'a> HashStable<StableHashingContext<'a>> + Debug,

source§

#### default fn fingerprint_style() -> FingerprintStyle

source§

#### default fn to_fingerprint(&self, tcx: Tcx) -> Fingerprint

This method turns the parameters of a DepNodeConstructor into an opaque Fingerprint to be used in DepNode. Not all DepNodeParams support being turned into a Fingerprint (they don’t need to if the corresponding DepNode is anonymous).
source§

#### default fn to_debug_str(&self, _: Tcx) -> String

source§

#### default fn recover(_: Tcx, _: &DepNode) -> Option<T>

This method tries to recover the query key from the given `DepNode`, something which is needed when forcing `DepNode`s during red-green evaluation. The query system will only call this method if `fingerprint_style()` is not `FingerprintStyle::Opaque`. It is always valid to return `None` here, in which case incremental compilation will treat the query as having changed instead of forcing it.
source§

### impl<T> Filterable for T

source§

#### fn filterable( self, filter_name: &'static str ) -> RequestFilterDataProvider<T, fn(_: DataRequest<'_>) -> bool>

Creates a filterable data provider with the given name for debugging. Read more
source§

### impl<T> From<T> for T

source§

#### fn from(t: T) -> T

Returns the argument unchanged.

source§

### impl<T> Instrument for T

source§

#### fn instrument(self, span: Span) -> Instrumented<Self>

Instruments this type with the provided `Span`, returning an `Instrumented` wrapper. Read more
source§

#### fn in_current_span(self) -> Instrumented<Self>

Instruments this type with the current `Span`, returning an `Instrumented` wrapper. Read more
source§

### impl<T, U> Into<U> for T
where U: From<T>,

source§

#### fn into(self) -> U

Calls `U::from(self)`.

That is, this conversion is whatever the implementation of `From<T> for U` chooses to do.

source§

### impl<P> IntoQueryParam<P> for P

source§

#### fn into_query_param(self) -> P

source§

### impl<T> MaybeResult<T> for T

§

#### type Error = !

source§

#### fn from(_: Result<T, <T as MaybeResult<T>>::Error>) -> T

source§

#### fn to_result(self) -> Result<T, <T as MaybeResult<T>>::Error>

source§

### impl<T> Pointable for T

source§

#### const ALIGN: usize = _

The alignment of pointer.
§

#### type Init = T

The type for initializers.
source§

#### unsafe fn init(init: <T as Pointable>::Init) -> usize

Initializes a with the given initializer. Read more
source§

#### unsafe fn deref<'a>(ptr: usize) -> &'a T

Dereferences the given pointer. Read more
source§

#### unsafe fn deref_mut<'a>(ptr: usize) -> &'a mut T

Mutably dereferences the given pointer. Read more
source§

#### unsafe fn drop(ptr: usize)

Drops the object pointed to by the given pointer. Read more
source§

### impl<T> Same for T

§

#### type Output = T

Should always be `Self`
source§

### impl<T> ToOwned for T
where T: Clone,

§

#### type Owned = T

The resulting type after obtaining ownership.
source§

#### fn to_owned(&self) -> T

Creates owned data from borrowed data, usually by cloning. Read more
source§

#### fn clone_into(&self, target: &mut T)

Uses borrowed data to replace owned data, usually by cloning. Read more
source§

### impl<'tcx, T> ToPredicate<'tcx, T> for T

source§

#### fn to_predicate(self, _tcx: TyCtxt<'tcx>) -> T

source§

### impl<T, U> TryFrom<U> for T
where U: Into<T>,

§

#### type Error = Infallible

The type returned in the event of a conversion error.
source§

#### fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
source§

### impl<T, U> TryInto<U> for T
where U: TryFrom<T>,

§

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

The type returned in the event of a conversion error.
source§

#### fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.
source§

### impl<V, T> VZip<V> for T
where V: MultiLane<T>,

source§

#### fn vzip(self) -> V

source§

### impl<Tcx, T> Value<Tcx> for T
where Tcx: DepContext,

source§

#### default fn from_cycle_error( tcx: Tcx, cycle_error: &CycleError, _guar: ErrorGuaranteed ) -> T

source§

### impl<T> WithSubscriber for T

source§

#### fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>
where S: Into<Dispatch>,

Attaches the provided `Subscriber` to this type, returning a `WithDispatch` wrapper. Read more
source§

#### fn with_current_subscriber(self) -> WithDispatch<Self>

Attaches the current default `Subscriber` to this type, returning a `WithDispatch` wrapper. Read more
source§

### impl<'a, T> Captures<'a> for T
where T: ?Sized,

source§

### impl<T> ErasedDestructor for T
where T: 'static,

source§

### impl<T> MaybeSendSync for T
where T: Send + Sync,

## Layout§

Note: Most layout information is completely unstable and may even differ between compilations. The only exception is types with certain `repr(...)` attributes. Please see the Rust Reference's “Type Layout” chapter for details on type layout guarantees.

Size: 40 bytes

Size for each variant:

- `Scope`: 23 bytes
- `Box`: 7 bytes
- `If`: 23 bytes
- `Call`: 39 bytes
- `Deref`: 7 bytes
- `Binary`: 11 bytes
- `LogicalOp`: 11 bytes
- `Unary`: 7 bytes
- `Cast`: 7 bytes
- `Use`: 7 bytes
- `NeverToAny`: 7 bytes
- `PointerCoercion`: 7 bytes
- `Loop`: 7 bytes
- `Let`: 15 bytes
- `Match`: 39 bytes
- `Block`: 7 bytes
- `Assign`: 11 bytes
- `AssignOp`: 11 bytes
- `Field`: 15 bytes
- `Index`: 11 bytes
- `VarRef`: 11 bytes
- `UpvarRef`: 19 bytes
- `Borrow`: 7 bytes
- `AddressOf`: 7 bytes
- `Break`: 15 bytes
- `Continue`: 11 bytes
- `Return`: 7 bytes
- `Become`: 7 bytes
- `ConstBlock`: 23 bytes
- `Repeat`: 15 bytes
- `Array`: 23 bytes
- `Tuple`: 23 bytes
- `Adt`: 15 bytes
- `PlaceTypeAscription`: 15 bytes
- `ValueTypeAscription`: 15 bytes
- `Closure`: 15 bytes
- `Literal`: 15 bytes
- `NonHirLiteral`: 31 bytes
- `ZstLiteral`: 15 bytes
- `NamedConst`: 31 bytes
- `ConstParam`: 19 bytes
- `StaticRef`: 31 bytes
- `InlineAsm`: 15 bytes
- `OffsetOf`: 23 bytes
- `ThreadLocalRef`: 11 bytes
- `Yield`: 7 bytes