Struct rustc_next_trait_solver::solve::inspect::State

pub struct State<I, T>
where
    I: Interner,
{
    pub var_values: CanonicalVarValues<I>,
    pub data: T,
}

Some data together with information about how they relate to the input of the canonical query.

This is only ever used as CanonicalState. Any type information in proof trees used mechanically has to be canonicalized as we otherwise leak inference variables from a nested InferCtxt.

Fields

var_values: CanonicalVarValues<I>

data: T

Trait Implementations

impl<I, T> Clone for State<I, T>

where I: Interner, T: Clone,

fn clone(&self) -> State<I, T>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<I, T> Debug for State<I, T>

where I: Interner, T: Debug,

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

Formats the value using the given formatter.

impl<I, T> Hash for State<I, T>

where I: Interner, T: Hash,

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

where __HIT: 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, T> PartialEq for State<I, T>

where I: Interner, T: PartialEq,

fn eq(&self, other: &State<I, T>) -> 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<I: Interner, T> ResponseT<I> for State<I, T>

fn var_values(&self) -> CanonicalVarValues<I>

impl<I, T> TypeFoldable<I> for State<I, T>

where I: Interner, CanonicalVarValues<I>: TypeFoldable<I>, T: TypeFoldable<I>,

fn try_fold_with<__F>( self, __folder: &mut __F, ) -> Result<State<I, T>, <__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, T> TypeVisitable<I> for State<I, T>

where I: Interner, CanonicalVarValues<I>: TypeVisitable<I>, T: 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, T> Copy for State<I, T>

where I: Interner, T: Copy,

impl<I, T> Eq for State<I, T>

where I: Interner, T: Eq,

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.