Struct PseudoCanonicalInput

pub struct PseudoCanonicalInput<'tcx, T> {
    pub typing_env: TypingEnv<'tcx>,
    pub value: T,
}

Similar to CanonicalInput, this carries the typing_mode and the environment necessary to do any kind of trait solving inside of nested queries.

Unlike proper canonicalization, this requires the param_env and the value to not contain anything local to the infcx of the caller, so we don’t actually canonicalize anything.

This should be created by using infcx.pseudo_canonicalize_query(param_env, value) or by using typing_env.as_query_input(value).

Fields

typing_env: TypingEnv<'tcx>

value: T

Trait Implementations

impl<'tcx, T: Clone> Clone for PseudoCanonicalInput<'tcx, T>

fn clone(&self) -> PseudoCanonicalInput<'tcx, T>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'tcx, T: Debug> Debug for PseudoCanonicalInput<'tcx, T>

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

Formats the value using the given formatter.

impl<'tcx, T: Hash> Hash for PseudoCanonicalInput<'tcx, T>

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

where T: HashStable<StableHashingContext<'__ctx>>,

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

impl<'tcx, T: Key> Key for PseudoCanonicalInput<'tcx, T>

type Cache<V> = DefaultCache<PseudoCanonicalInput<'tcx, T>, V>

fn default_span(&self, tcx: TyCtxt<'_>) -> Span

In the event that a cycle occurs, if no explicit span has been given for a query with key self, what span should we use?

fn ty_def_id(&self) -> Option<DefId>

fn key_as_def_id(&self) -> Option<DefId>

If the key is a DefId or DefId–equivalent, return that DefId. Otherwise, return None.

impl<'tcx, T: PartialEq> PartialEq for PseudoCanonicalInput<'tcx, T>

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

where T: TypeFoldable<TyCtxt<'tcx>>,

fn try_fold_with<__F: FallibleTypeFolder<TyCtxt<'tcx>>>( 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>(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, T> TypeVisitable<TyCtxt<'tcx>> for PseudoCanonicalInput<'tcx, T>

where T: TypeVisitable<TyCtxt<'tcx>>,

fn visit_with<__V: TypeVisitor<TyCtxt<'tcx>>>( &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<'tcx, T: Copy> Copy for PseudoCanonicalInput<'tcx, T>

impl<'tcx, T: Eq> Eq for PseudoCanonicalInput<'tcx, T>

impl<'tcx, T> StructuralPartialEq for PseudoCanonicalInput<'tcx, T>

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.