Struct rustc_trait_selection::infer::canonical::ir::CoroutineArgs

pub struct CoroutineArgs<I>
where
    I: Interner,
{
    pub args: <I as Interner>::GenericArgs,
}

Similar to ClosureArgs; see the above documentation for more.

Fields

args: <I as Interner>::GenericArgs

Implementations

impl<I> CoroutineArgs<I>

where I: Interner,

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

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

pub fn parent_args(self) -> <I as Interner>::GenericArgsSlice

Returns the generic parameters of the coroutine’s parent.

pub fn kind_ty(self) -> <I as Interner>::Ty

pub fn witness(self) -> <I as Interner>::Ty

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) -> <I as Interner>::Tys

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) -> <I as Interner>::Ty

Returns the tuple type representing the upvars for this coroutine.

pub fn resume_ty(self) -> <I as Interner>::Ty

Returns the type representing the resume type of the coroutine.

pub fn yield_ty(self) -> <I as Interner>::Ty

Returns the type representing the yield type of the coroutine.

pub fn return_ty(self) -> <I as Interner>::Ty

Returns the type representing the return type of the coroutine.

pub fn sig(self) -> GenSig<I>

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

Trait Implementations

impl<I> Clone for CoroutineArgs<I>

where I: Interner,

fn clone(&self) -> CoroutineArgs<I>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'tcx> CoroutineArgsExt<'tcx> for CoroutineArgs<TyCtxt<'tcx>>

const UNRESUMED: usize = 0usize

Coroutine has not been resumed yet.

const RETURNED: usize = 1usize

Coroutine has returned or is completed.

const POISONED: usize = 2usize

Coroutine has been poisoned.

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

The valid variant indices of this coroutine.

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.

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.

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

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

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

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

fn state_tys( self, def_id: DefId, tcx: TyCtxt<'tcx>, ) -> impl Iterator + 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.

fn prefix_tys(self) -> &'tcx RawList<(), Ty<'tcx>>

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

const UNRESUMED_NAME: &'static str = "Unresumed"

const RETURNED_NAME: &'static str = "Returned"

const POISONED_NAME: &'static str = "Panicked"

impl<I> Debug for CoroutineArgs<I>

where I: Interner,

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

Formats the value using the given formatter.

impl<I> Hash for CoroutineArgs<I>

where I: Interner,

fn hash<__HI>(&self, __state: &mut __HI)

where __HI: Hasher,

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<I, J> Lift<J> for CoroutineArgs<I>

where I: Interner, J: Interner, <I as Interner>::GenericArgs: Lift<J, Lifted = <J as Interner>::GenericArgs>,

type Lifted = CoroutineArgs<J>

fn lift_to_tcx(self, interner: J) -> Option<CoroutineArgs<J>>

impl<I> PartialEq for CoroutineArgs<I>

where I: Interner,

fn eq(&self, other: &CoroutineArgs<I>) -> 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<I> TypeFoldable<I> for CoroutineArgs<I>

where I: Interner, <I as Interner>::GenericArgs: TypeFoldable<I>,

fn try_fold_with<__F>( self, __folder: &mut __F, ) -> Result<CoroutineArgs<I>, <__F as FallibleTypeFolder<I>>::Error>

where __F: FallibleTypeFolder<I>,

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<I> TypeVisitable<I> for CoroutineArgs<I>

where I: Interner, <I as Interner>::GenericArgs: TypeVisitable<I>,

fn visit_with<__V>( &self, __visitor: &mut __V, ) -> <__V as TypeVisitor<I>>::Result

where __V: TypeVisitor<I>,

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

impl<I> Copy for CoroutineArgs<I>

where I: Interner,

impl<I> Eq for CoroutineArgs<I>

where I: Interner,

Layout

Note: Unable to compute type layout, possibly due to this type having generic parameters. Layout can only be computed for concrete, fully-instantiated types.