Struct CanonicalQueryInput

pub struct CanonicalQueryInput<I, V>
where
    I: Interner,
{
    pub canonical: Canonical<I, V>,
    pub typing_mode: TypingMode<I>,
}

Fields

canonical: Canonical<I, V>

typing_mode: TypingMode<I>

Trait Implementations

impl<I, V> Clone for CanonicalQueryInput<I, V>

where I: Interner, V: Clone,

fn clone(&self) -> CanonicalQueryInput<I, V>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<I, V> Debug for CanonicalQueryInput<I, V>

where I: Interner, V: Debug,

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

Formats the value using the given formatter.

impl<I, V, __D> Decodable<__D> for CanonicalQueryInput<I, V>

where I: Interner, __D: TyDecoder<I = I>, Canonical<I, V>: Decodable<__D>, TypingMode<I>: Decodable<__D>,

fn decode(__decoder: &mut __D) -> CanonicalQueryInput<I, V>

impl<I, V, __E> Encodable<__E> for CanonicalQueryInput<I, V>

where I: Interner, __E: TyEncoder<I = I>, Canonical<I, V>: Encodable<__E>, TypingMode<I>: Encodable<__E>,

fn encode(&self, __encoder: &mut __E)

impl<I, V> Hash for CanonicalQueryInput<I, V>

where I: Interner, V: Hash,

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, V, __CTX> HashStable<__CTX> for CanonicalQueryInput<I, V>

where I: Interner, Canonical<I, V>: HashStable<__CTX>, TypingMode<I>: HashStable<__CTX>,

fn hash_stable( &self, __hcx: &mut __CTX, __hasher: &mut StableHasher<SipHasher128>, )

impl<'tcx, T> Key for CanonicalQueryInput<TyCtxt<'tcx>, T>

where T: Clone,

Canonical query goals correspond to abstract trait operations that are not tied to any crate in particular.

type Cache<V> = DefaultCache<CanonicalQueryInput<TyCtxt<'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 key_as_def_id(&self) -> Option<DefId>

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

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

Used to detect when ADT def ids are used as keys in a cycle for better error reporting.

impl<I, V> PartialEq for CanonicalQueryInput<I, V>

where I: Interner, V: PartialEq,

fn eq(&self, __other: &CanonicalQueryInput<I, V>) -> 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, V> Copy for CanonicalQueryInput<I, V>

where I: Interner, V: Copy,

impl<I, V> Eq for CanonicalQueryInput<I, V>

where I: Interner, V: 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.