Struct AccessedOpaques 

pub struct AccessedOpaques<I>
where
    I: Interner,
{
    pub reason: Option<RerunReason>,
    pub rerun: RerunCondition<I>,
}

Fields

reason: Option<RerunReason>

rerun: RerunCondition<I>

Implementations

impl<I> AccessedOpaques<I>

where I: Interner,

pub fn update(&mut self, other: AccessedOpaques<I>)

pub fn might_rerun(&self) -> bool

pub fn should_bail(&self) -> bool

pub fn rerun_always(&mut self, reason: RerunReason)

pub fn rerun_if_in_post_analysis(&mut self, reason: RerunReason)

pub fn rerun_if_opaque_in_opaque_type_storage( &mut self, reason: RerunReason, defid: <I as Interner>::LocalDefId, )

pub fn rerun_if_any_opaque_has_infer_as_hidden_type( &mut self, reason: RerunReason, )

Trait Implementations

impl<I> Clone for AccessedOpaques<I>

where I: Interner,

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<I> Debug for AccessedOpaques<I>

where I: Interner,

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

Formats the value using the given formatter.

impl<I> Default for AccessedOpaques<I>

where I: Interner,

fn default() -> AccessedOpaques<I>

Returns the “default value” for a type.

impl<I> Hash for AccessedOpaques<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 AccessedOpaques<I>

where I: Interner,

fn eq(&self, __other: &AccessedOpaques<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 AccessedOpaques<I>

where I: Interner, RerunCondition<I>: StableHash,

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

where __Hcx: StableHashCtxt,

impl<I> TypeFoldable<I> for AccessedOpaques<I>

where I: Interner, RerunCondition<I>: TypeFoldable<I>,

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

where I: Interner, RerunCondition<I>: 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 AccessedOpaques<I>

where I: Interner,

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