Struct rustc_middle::mir::CoroutineInfo

pub struct CoroutineInfo<'tcx> {
    pub yield_ty: Option<Ty<'tcx>>,
    pub resume_ty: Option<Ty<'tcx>>,
    pub coroutine_drop: Option<Body<'tcx>>,
    pub by_move_body: Option<Body<'tcx>>,
    pub by_mut_body: Option<Body<'tcx>>,
    pub coroutine_layout: Option<CoroutineLayout<'tcx>>,
    pub coroutine_kind: CoroutineKind,
}

Additional information carried by a MIR body when it is lowered from a coroutine. This information is modified as it is lowered during the StateTransform MIR pass, so not all fields will be active at a given time. For example, the yield_ty is taken out of the field after yields are turned into returns, and the coroutine_drop body is only populated after the state transform pass.

Fields

yield_ty: Option<Ty<'tcx>>

The yield type of the function. This field is removed after the state transform pass.

resume_ty: Option<Ty<'tcx>>

The resume type of the function. This field is removed after the state transform pass.

coroutine_drop: Option<Body<'tcx>>

Coroutine drop glue. This field is populated after the state transform pass.

by_move_body: Option<Body<'tcx>>

The body of the coroutine, modified to take its upvars by move rather than by ref.

This is used by coroutine-closures, which must return a different flavor of coroutine when called using AsyncFnOnce::call_once. It is produced by the ByMoveBody pass which is run right after building the initial MIR, and will only be populated for coroutines which come out of the async closure desugaring.

This body should be processed in lockstep with the containing body – any optimization passes, etc, should be applied to this body as well. This is done automatically if using run_passes.

by_mut_body: Option<Body<'tcx>>

The body of the coroutine, modified to take its upvars by mutable ref rather than by immutable ref.

FIXME(async_closures): This is literally the same body as the parent body. Find a better way to represent the by-mut signature (or cap the closure-kind of the coroutine).

coroutine_layout: Option<CoroutineLayout<'tcx>>

The layout of a coroutine. This field is populated after the state transform pass.

coroutine_kind: CoroutineKind

If this is a coroutine then record the type of source expression that caused this coroutine to be created.

Implementations

impl<'tcx> CoroutineInfo<'tcx>

pub fn initial( coroutine_kind: CoroutineKind, yield_ty: Ty<'tcx>, resume_ty: Ty<'tcx> ) -> CoroutineInfo<'tcx>

Trait Implementations

impl<'tcx> Clone for CoroutineInfo<'tcx>

fn clone(&self) -> CoroutineInfo<'tcx>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'tcx> Debug for CoroutineInfo<'tcx>

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

Formats the value using the given formatter.

impl<'tcx, __D: TyDecoder<I = TyCtxt<'tcx>>> Decodable<__D> for CoroutineInfo<'tcx>

fn decode(__decoder: &mut __D) -> Self

impl<'tcx, __E: TyEncoder<I = TyCtxt<'tcx>>> Encodable<__E> for CoroutineInfo<'tcx>

fn encode(&self, __encoder: &mut __E)

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

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

impl<'tcx> TypeFoldable<TyCtxt<'tcx>> for CoroutineInfo<'tcx>

fn try_fold_with<__F: FallibleTypeFolder<TyCtxt<'tcx>>>( self, __folder: &mut __F ) -> Result<Self, __F::Error>

The entry point for folding. To fold a value t with a folder f call: t.try_fold_with(f).

fn fold_with<F>(self, folder: &mut F) -> Self

where F: TypeFolder<I>,

A convenient alternative to try_fold_with for use with infallible folders. Do not override this method, to ensure coherence with try_fold_with.

impl<'tcx> TypeVisitable<TyCtxt<'tcx>> for CoroutineInfo<'tcx>

fn visit_with<__V: TypeVisitor<TyCtxt<'tcx>>>( &self, __visitor: &mut __V ) -> __V::Result

The entry point for visiting. To visit a value t with a visitor v call: t.visit_with(v).

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: 1456 bytes