Enum rustc_middle::traits::solve::inspect::ProbeKind

pub enum ProbeKind<I>
where
    I: Interner,
{
    Root {
        result: Result<Canonical<I, Response<I>>, NoSolution>,
    },
    TryNormalizeNonRigid {
        result: Result<Canonical<I, Response<I>>, NoSolution>,
    },
    NormalizedSelfTyAssembly,
    TraitCandidate {
        source: CandidateSource<I>,
        result: Result<Canonical<I, Response<I>>, NoSolution>,
    },
    UnsizeAssembly,
    UpcastProjectionCompatibility,
    ShadowedEnvProbing,
    OpaqueTypeStorageLookup {
        result: Result<Canonical<I, Response<I>>, NoSolution>,
    },
}

What kind of probe we’re in. In case the probe represents a candidate, or the final result of the current goal - via ProbeKind::Root - we also store the QueryResult.

Variants

Root

The root inference context while proving a goal.

Fields

result: Result<Canonical<I, Response<I>>, NoSolution>

TryNormalizeNonRigid

Trying to normalize an alias by at least one step in NormalizesTo.

Fields

result: Result<Canonical<I, Response<I>>, NoSolution>

NormalizedSelfTyAssembly

Probe entered when normalizing the self ty during candidate assembly

TraitCandidate

A candidate for proving a trait or alias-relate goal.

Fields

source: CandidateSource<I>

result: Result<Canonical<I, Response<I>>, NoSolution>

UnsizeAssembly

Used in the probe that wraps normalizing the non-self type for the unsize trait, which is also structurally matched on.

UpcastProjectionCompatibility

During upcasting from some source object to target object type, used to do a probe to find out what projection type(s) may be used to prove that the source type upholds all of the target type’s object bounds.

ShadowedEnvProbing

Looking for param-env candidates that satisfy the trait ref for a projection.

OpaqueTypeStorageLookup

Try to unify an opaque type with an existing key in the storage.

Fields

result: Result<Canonical<I, Response<I>>, NoSolution>

Trait Implementations

impl<I> Clone for ProbeKind<I>

where I: Interner,

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<I> Debug for ProbeKind<I>

where I: Interner,

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

Formats the value using the given formatter.

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

where I: Interner,

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

where I: Interner, Result<Canonical<I, Response<I>>, NoSolution>: TypeFoldable<I>, CandidateSource<I>: TypeFoldable<I>,

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

where I: Interner, Result<Canonical<I, Response<I>>, NoSolution>: TypeVisitable<I>, CandidateSource<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 ProbeKind<I>

where I: Interner,

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