Enum rustc_infer::traits::DefiningAnchor

pub enum DefiningAnchor<'tcx> {
    Bind(&'tcx List<LocalDefId>),
    Bubble,
}

Defines the treatment of opaque types in a given inference context.

This affects both what opaques are allowed to be defined, but also whether opaques are replaced with inference vars eagerly in the old solver (e.g. in projection, and in the signature during function type-checking).

Variants

Bind(&'tcx List<LocalDefId>)

Define opaques which are in-scope of the current item being analyzed. Also, eagerly replace these opaque types in replace_opaque_types_with_inference_vars.

If the list is empty, do not allow any opaques to be defined. This is used to catch type mismatch errors when handling opaque types, and also should be used when we would otherwise reveal opaques (such as Reveal::All reveal mode).

Bubble

In contexts where we don’t currently know what opaques are allowed to be defined, such as (old solver) canonical queries, we will simply allow opaques to be defined, but “bubble” them up in the canonical response or otherwise treat them to be handled later.

We do not eagerly replace opaque types in replace_opaque_types_with_inference_vars, which may affect what predicates pass and fail in the old trait solver.

Implementations

impl<'tcx> DefiningAnchor<'tcx>

pub fn bind(tcx: TyCtxt<'tcx>, item: LocalDefId) -> DefiningAnchor<'tcx>

Trait Implementations

impl<'tcx> Clone for DefiningAnchor<'tcx>

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'tcx> Debug for DefiningAnchor<'tcx>

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

Formats the value using the given formatter.

impl<'tcx> Hash for DefiningAnchor<'tcx>

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<'tcx, '__ctx> HashStable<StableHashingContext<'__ctx>> for DefiningAnchor<'tcx>

fn hash_stable( &self, __hcx: &mut StableHashingContext<'__ctx>, __hasher: &mut StableHasher )

impl<'tcx> PartialEq for DefiningAnchor<'tcx>

fn eq(&self, other: &DefiningAnchor<'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> TypeFoldable<TyCtxt<'tcx>> for DefiningAnchor<'tcx>

fn try_fold_with<__F>( self, __folder: &mut __F ) -> Result<DefiningAnchor<'tcx>, <__F as FallibleTypeFolder<TyCtxt<'tcx>>>::Error>

where __F: FallibleTypeFolder<TyCtxt<'tcx>>,

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 DefiningAnchor<'tcx>

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

where __V: TypeVisitor<TyCtxt<'tcx>>,

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

impl<'tcx> Copy for DefiningAnchor<'tcx>

impl<'tcx> Eq for DefiningAnchor<'tcx>

impl<'tcx> StructuralPartialEq for DefiningAnchor<'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

Size for each variant:

• Bind: 8 bytes
• Bubble: 0 bytes