Struct rustc_infer::infer::canonical::ir::Binder

pub struct Binder<I, T>
where
    I: Interner,
{
    value: T,
    bound_vars: <I as Interner>::BoundVarKinds,
}

Binder is a binder for higher-ranked lifetimes or types. It is part of the compiler’s representation for things like for<'a> Fn(&'a isize) (which would be represented by the type PolyTraitRef == Binder<I, TraitRef>). Note that when we instantiate, erase, or otherwise “discharge” these bound vars, we change the type from Binder<I, T> to just T (see e.g., liberate_late_bound_regions).

Decodable and Encodable are implemented for Binder<T> using the impl_binder_encode_decode! macro.

Fields

value: T

bound_vars: <I as Interner>::BoundVarKinds

Implementations

impl<I, T> Binder<I, T>

where I: Interner, T: TypeVisitable<I>,

pub fn dummy(value: T) -> Binder<I, T>

Wraps value in a binder, asserting that value does not contain any bound vars that would be bound by the binder. This is commonly used to ‘inject’ a value T into a different binding level.

pub fn bind_with_vars( value: T, bound_vars: <I as Interner>::BoundVarKinds, ) -> Binder<I, T>

impl<I, T> Binder<I, T>

where I: Interner,

pub fn skip_binder(self) -> T

Skips the binder and returns the “bound” value. This is a risky thing to do because it’s easy to get confused about De Bruijn indices and the like. It is usually better to discharge the binder using no_bound_vars or instantiate_bound_regions or something like that. skip_binder is only valid when you are either extracting data that has nothing to do with bound vars, you are doing some sort of test that does not involve bound regions, or you are being very careful about your depth accounting.

Some examples where skip_binder is reasonable:

• extracting the DefId from a PolyTraitRef;
• comparing the self type of a PolyTraitRef to see if it is equal to a type parameter X, since the type X does not reference any regions

pub fn bound_vars(&self) -> <I as Interner>::BoundVarKinds

pub fn as_ref(&self) -> Binder<I, &T>

pub fn as_deref(&self) -> Binder<I, &<T as Deref>::Target>

where T: Deref,

pub fn map_bound_ref<F, U>(&self, f: F) -> Binder<I, U>

where U: TypeVisitable<I>, F: FnOnce(&T) -> U,

pub fn map_bound<F, U>(self, f: F) -> Binder<I, U>

where U: TypeVisitable<I>, F: FnOnce(T) -> U,

pub fn try_map_bound<F, U, E>(self, f: F) -> Result<Binder<I, U>, E>

where U: TypeVisitable<I>, F: FnOnce(T) -> Result<U, E>,

pub fn rebind<U>(&self, value: U) -> Binder<I, U>

where U: TypeVisitable<I>,

Wraps a value in a binder, using the same bound variables as the current Binder. This should not be used if the new value changes the bound variables. Note: the (old or new) value itself does not necessarily need to name all the bound variables.

This currently doesn’t do anything different than bind, because we don’t actually track bound vars. However, semantically, it is different because bound vars aren’t allowed to change here, whereas they are in bind. This may be (debug) asserted in the future.

pub fn no_bound_vars(self) -> Option<T>

where T: TypeVisitable<I>,

Unwraps and returns the value within, but only if it contains no bound vars at all. (In other words, if this binder – and indeed any enclosing binder – doesn’t bind anything at all.) Otherwise, returns None.

(One could imagine having a method that just unwraps a single binder, but permits late-bound vars bound by enclosing binders, but that would require adjusting the debruijn indices, and given the shallow binding structure we often use, would not be that useful.)

impl<I, T> Binder<I, Option<T>>

where I: Interner,

pub fn transpose(self) -> Option<Binder<I, T>>

impl<I, T> Binder<I, T>

where I: Interner, T: IntoIterator,

pub fn iter(self) -> impl Iterator<Item = Binder<I, <T as IntoIterator>::Item>>

impl<I> Binder<I, TraitRef<I>>

where I: Interner,

pub fn self_ty(&self) -> Binder<I, <I as Interner>::Ty>

pub fn def_id(&self) -> <I as Interner>::DefId

impl<I> Binder<I, TraitPredicate<I>>

where I: Interner,

pub fn def_id(self) -> <I as Interner>::DefId

pub fn self_ty(self) -> Binder<I, <I as Interner>::Ty>

pub fn polarity(self) -> PredicatePolarity

impl<I> Binder<I, ExistentialPredicate<I>>

where I: Interner,

pub fn with_self_ty( &self, cx: I, self_ty: <I as Interner>::Ty, ) -> <I as Interner>::Clause

Given an existential predicate like ?Self: PartialEq<u32> (e.g., derived from dyn PartialEq<u32>), and a concrete type self_ty, returns a full predicate where the existentially quantified variable ?Self has been replaced with self_ty (e.g., self_ty: PartialEq<u32>, in our example).

impl<I> Binder<I, ExistentialTraitRef<I>>

where I: Interner,

pub fn def_id(&self) -> <I as Interner>::DefId

pub fn with_self_ty( &self, cx: I, self_ty: <I as Interner>::Ty, ) -> Binder<I, TraitRef<I>>

Object types don’t have a self type specified. Therefore, when we convert the principal trait-ref into a normal trait-ref, you must give some self type. A common choice is mk_err() or some placeholder type.

impl<I> Binder<I, ExistentialProjection<I>>

where I: Interner,

pub fn with_self_ty( &self, cx: I, self_ty: <I as Interner>::Ty, ) -> Binder<I, ProjectionPredicate<I>>

pub fn item_def_id(&self) -> <I as Interner>::DefId

impl<I> Binder<I, ProjectionPredicate<I>>

where I: Interner,

pub fn trait_def_id(&self, cx: I) -> <I as Interner>::DefId

Returns the DefId of the trait of the associated item being projected.

pub fn required_poly_trait_ref(&self, cx: I) -> Binder<I, TraitRef<I>>

Get the trait ref required for this projection to be well formed. Note that for generic associated types the predicates of the associated type also need to be checked.

pub fn term(&self) -> Binder<I, <I as Interner>::Term>

pub fn projection_def_id(&self) -> <I as Interner>::DefId

The DefId of the TraitItem for the associated type.

Note that this is not the DefId of the TraitRef containing this associated type, which is in tcx.associated_item(projection_def_id()).container.

impl<I> Binder<I, FnSig<I>>

where I: Interner,

pub fn inputs(self) -> Binder<I, <I as Interner>::FnInputTys>

pub fn input(self, index: usize) -> Binder<I, <I as Interner>::Ty>

pub fn inputs_and_output(self) -> Binder<I, <I as Interner>::Tys>

pub fn output(self) -> Binder<I, <I as Interner>::Ty>

pub fn c_variadic(self) -> bool

pub fn safety(self) -> <I as Interner>::Safety

pub fn abi(self) -> <I as Interner>::Abi

pub fn is_fn_trait_compatible(&self) -> bool

pub fn split(self) -> (Binder<I, FnSigTys<I>>, FnHeader<I>)

impl<I> Binder<I, FnSigTys<I>>

where I: Interner,

pub fn with(self, hdr: FnHeader<I>) -> Binder<I, FnSig<I>>

pub fn inputs(self) -> Binder<I, <I as Interner>::FnInputTys>

pub fn input(self, index: usize) -> Binder<I, <I as Interner>::Ty>

pub fn inputs_and_output(self) -> Binder<I, <I as Interner>::Tys>

pub fn output(self) -> Binder<I, <I as Interner>::Ty>

Trait Implementations

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

where I: Interner, T: Clone,

fn clone(&self) -> Binder<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 Binder<I, T>

where I: Interner, T: Debug,

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

Formats the value using the given formatter.

impl<I, D> Decodable<D> for Binder<I, ExistentialPredicate<I>>

where I: Interner, D: TyDecoder<I = I>, ExistentialPredicate<I>: TypeVisitable<I> + Decodable<D>, <I as Interner>::BoundVarKinds: Decodable<D>,

fn decode(decoder: &mut D) -> Binder<I, ExistentialPredicate<I>>

impl<I, D> Decodable<D> for Binder<I, ExistentialTraitRef<I>>

where I: Interner, D: TyDecoder<I = I>, ExistentialTraitRef<I>: TypeVisitable<I> + Decodable<D>, <I as Interner>::BoundVarKinds: Decodable<D>,

fn decode(decoder: &mut D) -> Binder<I, ExistentialTraitRef<I>>

impl<I, D> Decodable<D> for Binder<I, FnSig<I>>

where I: Interner, D: TyDecoder<I = I>, FnSig<I>: TypeVisitable<I> + Decodable<D>, <I as Interner>::BoundVarKinds: Decodable<D>,

fn decode(decoder: &mut D) -> Binder<I, FnSig<I>>

impl<I, D> Decodable<D> for Binder<I, FnSigTys<I>>

where I: Interner, D: TyDecoder<I = I>, FnSigTys<I>: TypeVisitable<I> + Decodable<D>, <I as Interner>::BoundVarKinds: Decodable<D>,

fn decode(decoder: &mut D) -> Binder<I, FnSigTys<I>>

impl<I, D> Decodable<D> for Binder<I, TraitPredicate<I>>

where I: Interner, D: TyDecoder<I = I>, TraitPredicate<I>: TypeVisitable<I> + Decodable<D>, <I as Interner>::BoundVarKinds: Decodable<D>,

fn decode(decoder: &mut D) -> Binder<I, TraitPredicate<I>>

impl<I, D> Decodable<D> for Binder<I, TraitRef<I>>

where I: Interner, D: TyDecoder<I = I>, TraitRef<I>: TypeVisitable<I> + Decodable<D>, <I as Interner>::BoundVarKinds: Decodable<D>,

fn decode(decoder: &mut D) -> Binder<I, TraitRef<I>>

impl<I, T> Display for Binder<I, T>

where I: Interner + IrPrint<Binder<I, T>>,

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

Formats the value using the given formatter.

impl<I, E> Encodable<E> for Binder<I, ExistentialPredicate<I>>

where I: Interner, E: TyEncoder<I = I>, ExistentialPredicate<I>: Encodable<E>, <I as Interner>::BoundVarKinds: Encodable<E>,

fn encode(&self, e: &mut E)

impl<I, E> Encodable<E> for Binder<I, ExistentialTraitRef<I>>

where I: Interner, E: TyEncoder<I = I>, ExistentialTraitRef<I>: Encodable<E>, <I as Interner>::BoundVarKinds: Encodable<E>,

fn encode(&self, e: &mut E)

impl<I, E> Encodable<E> for Binder<I, FnSig<I>>

where I: Interner, E: TyEncoder<I = I>, FnSig<I>: Encodable<E>, <I as Interner>::BoundVarKinds: Encodable<E>,

fn encode(&self, e: &mut E)

impl<I, E> Encodable<E> for Binder<I, FnSigTys<I>>

where I: Interner, E: TyEncoder<I = I>, FnSigTys<I>: Encodable<E>, <I as Interner>::BoundVarKinds: Encodable<E>,

fn encode(&self, e: &mut E)

impl<I, E> Encodable<E> for Binder<I, TraitPredicate<I>>

where I: Interner, E: TyEncoder<I = I>, TraitPredicate<I>: Encodable<E>, <I as Interner>::BoundVarKinds: Encodable<E>,

fn encode(&self, e: &mut E)

impl<I, E> Encodable<E> for Binder<I, TraitRef<I>>

where I: Interner, E: TyEncoder<I = I>, TraitRef<I>: Encodable<E>, <I as Interner>::BoundVarKinds: Encodable<E>,

fn encode(&self, e: &mut E)

impl EraseType for Binder<TyCtxt<'_>, &RawList<(), Ty<'_>>>

type Result = [u8; 16]

impl EraseType for Binder<TyCtxt<'_>, FnSig<TyCtxt<'_>>>

type Result = [u8; 24]

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

where I: Interner, T: 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, T, __CTX> HashStable<__CTX> for Binder<I, T>

where I: Interner, T: HashStable<__CTX>, <I as Interner>::BoundVarKinds: HashStable<__CTX>,

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

impl<I, T> IntoDiagArg for Binder<I, T>

where I: Interner, T: IntoDiagArg,

fn into_diag_arg(self) -> DiagArgValue

impl<'tcx> Key for Binder<TyCtxt<'tcx>, ExistentialTraitRef<TyCtxt<'tcx>>>

type Cache<V> = DefaultCache<Binder<TyCtxt<'tcx>, ExistentialTraitRef<TyCtxt<'tcx>>>, 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 ty_def_id(&self) -> Option<DefId>

impl<'tcx> Key for Binder<TyCtxt<'tcx>, TraitRef<TyCtxt<'tcx>>>

type Cache<V> = DefaultCache<Binder<TyCtxt<'tcx>, TraitRef<TyCtxt<'tcx>>>, 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 ty_def_id(&self) -> Option<DefId>

impl<I, U, T> Lift<U> for Binder<I, T>

where I: Interner, U: Interner, T: Lift<U>, <I as Interner>::BoundVarKinds: Lift<U, Lifted = <U as Interner>::BoundVarKinds>,

type Lifted = Binder<U, <T as Lift<U>>::Lifted>

fn lift_to_interner(self, cx: U) -> Option<Binder<U, <T as Lift<U>>::Lifted>>

impl<T> ParameterizedOverTcx for Binder<TyCtxt<'static>, T>

where T: ParameterizedOverTcx,

type Value<'tcx> = Binder<TyCtxt<'tcx>, <T as ParameterizedOverTcx>::Value<'tcx>>

impl<I, T> PartialEq for Binder<I, T>

where I: Interner, T: PartialEq,

fn eq(&self, __other: &Binder<I, 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, P> Print<'tcx, P> for Binder<TyCtxt<'tcx>, T>

where P: PrettyPrinter<'tcx>, T: Print<'tcx, P> + TypeFoldable<TyCtxt<'tcx>>,

fn print(&self, cx: &mut P) -> Result<(), Error>

impl<'tcx> PrintPolyTraitPredicateExt<'tcx> for Binder<TyCtxt<'tcx>, TraitPredicate<TyCtxt<'tcx>>>

fn print_modifiers_and_trait_path( self, ) -> Binder<TyCtxt<'tcx>, TraitPredPrintModifiersAndPath<'tcx>>

impl<'tcx> PrintPolyTraitRefExt<'tcx> for Binder<TyCtxt<'tcx>, TraitRef<TyCtxt<'tcx>>>

fn print_only_trait_path( self, ) -> Binder<TyCtxt<'tcx>, TraitRefPrintOnlyTraitPath<'tcx>>

fn print_trait_sugared(self) -> Binder<TyCtxt<'tcx>, TraitRefPrintSugared<'tcx>>

impl<I, T> Relate<I> for Binder<I, T>

where I: Interner, T: Relate<I>,

fn relate<R>( relation: &mut R, a: Binder<I, T>, b: Binder<I, T>, ) -> Result<Binder<I, T>, TypeError<I>>

where R: TypeRelation<I>,

impl<'tcx> ToPolyTraitRef<'tcx> for Binder<TyCtxt<'tcx>, TraitPredicate<TyCtxt<'tcx>>>

fn to_poly_trait_ref(&self) -> Binder<TyCtxt<'tcx>, TraitRef<TyCtxt<'tcx>>>

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

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

fn try_fold_with<F>( self, folder: &mut F, ) -> Result<Binder<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> TypeSuperFoldable<I> for Binder<I, T>

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

fn try_super_fold_with<F>( self, folder: &mut F, ) -> Result<Binder<I, T>, <F as FallibleTypeFolder<I>>::Error>

where F: FallibleTypeFolder<I>,

Provides a default fold for a recursive type of interest. This should only be called within TypeFolder methods, when a non-custom traversal is desired for the value of the type of interest passed to that method. For example, in MyFolder::try_fold_ty(ty), it is valid to call ty.try_super_fold_with(self), but any other folding should be done with xyz.try_fold_with(self).

fn super_fold_with<F>(self, folder: &mut F) -> Self

where F: TypeFolder<I>,

A convenient alternative to try_super_fold_with for use with infallible folders. Do not override this method, to ensure coherence with try_super_fold_with.

impl<I, T> TypeSuperVisitable<I> for Binder<I, T>

where I: Interner, T: TypeVisitable<I>,

fn super_visit_with<V>(&self, visitor: &mut V) -> <V as TypeVisitor<I>>::Result

where V: TypeVisitor<I>,

Provides a default visit for a recursive type of interest. This should only be called within TypeVisitor methods, when a non-custom traversal is desired for the value of the type of interest passed to that method. For example, in MyVisitor::visit_ty(ty), it is valid to call ty.super_visit_with(self), but any other visiting should be done with xyz.visit_with(self).

impl<I, T> TypeVisitable<I> for Binder<I, T>

where I: Interner, 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<'tcx> UpcastFrom<TyCtxt<'tcx>, Binder<TyCtxt<'tcx>, ClauseKind<TyCtxt<'tcx>>>> for Clause<'tcx>

fn upcast_from( from: Binder<TyCtxt<'tcx>, ClauseKind<TyCtxt<'tcx>>>, tcx: TyCtxt<'tcx>, ) -> Clause<'tcx>

impl<'tcx> UpcastFrom<TyCtxt<'tcx>, Binder<TyCtxt<'tcx>, ClauseKind<TyCtxt<'tcx>>>> for Predicate<'tcx>

fn upcast_from( from: Binder<TyCtxt<'tcx>, ClauseKind<TyCtxt<'tcx>>>, tcx: TyCtxt<'tcx>, ) -> Predicate<'tcx>

impl<'tcx> UpcastFrom<TyCtxt<'tcx>, Binder<TyCtxt<'tcx>, OutlivesPredicate<TyCtxt<'tcx>, Region<'tcx>>>> for Predicate<'tcx>

fn upcast_from( from: Binder<TyCtxt<'tcx>, OutlivesPredicate<TyCtxt<'tcx>, Region<'tcx>>>, tcx: TyCtxt<'tcx>, ) -> Predicate<'tcx>

impl<'tcx> UpcastFrom<TyCtxt<'tcx>, Binder<TyCtxt<'tcx>, PredicateKind<TyCtxt<'tcx>>>> for Predicate<'tcx>

fn upcast_from( from: Binder<TyCtxt<'tcx>, PredicateKind<TyCtxt<'tcx>>>, tcx: TyCtxt<'tcx>, ) -> Predicate<'tcx>

impl<'tcx> UpcastFrom<TyCtxt<'tcx>, Binder<TyCtxt<'tcx>, ProjectionPredicate<TyCtxt<'tcx>>>> for Clause<'tcx>

fn upcast_from( from: Binder<TyCtxt<'tcx>, ProjectionPredicate<TyCtxt<'tcx>>>, tcx: TyCtxt<'tcx>, ) -> Clause<'tcx>

impl<'tcx> UpcastFrom<TyCtxt<'tcx>, Binder<TyCtxt<'tcx>, ProjectionPredicate<TyCtxt<'tcx>>>> for Predicate<'tcx>

fn upcast_from( from: Binder<TyCtxt<'tcx>, ProjectionPredicate<TyCtxt<'tcx>>>, tcx: TyCtxt<'tcx>, ) -> Predicate<'tcx>

impl<'tcx> UpcastFrom<TyCtxt<'tcx>, Binder<TyCtxt<'tcx>, TraitPredicate<TyCtxt<'tcx>>>> for Clause<'tcx>

fn upcast_from( from: Binder<TyCtxt<'tcx>, TraitPredicate<TyCtxt<'tcx>>>, tcx: TyCtxt<'tcx>, ) -> Clause<'tcx>

impl<'tcx> UpcastFrom<TyCtxt<'tcx>, Binder<TyCtxt<'tcx>, TraitPredicate<TyCtxt<'tcx>>>> for Predicate<'tcx>

fn upcast_from( from: Binder<TyCtxt<'tcx>, TraitPredicate<TyCtxt<'tcx>>>, tcx: TyCtxt<'tcx>, ) -> Predicate<'tcx>

impl<'tcx> UpcastFrom<TyCtxt<'tcx>, Binder<TyCtxt<'tcx>, TraitRef<TyCtxt<'tcx>>>> for Binder<TyCtxt<'tcx>, TraitPredicate<TyCtxt<'tcx>>>

fn upcast_from( from: Binder<TyCtxt<'tcx>, TraitRef<TyCtxt<'tcx>>>, _tcx: TyCtxt<'tcx>, ) -> Binder<TyCtxt<'tcx>, TraitPredicate<TyCtxt<'tcx>>>

impl<'tcx> UpcastFrom<TyCtxt<'tcx>, Binder<TyCtxt<'tcx>, TraitRef<TyCtxt<'tcx>>>> for Clause<'tcx>

fn upcast_from( from: Binder<TyCtxt<'tcx>, TraitRef<TyCtxt<'tcx>>>, tcx: TyCtxt<'tcx>, ) -> Clause<'tcx>

impl<'tcx> UpcastFrom<TyCtxt<'tcx>, Binder<TyCtxt<'tcx>, TraitRef<TyCtxt<'tcx>>>> for Predicate<'tcx>

fn upcast_from( from: Binder<TyCtxt<'tcx>, TraitRef<TyCtxt<'tcx>>>, tcx: TyCtxt<'tcx>, ) -> Predicate<'tcx>

impl<'tcx> Value<TyCtxt<'tcx>> for Binder<TyCtxt<'_>, FnSig<TyCtxt<'_>>>

fn from_cycle_error( tcx: TyCtxt<'tcx>, cycle_error: &CycleError, guar: ErrorGuaranteed, ) -> Binder<TyCtxt<'_>, FnSig<TyCtxt<'_>>>

impl<I, T> Copy for Binder<I, T>

where I: Interner, T: Copy,

impl<I, T> Eq for Binder<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.