pub type PolyExistentialProjection<'tcx> = Binder<'tcx, ExistentialProjection<'tcx>>;

Aliased Type§

struct PolyExistentialProjection<'tcx> {
    value: ExistentialProjection<'tcx>,
    bound_vars: &'tcx List<BoundVariableKind>,
}

Fields§

§value: ExistentialProjection<'tcx>§bound_vars: &'tcx List<BoundVariableKind>

Implementations§

source§

impl<'tcx> PolyExistentialProjection<'tcx>

source

pub fn with_self_ty( &self, tcx: TyCtxt<'tcx>, self_ty: Ty<'tcx> ) -> PolyProjectionPredicate<'tcx>

source

pub fn item_def_id(&self) -> DefId

source§

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

source

pub fn dummy(value: T) -> Binder<'tcx, 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.

source

pub fn bind_with_vars( value: T, bound_vars: &'tcx List<BoundVariableKind> ) -> Binder<'tcx, T>

source§

impl<'tcx, T> Binder<'tcx, T>

source

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 replace_late_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
source

pub fn bound_vars(&self) -> &'tcx List<BoundVariableKind>

source

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

source

pub fn as_deref(&self) -> Binder<'tcx, &T::Target>where T: Deref,

source

pub fn map_bound_ref_unchecked<F, U>(&self, f: F) -> Binder<'tcx, U>where F: FnOnce(&T) -> U,

source

pub fn map_bound_ref<F, U: TypeVisitable<TyCtxt<'tcx>>>( &self, f: F ) -> Binder<'tcx, U>where F: FnOnce(&T) -> U,

source

pub fn map_bound<F, U: TypeVisitable<TyCtxt<'tcx>>>( self, f: F ) -> Binder<'tcx, U>where F: FnOnce(T) -> U,

source

pub fn try_map_bound<F, U: TypeVisitable<TyCtxt<'tcx>>, E>( self, f: F ) -> Result<Binder<'tcx, U>, E>where F: FnOnce(T) -> Result<U, E>,

source

pub fn rebind<U>(&self, value: U) -> Binder<'tcx, U>where U: TypeVisitable<TyCtxt<'tcx>>,

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.

source

pub fn no_bound_vars(self) -> Option<T>where T: TypeVisitable<TyCtxt<'tcx>>,

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.)

source

pub fn split<U, V, F>(self, f: F) -> (Binder<'tcx, U>, Binder<'tcx, V>)where F: FnOnce(T) -> (U, V),

Splits the contents into two things that share the same binder level as the original, returning two distinct binders.

f should consider bound regions at depth 1 to be free, and anything it produces with bound regions at depth 1 will be bound in the resulting return values.

source§

impl<'tcx, T: IntoIterator> Binder<'tcx, T>

source

pub fn iter(self) -> impl Iterator<Item = Binder<'tcx, T::Item>>

Trait Implementations§

source§

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

source§

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

Returns a copy of the value. Read more
1.0.0 · source§

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

Performs copy-assignment from source. Read more
source§

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

source§

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

Formats the value using the given formatter. Read more
source§

impl<'tcx, T: DebugWithInfcx<TyCtxt<'tcx>>> DebugWithInfcx<TyCtxt<'tcx>> for Binder<'tcx, T>

source§

fn fmt<InfCtx: InferCtxtLike<TyCtxt<'tcx>>>( this: OptWithInfcx<'_, TyCtxt<'tcx>, InfCtx, &Self>, f: &mut Formatter<'_> ) -> Result

source§

impl<'tcx> Display for PolyExistentialProjection<'tcx>

source§

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

Formats the value using the given formatter. Read more
source§

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

source§

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

Feeds this value into the given Hasher. Read more
1.3.0 · 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
source§

impl<'tcx, '__ctx, T> HashStable<StableHashingContext<'__ctx>> for Binder<'tcx, T>where T: HashStable<StableHashingContext<'__ctx>>,

source§

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

source§

impl<'tcx, T> IntoDiagnosticArg for Binder<'tcx, T>where T: IntoDiagnosticArg,

source§

impl<'tcx, '__lifted, T> Lift<'__lifted> for Binder<'tcx, T>where T: Lift<'__lifted>,

§

type Lifted = Binder<'__lifted, <T as Lift<'__lifted>>::Lifted>

source§

fn lift_to_tcx( self, __tcx: TyCtxt<'__lifted> ) -> Option<Binder<'__lifted, T::Lifted>>

source§

impl<'tcx, T: Ord> Ord for Binder<'tcx, T>

source§

fn cmp(&self, other: &Binder<'tcx, T>) -> Ordering

This method returns an Ordering between self and other. Read more
1.21.0 · source§

fn max(self, other: Self) -> Selfwhere Self: Sized,

Compares and returns the maximum of two values. Read more
1.21.0 · source§

fn min(self, other: Self) -> Selfwhere Self: Sized,

Compares and returns the minimum of two values. Read more
1.50.0 · source§

fn clamp(self, min: Self, max: Self) -> Selfwhere Self: Sized + PartialOrd<Self>,

Restrict a value to a certain interval. Read more
source§

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

§

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

source§

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

source§

fn eq(&self, other: &Binder<'tcx, T>) -> bool

This method tests for self and other values to be equal, and is used by ==.
1.0.0 · source§

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.
source§

impl<'tcx, T: PartialOrd> PartialOrd<Binder<'tcx, T>> for Binder<'tcx, T>

source§

fn partial_cmp(&self, other: &Binder<'tcx, T>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists. Read more
1.0.0 · source§

fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator. Read more
1.0.0 · source§

fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator. Read more
1.0.0 · source§

fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator. Read more
1.0.0 · source§

fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator. Read more
source§

impl<'tcx, T, P: PrettyPrinter<'tcx>> Print<'tcx, P> for Binder<'tcx, T>where T: Print<'tcx, P, Output = P, Error = P::Error> + TypeFoldable<TyCtxt<'tcx>>,

§

type Output = P

§

type Error = Error

source§

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

source§

impl<'tcx, T: Relate<'tcx>> Relate<'tcx> for Binder<'tcx, T>

source§

fn relate<R: TypeRelation<'tcx>>( relation: &mut R, a: Binder<'tcx, T>, b: Binder<'tcx, T> ) -> RelateResult<'tcx, Binder<'tcx, T>>

source§

impl<'tcx, T: TypeFoldable<TyCtxt<'tcx>>> TypeFoldable<TyCtxt<'tcx>> for Binder<'tcx, T>

source§

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

fn fold_with<F>(self, folder: &mut F) -> Selfwhere 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.
source§

impl<'tcx, T: TypeFoldable<TyCtxt<'tcx>>> TypeSuperFoldable<TyCtxt<'tcx>> for Binder<'tcx, T>

source§

fn try_super_fold_with<F: FallibleTypeFolder<TyCtxt<'tcx>>>( self, folder: &mut F ) -> Result<Self, F::Error>

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).
source§

fn super_fold_with<F>(self, folder: &mut F) -> Selfwhere 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.
source§

impl<'tcx, T: TypeVisitable<TyCtxt<'tcx>>> TypeSuperVisitable<TyCtxt<'tcx>> for Binder<'tcx, T>

source§

fn super_visit_with<V: TypeVisitor<TyCtxt<'tcx>>>( &self, visitor: &mut V ) -> ControlFlow<V::BreakTy>

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).
source§

impl<'tcx, T: TypeVisitable<TyCtxt<'tcx>>> TypeVisitable<TyCtxt<'tcx>> for Binder<'tcx, T>

source§

fn visit_with<V: TypeVisitor<TyCtxt<'tcx>>>( &self, visitor: &mut V ) -> ControlFlow<V::BreakTy>

The entry point for visiting. To visit a value t with a visitor v call: t.visit_with(v). Read more
source§

impl<'tcx, T: Copy> Copy for Binder<'tcx, T>

source§

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

source§

impl<'tcx, T> StructuralEq for Binder<'tcx, T>

source§

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

Layout§

Note: Most layout information is completely unstable and may even differ between compilations. The only exception is types with certain repr(...) attributes. Please see the Rust Reference's “Type Layout” chapter for details on type layout guarantees.

Size: 32 bytes