Struct UnsafeBinderInner 

pub struct UnsafeBinderInner<I: Interner>(Binder<I, I::Ty>);

Tuple Fields

0: Binder<I, I::Ty>

Methods from Deref<Target = Binder<I, I::Ty>>

pub fn skip_binder(self) -> T

Returns the value contained inside of this for<'a>. Accessing generic args in the returned value is generally incorrect.

Please read https://rustc-dev-guide.rust-lang.org/ty_module/instantiating_binders.html before using this function. 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 does not reference any generic arguments, e.g. a DefId, or when you’re making sure you only pass the value to things which can handle escaping bound vars.

See existing uses of .skip_binder() in rustc_trait_selection::traits::select or rustc_next_trait_solver for examples.

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

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

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

where T: Deref,

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

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

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

where F: FnOnce(T) -> U,

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

where F: FnOnce(T) -> U,

There are some uses of map_bound which are incredibly hot and trivially correct. Only use this if this significantly improves the performance of builds with debug assertions.

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

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

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

Trait Implementations

impl<I> Clone for UnsafeBinderInner<I>

where I: Interner,

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<I> Copy for UnsafeBinderInner<I>

where I: Interner,

impl<I: Interner> Debug for UnsafeBinderInner<I>

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

Formats the value using the given formatter.

impl<I: Interner, D: Decoder> Decodable<D> for UnsafeBinderInner<I>

where I::Ty: TypeVisitable<I> + Decodable<D>, I::BoundVarKinds: Decodable<D>,

fn decode(decoder: &mut D) -> Self

impl<I: Interner> Deref for UnsafeBinderInner<I>

type Target = Binder<I, <I as Interner>::Ty>

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<I: Interner, E: Encoder> Encodable<E> for UnsafeBinderInner<I>

where I::Ty: Encodable<E>, I::BoundVarKinds: Encodable<E>,

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

impl<I: Interner> Eq for UnsafeBinderInner<I>

impl<I: Interner> From<Binder<I, <I as Interner>::Ty>> for UnsafeBinderInner<I>

fn from(value: Binder<I, I::Ty>) -> Self

Converts to this type from the input type.

impl<I: Interner> From<UnsafeBinderInner<I>> for Binder<I, I::Ty>

fn from(value: UnsafeBinderInner<I>) -> Self

Converts to this type from the input type.

impl<I: Interner, __V> GenericTypeVisitable<__V> for UnsafeBinderInner<I>

where Binder<I, I::Ty>: GenericTypeVisitable<__V>,

fn generic_visit_with(&self, __visitor: &mut __V)

impl<I> Hash for UnsafeBinderInner<I>

where I: Interner,

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<I, J> Lift<J> for UnsafeBinderInner<I>

where J: Interner, I: LiftInto<J> + Interner,

type Lifted = UnsafeBinderInner<J>

fn lift_to_interner(self, interner: J) -> Self::Lifted

impl<I> PartialEq for UnsafeBinderInner<I>

where I: Interner,

fn eq(&self, __other: &Self) -> bool

Equality operator ==.

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

Inequality operator !=.

impl<I: Interner> StableHash for UnsafeBinderInner<I>

where Binder<I, I::Ty>: StableHash,

fn stable_hash<__Hcx: StableHashCtxt>( &self, __hcx: &mut __Hcx, __hasher: &mut StableHasher, )

impl<I> TypeFoldable<I> for UnsafeBinderInner<I>

where I: Interner, Binder<I, I::Ty>: TypeFoldable<I>,

fn try_fold_with<__F: FallibleTypeFolder<I>>( 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: TypeFolder<I>>(self, __folder: &mut __F) -> Self

The entry point for folding. To fold a value t with a folder f call: t.fold_with(f).

impl<I> TypeVisitable<I> for UnsafeBinderInner<I>

where I: Interner, Binder<I, I::Ty>: TypeVisitable<I>,

fn visit_with<__V: TypeVisitor<I>>(&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).

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.