Enum RerunCondition 

pub enum RerunCondition<I>
where
    I: Interner,
{
    Never,
    AnyOpaqueHasInferAsHidden,
    OpaqueInStorage(SmallCopyList<<I as Interner>::LocalDefId>),
    OpaqueInStorageOrAnyOpaqueHasInferAsHidden(SmallCopyList<<I as Interner>::LocalDefId>),
    Always,
}

Information about how we accessed opaque types This is what the trait solver does when each states is encountered:

	bail?	rerun goal?
never	no	no
always	yes	yes
[defid in storage]	no	only if any of the defids in the list is in the opaque type storage OR if TypingMode::PostAnalysis
opaque with hidden type	no	only if any of the the opaques in the opaque type storage has a hidden type in this list AND if TypingMode::Analysis

• “bail” is implemented with should_bail. If true, we’re abandoning our attempt to canonicalize in TypingMode::ErasedNotCoherence, and should try to return as soon as possible to waste as little time as possible. A rerun will be attempted in the original typing mode.

• Rerun goal is implemented with should_rerun_after_erased_canonicalization, on the EvalCtxt.

Some variant names contain an Or here. They rerun when any of the two conditions applies

Variants

Never

AnyOpaqueHasInferAsHidden

Note that this only reruns according to the condition if we are in TypingMode::Analysis.

OpaqueInStorage(SmallCopyList<<I as Interner>::LocalDefId>)

Note: unconditionally reruns in postanalysis

OpaqueInStorageOrAnyOpaqueHasInferAsHidden(SmallCopyList<<I as Interner>::LocalDefId>)

Merges Self::AnyOpaqueHasInferAsHidden and Self::OpaqueInStorage. Note that just like the unmerged Self::OpaqueInStorage, that part of the condition only matters in TypingMode::Analysis

Always

Trait Implementations

impl<I> Clone for RerunCondition<I>

where I: Interner,

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<I> Debug for RerunCondition<I>

where I: Interner,

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

Formats the value using the given formatter.

impl<I> Hash for RerunCondition<I>

where I: Interner,

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

where __H: 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> PartialEq for RerunCondition<I>

where I: Interner,

fn eq(&self, __other: &RerunCondition<I>) -> bool

Tests for self and other values to be equal, and is used by ==.

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

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

impl<I> StableHash for RerunCondition<I>

where I: Interner, SmallCopyList<<I as Interner>::LocalDefId>: StableHash,

fn stable_hash<__Hcx>( &self, __hcx: &mut __Hcx, __hasher: &mut StableHasher<SipHasher128>, )

where __Hcx: StableHashCtxt,

impl<I> TypeFoldable<I> for RerunCondition<I>

where I: Interner, SmallCopyList<<I as Interner>::LocalDefId>: TypeFoldable<I>,

fn try_fold_with<__F>( self, __folder: &mut __F, ) -> Result<RerunCondition<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) -> RerunCondition<I>

where __F: TypeFolder<I>,

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

impl<I> TypeVisitable<I> for RerunCondition<I>

where I: Interner, SmallCopyList<<I as Interner>::LocalDefId>: 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 RerunCondition<I>

where I: Interner,

impl<I> Eq for RerunCondition<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.