Struct rustc_middle::ty::sty::CoroutineArgs

pub struct CoroutineArgs<'tcx> {
    pub args: GenericArgsRef<'tcx>,
}

Similar to ClosureArgs; see the above documentation for more.

Fields

args: GenericArgsRef<'tcx>

Implementations

impl<'tcx> CoroutineArgs<'tcx>

pub fn new( tcx: TyCtxt<'tcx>, parts: CoroutineArgsParts<'tcx> ) -> CoroutineArgs<'tcx>

Construct CoroutineArgs from CoroutineArgsParts, containing Args for the coroutine parent, alongside additional coroutine-specific components.

fn split(self) -> CoroutineArgsParts<'tcx>

Divides the coroutine args into their respective components. The ordering assumed here must match that used by CoroutineArgs::new above.

pub fn parent_args(self) -> &'tcx [GenericArg<'tcx>]

Returns the generic parameters of the coroutine’s parent.

pub fn kind_ty(self) -> Ty<'tcx>

pub fn witness(self) -> Ty<'tcx>

This describes the types that can be contained in a coroutine. It will be a type variable initially and unified in the last stages of typeck of a body. It contains a tuple of all the types that could end up on a coroutine frame. The state transformation MIR pass may only produce layouts which mention types in this tuple. Upvars are not counted here.

pub fn upvar_tys(self) -> &'tcx List<Ty<'tcx>>

Returns an iterator over the list of types of captured paths by the coroutine. In case there was a type error in figuring out the types of the captured path, an empty iterator is returned.

pub fn tupled_upvars_ty(self) -> Ty<'tcx>

Returns the tuple type representing the upvars for this coroutine.

pub fn resume_ty(self) -> Ty<'tcx>

Returns the type representing the resume type of the coroutine.

pub fn yield_ty(self) -> Ty<'tcx>

Returns the type representing the yield type of the coroutine.

pub fn return_ty(self) -> Ty<'tcx>

Returns the type representing the return type of the coroutine.

pub fn sig(self) -> GenSig<'tcx>

Returns the “coroutine signature”, which consists of its resume, yield and return types.

impl<'tcx> CoroutineArgs<'tcx>

pub const UNRESUMED: usize = 0usize

Coroutine has not been resumed yet.

pub const RETURNED: usize = 1usize

Coroutine has returned or is completed.

pub const POISONED: usize = 2usize

Coroutine has been poisoned.

const UNRESUMED_NAME: &'static str = "Unresumed"

const RETURNED_NAME: &'static str = "Returned"

const POISONED_NAME: &'static str = "Panicked"

pub fn variant_range( &self, def_id: DefId, tcx: TyCtxt<'tcx> ) -> Range<VariantIdx>

The valid variant indices of this coroutine.

pub fn discriminant_for_variant( &self, def_id: DefId, tcx: TyCtxt<'tcx>, variant_index: VariantIdx ) -> Discr<'tcx>

The discriminant for the given variant. Panics if the variant_index is out of range.

pub fn discriminants( self, def_id: DefId, tcx: TyCtxt<'tcx> ) -> impl Iterator<Item = (VariantIdx, Discr<'tcx>)> + Captures<'tcx>

The set of all discriminants for the coroutine, enumerated with their variant indices.

pub fn variant_name(v: VariantIdx) -> Cow<'static, str>

Calls f with a reference to the name of the enumerator for the given variant v.

pub fn discr_ty(&self, tcx: TyCtxt<'tcx>) -> Ty<'tcx>

The type of the state discriminant used in the coroutine type.

pub fn state_tys( self, def_id: DefId, tcx: TyCtxt<'tcx> ) -> impl Iterator<Item: Iterator<Item = Ty<'tcx>> + Captures<'tcx>>

This returns the types of the MIR locals which had to be stored across suspension points. It is calculated in rustc_mir_transform::coroutine::StateTransform. All the types here must be in the tuple in CoroutineInterior.

The locals are grouped by their variant number. Note that some locals may be repeated in multiple variants.

pub fn prefix_tys(self) -> &'tcx List<Ty<'tcx>>

This is the types of the fields of a coroutine which are not stored in a variant.

Trait Implementations

impl<'tcx> Clone for CoroutineArgs<'tcx>

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'tcx> Debug for CoroutineArgs<'tcx>

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

Formats the value using the given formatter.

impl<'tcx> PartialEq for CoroutineArgs<'tcx>

fn eq(&self, other: &CoroutineArgs<'tcx>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<'tcx> Relate<'tcx> for CoroutineArgs<'tcx>

fn relate<R: TypeRelation<'tcx>>( relation: &mut R, a: CoroutineArgs<'tcx>, b: CoroutineArgs<'tcx> ) -> RelateResult<'tcx, CoroutineArgs<'tcx>>

impl<'tcx> TypeFoldable<TyCtxt<'tcx>> for CoroutineArgs<'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 CoroutineArgs<'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).

impl<'tcx> Copy for CoroutineArgs<'tcx>

impl<'tcx> Eq for CoroutineArgs<'tcx>

impl<'tcx> StructuralPartialEq for CoroutineArgs<'tcx>

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