Enum rustc_middle::thir::ExprKind[−][src]

pub enum ExprKind<'tcx> {
Show 41 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,
    },
    Pointer {
        cast: PointerCast,
        source: ExprId,
    },
    Loop {
        body: ExprId,
    },
    Let {
        expr: ExprId,
        pat: Pat<'tcx>,
    },
    Match {
        scrutinee: ExprId,
        arms: Box<[ArmId]>,
    },
    Block {
        body: Block,
    },
    Assign {
        lhs: ExprId,
        rhs: ExprId,
    },
    AssignOp {
        op: BinOp,
        lhs: ExprId,
        rhs: ExprId,
    },
    Field {
        lhs: ExprId,
        name: Field,
    },
    Index {
        lhs: ExprId,
        index: ExprId,
    },
    VarRef {
        id: HirId,
    },
    UpvarRef {
        closure_def_id: DefId,
        var_hir_id: HirId,
    },
    Borrow {
        borrow_kind: BorrowKind,
        arg: ExprId,
    },
    AddressOf {
        mutability: Mutability,
        arg: ExprId,
    },
    Break {
        label: Scope,
        value: Option<ExprId>,
    },
    Continue {
        label: Scope,
    },
    Return {
        value: Option<ExprId>,
    },
    ConstBlock {
        value: &'tcx Const<'tcx>,
    },
    Repeat {
        value: ExprId,
        count: &'tcx Const<'tcx>,
    },
    Array {
        fields: Box<[ExprId]>,
    },
    Tuple {
        fields: Box<[ExprId]>,
    },
    Adt(Box<Adt<'tcx>>),
    PlaceTypeAscription {
        source: ExprId,
        user_ty: Option<Canonical<'tcx, UserType<'tcx>>>,
    },
    ValueTypeAscription {
        source: ExprId,
        user_ty: Option<Canonical<'tcx, UserType<'tcx>>>,
    },
    Closure {
        closure_id: DefId,
        substs: UpvarSubsts<'tcx>,
        upvars: Box<[ExprId]>,
        movability: Option<Movability>,
        fake_reads: Vec<(ExprId, FakeReadCause, HirId)>,
    },
    Literal {
        literal: &'tcx Const<'tcx>,
        user_ty: Option<Canonical<'tcx, UserType<'tcx>>>,
        const_id: Option<DefId>,
    },
    StaticRef {
        literal: &'tcx Const<'tcx>,
        def_id: DefId,
    },
    InlineAsm {
        template: &'tcx [InlineAsmTemplatePiece],
        operands: Box<[InlineAsmOperand<'tcx>]>,
        options: InlineAsmOptions,
        line_spans: &'tcx [Span],
    },
    ThreadLocalRef(DefId),
    LlvmInlineAsm {
        asm: &'tcx LlvmInlineAsmInner,
        outputs: Box<[ExprId]>,
        inputs: Box<[ExprId]>,
    },
    Yield {
        value: ExprId,
    },
}

Variants

Scope

Scopes are used to explicitely mark destruction scopes, and to track the HirId of the expressions within the scope.

Fields of Scope

region_scope: Scopelint_level: LintLevelvalue: ExprId

Box

A box <value> expression.

Fields of Box

value: ExprId

If

An if expression.

Fields of If

if_then_scope: Scopecond: ExprIdthen: ExprIdelse_opt: Option<ExprId>

Call

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

Fields of Call

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 of Deref

arg: ExprId

Binary

A non-overloaded binary operation.

Fields of Binary

op: BinOplhs: ExprIdrhs: ExprId

LogicalOp

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

Fields of LogicalOp

op: LogicalOplhs: ExprIdrhs: ExprId

Unary

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

Fields of Unary

op: UnOparg: ExprId

Cast

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

Fields of Cast

source: ExprId

Use

Fields of Use

source: ExprId

NeverToAny

A coercion from ! to any type.

Fields of NeverToAny

source: ExprId

Pointer

A pointer cast. More information can be found in PointerCast.

Fields of Pointer

cast: PointerCastsource: ExprId

Loop

A loop expression.

Fields of Loop

body: ExprId

Let

Fields of Let

expr: ExprIdpat: Pat<'tcx>

Match

A match expression.

Fields of Match

scrutinee: ExprIdarms: Box<[ArmId]>

Block

A block.

Fields of Block

body: Block

Assign

An assignment: lhs = rhs.

Fields of Assign

lhs: ExprIdrhs: ExprId

AssignOp

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

Fields of AssignOp

op: BinOplhs: ExprIdrhs: ExprId

Field

Access to a struct or tuple field.

Fields of Field

lhs: ExprIdname: Field

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

Index

A non-overloaded indexing operation.

Fields of Index

lhs: ExprIdindex: ExprId

VarRef

A local variable.

Fields of VarRef

id: HirId

UpvarRef

Used to represent upvars mentioned in a closure/generator

Fields of UpvarRef

closure_def_id: DefId

DefId of the closure/generator

var_hir_id: HirId

HirId of the root variable

Borrow

A borrow, e.g. &arg.

Fields of Borrow

borrow_kind: BorrowKindarg: ExprId

AddressOf

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

Fields of AddressOf

mutability: Mutabilityarg: ExprId

Break

A break expression.

Fields of Break

label: Scopevalue: Option<ExprId>

Continue

A continue expression.

Fields of Continue

label: Scope

Return

A return expression.

Fields of Return

value: Option<ExprId>

ConstBlock

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

Fields of ConstBlock

value: &'tcx Const<'tcx>

Repeat

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

Fields of Repeat

value: ExprIdcount: &'tcx Const<'tcx>

Array

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

Fields of Array

fields: Box<[ExprId]>

Tuple

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

Fields of Tuple

fields: Box<[ExprId]>

Adt(Box<Adt<'tcx>>)

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

Tuple Fields of Adt

0: Box<Adt<'tcx>>

PlaceTypeAscription

A type ascription on a place.

Fields of PlaceTypeAscription

source: ExprIduser_ty: Option<Canonical<'tcx, UserType<'tcx>>>

Type that the user gave to this expression

ValueTypeAscription

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

Fields of ValueTypeAscription

source: ExprIduser_ty: Option<Canonical<'tcx, UserType<'tcx>>>

Type that the user gave to this expression

Closure

A closure definition.

Fields of Closure

closure_id: DefIdsubsts: UpvarSubsts<'tcx>upvars: Box<[ExprId]>movability: Option<Movability>fake_reads: Vec<(ExprId, FakeReadCause, HirId)>

Literal

A literal.

Fields of Literal

literal: &'tcx Const<'tcx>user_ty: Option<Canonical<'tcx, UserType<'tcx>>>const_id: Option<DefId>

The DefId of the const item this literal was produced from, if this is not a user-written literal value.

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 of StaticRef

literal: &'tcx Const<'tcx>def_id: DefId

InlineAsm

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

Fields of InlineAsm

template: &'tcx [InlineAsmTemplatePiece]operands: Box<[InlineAsmOperand<'tcx>]>options: InlineAsmOptionsline_spans: &'tcx [Span]

ThreadLocalRef(DefId)

An expression taking a reference to a thread local.

Tuple Fields of ThreadLocalRef

0: DefId

LlvmInlineAsm

Inline LLVM assembly, i.e. llvm_asm!().

Fields of LlvmInlineAsm

asm: &'tcx LlvmInlineAsmInneroutputs: Box<[ExprId]>inputs: Box<[ExprId]>

Yield

A yield expression.

Fields of Yield

value: ExprId

Trait Implementations

[src]

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

[src]

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

Formats the value using the given formatter. Read more

[src]

impl<'tcx, 'ctx> HashStable<StableHashingContext<'ctx>> for ExprKind<'tcx>

[src]

fn hash_stable(
 &self,
 hcx: &mut StableHashingContext<'ctx>,
 __hasher: &mut StableHasher
)

Auto Trait Implementations

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

[src]

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

[src]

pub fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more

[src]

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

[src]

pub fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more

[src]

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

[src]

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

Mutably borrows from an owned value. Read more

[src]

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

[src]

pub default fn fingerprint_style() -> FingerprintStyle

[src]

pub default fn to_fingerprint(&self, tcx: Ctxt) -> 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). Read more

[src]

pub default fn to_debug_str(&self, Ctxt) -> String

[src]

pub default fn recover(
Ctxt,
&DepNode<<Ctxt as DepContext>::DepKind>
) -> Option<T>

This method tries to recover the query key from the given DepNode, something which is needed when forcing DepNodes 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. Read more

[src]

impl<T> From<T> for T

[src]

pub fn from(t: T) -> T

Performs the conversion.

[src]

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

[src]

pub fn into(self) -> U

Performs the conversion.

[src]

impl<T> MaybeResult<T> for T

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

type Error = Infallible

The type returned in the event of a conversion error.

[src]

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

Performs the conversion.

[src]

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

type Error = >::Error

The type returned in the event of a conversion error.

[src]

pub fn try_into(self) -> Result<U, >::Error>

Performs the conversion.

[src]

impl<T> WithConstness for T

[src]

fn with_constness(self, constness: BoundConstness) -> ConstnessAnd<Self>

[src]

fn with_const_if_const(self) -> ConstnessAnd<Self>

[src]

fn without_const(self) -> ConstnessAnd<Self>

[src]

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

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: 80 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
Pointer: 7 bytes
Loop: 7 bytes
Let: 31 bytes
Match: 23 bytes
Block: 63 bytes
Assign: 11 bytes
AssignOp: 11 bytes
Field: 11 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
ConstBlock: 15 bytes
Repeat: 15 bytes
Array: 23 bytes
Tuple: 23 bytes
Adt: 15 bytes
PlaceTypeAscription: 63 bytes
ValueTypeAscription: 63 bytes
Closure: 71 bytes
Literal: 79 bytes
StaticRef: 23 bytes
InlineAsm: 55 bytes
ThreadLocalRef: 11 bytes
LlvmInlineAsm: 47 bytes
Yield: 7 bytes

Enum rustc_middle::thir::ExprKind[−][src]

Variants

Fields of Scope

Fields of Box

Fields of If

Fields of Call

Fields of Deref

Fields of Binary

Fields of LogicalOp

Fields of Unary

Fields of Cast

Fields of Use

Fields of NeverToAny

Fields of Pointer

Fields of Loop

Fields of Let

Fields of Match

Fields of Block

Fields of Assign

Fields of AssignOp

Fields of Field

Fields of Index

Fields of VarRef

Fields of UpvarRef

Fields of Borrow

Fields of AddressOf

Fields of Break

Fields of Continue

Fields of Return

Fields of ConstBlock

Fields of Repeat

Fields of Array

Fields of Tuple

Tuple Fields of Adt

Fields of PlaceTypeAscription

Fields of ValueTypeAscription

Fields of Closure

Fields of Literal

Fields of StaticRef

Fields of InlineAsm

Tuple Fields of ThreadLocalRef

Fields of LlvmInlineAsm

Fields of Yield

Trait Implementations

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

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

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

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

Auto Trait Implementations

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

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

pub fn type_id(&self) -> TypeId

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

pub fn borrow(&self) -> &T

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

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

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

pub default fn fingerprint_style() -> FingerprintStyle

pub default fn to_fingerprint(&self, tcx: Ctxt) -> Fingerprint

pub default fn to_debug_str(&self, Ctxt) -> String

pub default fn recover( Ctxt, &DepNode<<Ctxt as DepContext>::DepKind>) -> Option<T>

impl<T> From<T> for T

pub fn from(t: T) -> T

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

pub fn into(self) -> U

impl<T> MaybeResult<T> for T

type Error = !

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

pub fn to_result(Self) -> Result<T, <T as MaybeResult<T>>::Error>

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

type Error = Infallible

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

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

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

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

impl<'tcx, 'ctx> HashStable<StableHashingContext<'ctx>> for ExprKind<'tcx>

fn hash_stable(
&self,
hcx: &mut StableHashingContext<'ctx>,
__hasher: &mut StableHasher
)

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

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

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

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

pub default fn recover(
Ctxt,
&DepNode<<Ctxt as DepContext>::DepKind>
) -> Option<T>

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

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

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

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