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 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 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 self_ty(&self) -> Binder<I, I::Ty>

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

pub fn with_self_ty(&self, cx: I, self_ty: I::Ty) -> I::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).

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

pub fn with_self_ty(&self, cx: I, self_ty: I::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.

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

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

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

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

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

pub fn item_def_id(&self) -> I::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.

pub fn is_fn_trait_compatible(&self) -> bool

Trait Implementations

impl<I> Clone for UnsafeBinderInner<I>

where I: Interner,

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

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: TyDecoder<I = I>> 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: TyEncoder<I = I>> Encodable<E> for UnsafeBinderInner<I>

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

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

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> 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: Interner, __CTX> HashStable<__CTX> for UnsafeBinderInner<I>

where Binder<I, I::Ty>: HashStable<__CTX>,

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

impl<I, J> Lift<J> for UnsafeBinderInner<I>

where I: Interner, J: Interner, Binder<I, I::Ty>: Lift<J, Lifted = Binder<J, J::Ty>>,

type Lifted = UnsafeBinderInner<J>

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

impl<I> PartialEq for UnsafeBinderInner<I>

where I: Interner,

fn eq(&self, __other: &Self) -> 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> 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

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

impl<I> Copy for UnsafeBinderInner<I>

where I: Interner,

impl<I> Eq for UnsafeBinderInner<I>

where I: Interner,

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.