Enum RerunCondition 

pub enum RerunCondition<I: Interner> {
    Never,
    AnyOpaqueHasInferAsHidden,
    OpaqueInStorage(SmallCopyList<I::LocalDefId>),
    OpaqueInStorageOrAnyOpaqueHasInferAsHidden(SmallCopyList<I::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::LocalDefId>)

Note: unconditionally reruns in postanalysis

OpaqueInStorageOrAnyOpaqueHasInferAsHidden(SmallCopyList<I::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

Implementations

impl<I: Interner> RerunCondition<I>

fn merge(self, other: Self) -> Self

Merge two rerun states according to the following transition diagram (some cells are empty because the table is symmetric, i.e. a.merge(b) == b.merge(a)).

• “self” here means the current state, i.e. the state of the current column
• square brackets represents that this is a list of things. Even if the state doesn’t change, we might grow the list to effectively end up in a different state anyway
• [o. in s.] abbreviates “opaque in storage”

	never	always	[opaque in storage]	opaque has infer as hidden	[o. in s.] or i. as hidden
never	self	self	self	self	self
always		always	always	always	always
[opaque in storage]			concat self	[o. in s.] or i. as hidden	concat to self
opaque has infer as hidden type				self	to self

fn should_bail(&self) -> Result<(), RerunNonErased>

fn might_rerun(&self) -> bool

Returns true when any access of opaques was attempted. i.e. when self != Self::Never

Trait Implementations

impl<I> Clone for RerunCondition<I>

where I: Interner,

fn clone(&self) -> Self

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

Formats the value using the given formatter.

impl<I> Hash for RerunCondition<I>

where I: Interner,

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

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: &Self) -> 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: Interner> StableHash for RerunCondition<I>

where SmallCopyList<I::LocalDefId>: StableHash,

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

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

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

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

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::LocalDefId>: TypeVisitable<I>,

fn visit_with<__V: TypeVisitor<I>>(&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<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.