rustc_infer::infer::canonical

Type Alias Canonical

Source
pub type Canonical<'tcx, V> = Canonical<TyCtxt<'tcx>, V>;

Aliased Type§

struct Canonical<'tcx, V> {
    pub value: V,
    pub max_universe: UniverseIndex,
    pub variables: &'tcx RawList<(), CanonicalVarInfo<TyCtxt<'tcx>>>,
}

Fields§

§value: V§max_universe: UniverseIndex§variables: &'tcx RawList<(), CanonicalVarInfo<TyCtxt<'tcx>>>

Implementations

§

impl<I, V> Canonical<I, V>
where I: Interner,

pub fn unchecked_map<W>(self, map_op: impl FnOnce(V) -> W) -> Canonical<I, W>

Allows you to map the value of a canonical while keeping the same set of bound variables.

WARNING: This function is very easy to mis-use, hence the name! In particular, the new value W must use all the same type/region variables in precisely the same order as the original! (The ordering is defined by the TypeFoldable implementation of the type in question.)

An example of a correct use of this:

let a: Canonical<I, T> = ...;
let b: Canonical<I, (T,)> = a.unchecked_map(|v| (v, ));

An example of an incorrect use of this:

let a: Canonical<I, T> = ...;
let ty: Ty<I> = ...;
let b: Canonical<I, (T, Ty<I>)> = a.unchecked_map(|v| (v, ty));

Trait Implementations§

Source§

impl<'tcx, V> CanonicalExt<'tcx, V> for Canonical<'tcx, V>

Source§

fn instantiate( &self, tcx: TyCtxt<'tcx>, var_values: &CanonicalVarValues<'tcx>, ) -> V
where V: TypeFoldable<TyCtxt<'tcx>>,

Instantiate the wrapped value, replacing each canonical value with the value given in var_values.

Source§

fn instantiate_projected<T>( &self, tcx: TyCtxt<'tcx>, var_values: &CanonicalVarValues<'tcx>, projection_fn: impl FnOnce(&V) -> T, ) -> T
where T: TypeFoldable<TyCtxt<'tcx>>,

Allows one to apply a instantiation to some subset of self.value. Invoke projection_fn with self.value to get a value V that is expressed in terms of the same canonical variables bound in self (usually this extracts from subset of self). Apply the instantiation var_values to this value V, replacing each of the canonical variables.

Source§

impl<'tcx> ArenaAllocatable<'tcx> for Canonical<TyCtxt<'tcx>, QueryResponse<'tcx, ()>>

Source§

fn allocate_on( self, arena: &'tcx Arena<'tcx>, ) -> &'tcx mut Canonical<TyCtxt<'tcx>, QueryResponse<'tcx, ()>>

Source§

fn allocate_from_iter( arena: &'tcx Arena<'tcx>, iter: impl IntoIterator<Item = Canonical<TyCtxt<'tcx>, QueryResponse<'tcx, ()>>>, ) -> &'tcx mut [Canonical<TyCtxt<'tcx>, QueryResponse<'tcx, ()>>]

Source§

impl<'tcx> ArenaAllocatable<'tcx> for Canonical<TyCtxt<'tcx>, QueryResponse<'tcx, Binder<TyCtxt<'tcx>, FnSig<TyCtxt<'tcx>>>>>

Source§

fn allocate_on( self, arena: &'tcx Arena<'tcx>, ) -> &'tcx mut Canonical<TyCtxt<'tcx>, QueryResponse<'tcx, Binder<TyCtxt<'tcx>, FnSig<TyCtxt<'tcx>>>>>

Source§

fn allocate_from_iter( arena: &'tcx Arena<'tcx>, iter: impl IntoIterator<Item = Canonical<TyCtxt<'tcx>, QueryResponse<'tcx, Binder<TyCtxt<'tcx>, FnSig<TyCtxt<'tcx>>>>>>, ) -> &'tcx mut [Canonical<TyCtxt<'tcx>, QueryResponse<'tcx, Binder<TyCtxt<'tcx>, FnSig<TyCtxt<'tcx>>>>>]

Source§

impl<'tcx> ArenaAllocatable<'tcx> for Canonical<TyCtxt<'tcx>, QueryResponse<'tcx, Clause<'tcx>>>

Source§

fn allocate_on( self, arena: &'tcx Arena<'tcx>, ) -> &'tcx mut Canonical<TyCtxt<'tcx>, QueryResponse<'tcx, Clause<'tcx>>>

Source§

fn allocate_from_iter( arena: &'tcx Arena<'tcx>, iter: impl IntoIterator<Item = Canonical<TyCtxt<'tcx>, QueryResponse<'tcx, Clause<'tcx>>>>, ) -> &'tcx mut [Canonical<TyCtxt<'tcx>, QueryResponse<'tcx, Clause<'tcx>>>]

Source§

impl<'tcx> ArenaAllocatable<'tcx> for Canonical<TyCtxt<'tcx>, QueryResponse<'tcx, DropckOutlivesResult<'tcx>>>

Source§

fn allocate_on( self, arena: &'tcx Arena<'tcx>, ) -> &'tcx mut Canonical<TyCtxt<'tcx>, QueryResponse<'tcx, DropckOutlivesResult<'tcx>>>

Source§

fn allocate_from_iter( arena: &'tcx Arena<'tcx>, iter: impl IntoIterator<Item = Canonical<TyCtxt<'tcx>, QueryResponse<'tcx, DropckOutlivesResult<'tcx>>>>, ) -> &'tcx mut [Canonical<TyCtxt<'tcx>, QueryResponse<'tcx, DropckOutlivesResult<'tcx>>>]

Source§

impl<'tcx> ArenaAllocatable<'tcx> for Canonical<TyCtxt<'tcx>, QueryResponse<'tcx, FnSig<TyCtxt<'tcx>>>>

Source§

fn allocate_on( self, arena: &'tcx Arena<'tcx>, ) -> &'tcx mut Canonical<TyCtxt<'tcx>, QueryResponse<'tcx, FnSig<TyCtxt<'tcx>>>>

Source§

fn allocate_from_iter( arena: &'tcx Arena<'tcx>, iter: impl IntoIterator<Item = Canonical<TyCtxt<'tcx>, QueryResponse<'tcx, FnSig<TyCtxt<'tcx>>>>>, ) -> &'tcx mut [Canonical<TyCtxt<'tcx>, QueryResponse<'tcx, FnSig<TyCtxt<'tcx>>>>]

Source§

impl<'tcx> ArenaAllocatable<'tcx> for Canonical<TyCtxt<'tcx>, QueryResponse<'tcx, NormalizationResult<'tcx>>>

Source§

fn allocate_on( self, arena: &'tcx Arena<'tcx>, ) -> &'tcx mut Canonical<TyCtxt<'tcx>, QueryResponse<'tcx, NormalizationResult<'tcx>>>

Source§

fn allocate_from_iter( arena: &'tcx Arena<'tcx>, iter: impl IntoIterator<Item = Canonical<TyCtxt<'tcx>, QueryResponse<'tcx, NormalizationResult<'tcx>>>>, ) -> &'tcx mut [Canonical<TyCtxt<'tcx>, QueryResponse<'tcx, NormalizationResult<'tcx>>>]

Source§

impl<'tcx> ArenaAllocatable<'tcx> for Canonical<TyCtxt<'tcx>, QueryResponse<'tcx, Ty<'tcx>>>

Source§

fn allocate_on( self, arena: &'tcx Arena<'tcx>, ) -> &'tcx mut Canonical<TyCtxt<'tcx>, QueryResponse<'tcx, Ty<'tcx>>>

Source§

fn allocate_from_iter( arena: &'tcx Arena<'tcx>, iter: impl IntoIterator<Item = Canonical<TyCtxt<'tcx>, QueryResponse<'tcx, Ty<'tcx>>>>, ) -> &'tcx mut [Canonical<TyCtxt<'tcx>, QueryResponse<'tcx, Ty<'tcx>>>]

Source§

impl<'tcx> ArenaAllocatable<'tcx> for Canonical<TyCtxt<'tcx>, QueryResponse<'tcx, Vec<OutlivesBound<'tcx>>>>

Source§

fn allocate_on( self, arena: &'tcx Arena<'tcx>, ) -> &'tcx mut Canonical<TyCtxt<'tcx>, QueryResponse<'tcx, Vec<OutlivesBound<'tcx>>>>

Source§

fn allocate_from_iter( arena: &'tcx Arena<'tcx>, iter: impl IntoIterator<Item = Canonical<TyCtxt<'tcx>, QueryResponse<'tcx, Vec<OutlivesBound<'tcx>>>>>, ) -> &'tcx mut [Canonical<TyCtxt<'tcx>, QueryResponse<'tcx, Vec<OutlivesBound<'tcx>>>>]

§

impl<I, V> Clone for Canonical<I, V>
where I: Interner, V: Clone,

§

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

Returns a copy of the value. Read more
Source§

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

Performs copy-assignment from source. Read more
§

impl<I, V> Debug for Canonical<I, V>
where I: Interner, V: Debug,

§

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

Formats the value using the given formatter. Read more
§

impl<I, V, __D> Decodable<__D> for Canonical<I, V>
where I: Interner, __D: TyDecoder<I = I>, V: Decodable<__D>, <I as Interner>::CanonicalVars: Decodable<__D>,

§

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

§

impl<I, V> Display for Canonical<I, V>
where I: Interner, V: Display,

§

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

Formats the value using the given formatter. Read more
§

impl<I, V, __E> Encodable<__E> for Canonical<I, V>
where I: Interner, __E: TyEncoder<I = I>, V: Encodable<__E>, <I as Interner>::CanonicalVars: Encodable<__E>,

§

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

§

impl<I, V> Hash for Canonical<I, V>
where I: Interner, V: Hash,

§

fn hash<__H>(&self, __state: &mut __H)
where __H: Hasher,

Feeds this value into the given Hasher. Read more
Source§

fn hash_slice<H>(data: &[Self], state: &mut H)
where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher. Read more
§

impl<I, V, __CTX> HashStable<__CTX> for Canonical<I, V>
where I: Interner, V: HashStable<__CTX>, <I as Interner>::CanonicalVars: HashStable<__CTX>,

§

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

Source§

impl<'tcx> IsIdentity for Canonical<TyCtxt<'tcx>, UserType<'tcx>>

Source§

fn is_identity(&self) -> bool

Returns true if this represents the generic parameters of the form [?0, ?1, ?2], i.e., each thing is mapped to a canonical variable with the same index.

§

impl<I, V> PartialEq for Canonical<I, V>
where I: Interner, V: PartialEq,

§

fn eq(&self, __other: &Canonical<I, V>) -> bool

Tests for self and other values to be equal, and is used by ==.
Source§

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> TypeFoldable<I> for Canonical<I, V>

§

fn try_fold_with<__F>( self, __folder: &mut __F, ) -> Result<Canonical<I, V>, <__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). Read more
§

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, V> TypeVisitable<I> for Canonical<I, V>

§

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). Read more
§

impl<I, V> Copy for Canonical<I, V>
where I: Interner, V: Copy,

§

impl<I, V> Eq for Canonical<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.