Struct Binder &nbsp; Copy item path

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

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: ::BoundVarKinds, ) -> Binder<I, T>

impl<I, T> Binder<I, T>
where I: Interner,

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 map_bound_ref<F, U>(&self, f: F) -> Binder<I, U>
where U: TypeVisitable, F: FnOnce(&T) -> U,

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

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

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

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,

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 Binder<I, TraitRef>
where I: Interner,

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

pub fn def_id(&self) -> ::TraitId

pub fn to_host_effect_clause( self, cx: I, constness: BoundConstness, ) -> ::Clause

impl Binder<I, TraitPredicate>
where I: Interner,

pub fn def_id(self) -> ::TraitId

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

pub fn polarity(self) -> PredicatePolarity

impl Binder<I, ExistentialPredicate>
where I: Interner,

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

pub fn def_id(&self) -> ::TraitId

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

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 Binder<I, ExistentialProjection>
where I: Interner,

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

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

impl Binder<I, ProjectionPredicate>
where I: Interner,

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

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

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

pub fn item_def_id(&self) -> ::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 Binder<I, HostEffectPredicate>
where I: Interner,

pub fn def_id(self) -> ::TraitId

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

pub fn constness(self) -> BoundConstness

impl Binder<I, FnSig>
where I: Interner,

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

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

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

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

pub fn c_variadic(self) -> bool

pub fn safety(self) -> ::Safety

pub fn abi(self) -> ::Abi

pub fn is_fn_trait_compatible(&self) -> bool

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

impl Binder<I, FnSigTys>
where I: Interner,

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

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

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

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

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

Trait Implementations§

impl<I, T> Clone for Binder<I, T>
where I: Interner, T: Clone,

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

Returns a duplicate of the value. Read more

1.0.0 · Source§

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

Performs copy-assignment from source. Read more

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

impl<I, D> Decodable<D> for Binder<I, ExistentialPredicate>
where I: Interner, D: Decoder, ExistentialPredicate: TypeVisitable + Decodable<D>, ::BoundVarKinds: Decodable<D>,

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

impl<I, D> Decodable<D> for Binder<I, ExistentialTraitRef>
where I: Interner, D: Decoder, ExistentialTraitRef: TypeVisitable + Decodable<D>, ::BoundVarKinds: Decodable<D>,

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

impl<I, D> Decodable<D> for Binder<I, FnSig>
where I: Interner, D: Decoder, FnSig: TypeVisitable + Decodable<D>, ::BoundVarKinds: Decodable<D>,

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

impl<I, D> Decodable<D> for Binder<I, FnSigTys>
where I: Interner, D: Decoder, FnSigTys: TypeVisitable + Decodable<D>, ::BoundVarKinds: Decodable<D>,

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

impl<I, D> Decodable<D> for Binder<I, HostEffectPredicate>
where I: Interner, D: Decoder, HostEffectPredicate: TypeVisitable + Decodable<D>, ::BoundVarKinds: Decodable<D>,

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

impl<I, D> Decodable<D> for Binder<I, TraitPredicate>
where I: Interner, D: Decoder, TraitPredicate: TypeVisitable + Decodable<D>, ::BoundVarKinds: Decodable<D>,

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

impl<I, D> Decodable<D> for Binder<I, TraitRef>
where I: Interner, D: Decoder, TraitRef: TypeVisitable + Decodable<D>, ::BoundVarKinds: Decodable<D>,

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

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

impl<I, E> Encodable<E> for Binder<I, ExistentialPredicate>
where I: Interner, E: Encoder, ExistentialPredicate: Encodable<E>, ::BoundVarKinds: Encodable<E>,

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

impl<I, E> Encodable<E> for Binder<I, ExistentialTraitRef>
where I: Interner, E: Encoder, ExistentialTraitRef: Encodable<E>, ::BoundVarKinds: Encodable<E>,

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

impl<I, E> Encodable<E> for Binder<I, FnSig>
where I: Interner, E: Encoder, FnSig: Encodable<E>, ::BoundVarKinds: Encodable<E>,

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

impl<I, E> Encodable<E> for Binder<I, FnSigTys>
where I: Interner, E: Encoder, FnSigTys: Encodable<E>, ::BoundVarKinds: Encodable<E>,

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

impl<I, E> Encodable<E> for Binder<I, HostEffectPredicate>
where I: Interner, E: Encoder, HostEffectPredicate: Encodable<E>, ::BoundVarKinds: Encodable<E>,

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

impl<I, E> Encodable<E> for Binder<I, TraitPredicate>
where I: Interner, E: Encoder, TraitPredicate: Encodable<E>, ::BoundVarKinds: Encodable<E>,

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

impl<I, E> Encodable<E> for Binder<I, TraitRef>
where I: Interner, E: Encoder, TraitRef: Encodable<E>, ::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<'_>, CoroutineWitnessTypes<TyCtxt<'_>>>

type Result = [u8; 24]

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

type Result = [u8; 24]

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

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

Converts to this type from the input type.

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

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

Converts to this type from the input type.

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

impl<I, T, CTX> HashStable<CTX> for Binder<I, T>
where I: Interner, T: HashStable<CTX>, ::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, path: &mut Option<PathBuf>) -> DiagArgValue

Convert Self into a DiagArgValue suitable for rendering in a diagnostic. Read more

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

type Cache<V> = DefaultCache<Binder<TyCtxt<'tcx>, ExistentialTraitRef<TyCtxt<'tcx>>>, V>

The type of in-memory cache to use for queries with this key type. Read more

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 def_id_for_ty_in_cycle(&self) -> Option<DefId>

Used to detect when ADT def ids are used as keys in a cycle for better error reporting.

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

type Cache<V> = DefaultCache<Binder<TyCtxt<'tcx>, TraitRef<TyCtxt<'tcx>>>, V>

The type of in-memory cache to use for queries with this key type. Read more

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 def_id_for_ty_in_cycle(&self) -> Option<DefId>

Used to detect when ADT def ids are used as keys in a cycle for better error reporting.

impl<I, U, T> Lift for Binder<I, T>
where I: Interner, U: Interner, T: Lift, ::BoundVarKinds: Lift<U, Lifted = ::BoundVarKinds>,

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

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

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

1.0.0 · 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<'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, p: &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>>

fn print_with_bound_constness( self, constness: Option<BoundConstness>, ) -> Binder<TyCtxt<'tcx>, TraitPredPrintWithBoundConstness<'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 for Binder<I, T>
where I: Interner, T: Relate,

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

impl<'tcx> ToTrace<'tcx> for Binder<TyCtxt<'tcx>, ExistentialProjection<TyCtxt<'tcx>>>

fn to_trace( cause: &ObligationCause<'tcx>, a: Binder<TyCtxt<'tcx>, ExistentialProjection<TyCtxt<'tcx>>>, b: Binder<TyCtxt<'tcx>, ExistentialProjection<TyCtxt<'tcx>>>, ) -> TypeTrace<'tcx>

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

fn to_trace( cause: &ObligationCause<'tcx>, a: Binder<TyCtxt<'tcx>, ExistentialTraitRef<TyCtxt<'tcx>>>, b: Binder<TyCtxt<'tcx>, ExistentialTraitRef<TyCtxt<'tcx>>>, ) -> TypeTrace<'tcx>

impl<'tcx> ToTrace<'tcx> for Binder<TyCtxt<'tcx>, FnSig<TyCtxt<'tcx>>>

fn to_trace( cause: &ObligationCause<'tcx>, a: Binder<TyCtxt<'tcx>, FnSig<TyCtxt<'tcx>>>, b: Binder<TyCtxt<'tcx>, FnSig<TyCtxt<'tcx>>>, ) -> TypeTrace<'tcx>

impl<I, T> TypeFoldable for Binder<I, T>
where I: Interner, T: TypeFoldable,

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

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) -> Binder<I, T>
where F: TypeFolder,

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

impl<I, T> TypeSuperFoldable for Binder<I, T>
where I: Interner, T: TypeFoldable,

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

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) -> Binder<I, T>
where F: TypeFolder,

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

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

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

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

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

impl UpcastFrom<I, Binder<I, TraitRef>> for Binder<I, TraitPredicate>
where I: Interner,

fn upcast_from( from: Binder<I, TraitRef>, _tcx: I, ) -> Binder<I, TraitPredicate>

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>, HostEffectPredicate<TyCtxt<'tcx>>>> for Clause<'tcx>

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

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

fn upcast_from( from: Binder<TyCtxt<'tcx>, HostEffectPredicate<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 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,

Auto Trait Implementations§

impl<I, T> DynSend for Binder<I, T>
where T: DynSend, ::BoundVarKinds: DynSend,

impl<I, T> DynSync for Binder<I, T>
where T: DynSync, ::BoundVarKinds: DynSync,

impl<I, T> Freeze for Binder<I, T>
where T: Freeze, ::BoundVarKinds: Freeze,

impl<I, T> RefUnwindSafe for Binder<I, T>
where T: RefUnwindSafe, ::BoundVarKinds: RefUnwindSafe,

impl<I, T> Send for Binder<I, T>
where T: Send, ::BoundVarKinds: Send,

impl<I, T> Sync for Binder<I, T>
where T: Sync, ::BoundVarKinds: Sync,

impl<I, T> Unpin for Binder<I, T>
where T: Unpin, ::BoundVarKinds: Unpin,

impl<I, T> UnwindSafe for Binder<I, T>
where T: UnwindSafe, ::BoundVarKinds: UnwindSafe,

Blanket Implementations§

impl<T> Aligned for T

const ALIGN: Alignment

Alignment of Self.

impl<T> Any for T
where T: 'static + ?Sized,

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more

impl<T> AnyEq for T
where T: Any + PartialEq,

fn equals(&self, other: &(dyn Any + 'static)) -> bool

fn as_any(&self) -> &(dyn Any + 'static)

impl<'tcx, T> ArenaAllocatable<'tcx, IsCopy> for T
where T: Copy,

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

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

impl<'tcx, T> ArenaAllocatable<'tcx, IsCopy> for T
where T: Copy,

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

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

impl<T> Borrow<T> for T
where T: ?Sized,

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more

impl<T> BorrowMut<T> for T
where T: ?Sized,

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more

impl<T> CloneToUninit for T
where T: Clone,

unsafe fn clone_to_uninit(&self, dest: *mut u8)

🔬This is a nightly-only experimental API. (clone_to_uninit)

Performs copy-assignment from self to dest. Read more

impl<T, R> CollectAndApply<T, R> for T

fn collect_and_apply<I, F>(iter: I, f: F) -> R
where I: Iterator<Item = T>, F: FnOnce(&[T]) -> R,

Equivalent to f(&iter.collect::<Vec<_>>()).

type Output = R

impl<Tcx, T> DepNodeParams<Tcx> for T
where Tcx: DepContext, T: for<'a> HashStable<StableHashingContext<'a>> + Debug,

default fn fingerprint_style() -> FingerprintStyle

default fn to_fingerprint(&self, tcx: Tcx) -> Fingerprint

This method turns the parameters of a DepNodeConstructor into an opaque Fingerprint to be used in DepNode. Not all DepNodeParams support being turned into a Fingerprint (they don’t need to if the corresponding DepNode is anonymous).

default fn to_debug_str(&self, tcx: Tcx) -> String

default fn recover(_: Tcx, _: &DepNode) -> Option<T>

This method tries to recover the query key from the given DepNode, something which is needed when forcing DepNodes during red-green evaluation. The query system will only call this method if fingerprint_style() is not FingerprintStyle::Opaque. It is always valid to return None here, in which case incremental compilation will treat the query as having changed instead of forcing it.

impl<T> DynClone for T
where T: Clone,

fn __clone_box(&self, _: Private) -> *mut ()

impl<Q, K> Equivalent<K> for Q
where Q: Eq + ?Sized, K: Borrow<Q> + ?Sized,

fn equivalent(&self, key: &K) -> bool

Checks if this value is equivalent to the given key. Read more

impl<Q, K> Equivalent<K> for Q
where Q: Eq + ?Sized, K: Borrow<Q> + ?Sized,

fn equivalent(&self, key: &K) -> bool

Compare self to key and return true if they are equal.

impl<T> From<T> for T

fn from(t: T) -> T

Returns the argument unchanged.

impl<T> Instrument for T

fn instrument(self, span: Span) -> Instrumented<Self>

Instruments this type with the provided Span, returning an Instrumented wrapper. Read more

fn in_current_span(self) -> Instrumented<Self>

Instruments this type with the current Span, returning an Instrumented wrapper. Read more

impl<T, U> Into for T
where U: From<T>,

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

impl<T> IntoEither for T

fn into_either(self, into_left: bool) -> Either<Self, Self>

Converts self into a Left variant of Either<Self, Self> if into_left is true. Converts self into a Right variant of Either<Self, Self> otherwise. Read more

fn into_either_with<F>(self, into_left: F) -> Either<Self, Self>
where F: FnOnce(&Self) -> bool,

Converts self into a Left variant of Either<Self, Self> if into_left(&self) returns true. Converts self into a Right variant of Either<Self, Self> otherwise. Read more

impl IntoQueryParam for P

fn into_query_param(self) -> P

impl<'tcx, T> IsSuggestable<'tcx> for T
where T: TypeVisitable<TyCtxt<'tcx>> + TypeFoldable<TyCtxt<'tcx>>,

fn is_suggestable(self, tcx: TyCtxt<'tcx>, infer_suggestable: bool) -> bool

Whether this makes sense to suggest in a diagnostic. Read more

fn make_suggestable( self, tcx: TyCtxt<'tcx>, infer_suggestable: bool, placeholder: Option<Ty<'tcx>>, ) -> Option<T>

impl<T> MaybeResult<T> for T

type Error = !

fn from(_: Result<T, <T as MaybeResult<T>>::Error>) -> T

fn to_result(self) -> Result<T, <T as MaybeResult<T>>::Error>

impl<T> Pointable for T

const ALIGN: usize

The alignment of pointer.

type Init = T

The type for initializers.

unsafe fn init(init: <T as Pointable>::Init) -> usize

Initializes a with the given initializer. Read more

unsafe fn deref<'a>(ptr: usize) -> &'a T

Dereferences the given pointer. Read more

unsafe fn deref_mut<'a>(ptr: usize) -> &'a mut T

Mutably dereferences the given pointer. Read more

unsafe fn drop(ptr: usize)

Drops the object pointed to by the given pointer. Read more

impl<T> Same for T

type Output = T

Should always be Self

impl<T> ToOwned for T
where T: Clone,

type Owned = T

The resulting type after obtaining ownership.

fn to_owned(&self) -> T

Creates owned data from borrowed data, usually by cloning. Read more

fn clone_into(&self, target: &mut T)

Uses borrowed data to replace owned data, usually by cloning. Read more

impl<T> ToString for T
where T: Display + ?Sized,

fn to_string(&self) -> String

Converts the given value to a String. Read more

impl<T, U> TryFrom for T
where U: Into<T>,

type Error = Infallible

The type returned in the event of a conversion error.

fn try_from(value: U) -> Result<T, <T as TryFrom>::Error>

Performs the conversion.

impl<T, U> TryInto for T
where U: TryFrom<T>,

type Error = >::Error

The type returned in the event of a conversion error.

fn try_into(self) -> Result<U, >::Error>

Performs the conversion.

impl<I, T> TypeVisitableExt for T
where I: Interner, T: TypeVisitable,

fn has_type_flags(&self, flags: TypeFlags) -> bool

fn has_vars_bound_at_or_above(&self, binder: DebruijnIndex) -> bool

Returns true if self has any late-bound regions that are either bound by binder or bound by some binder outside of binder. If binder is ty::INNERMOST, this indicates whether there are any late-bound regions that appear free.

fn error_reported(&self) -> Result<(), ::ErrorGuaranteed>

fn has_vars_bound_above(&self, binder: DebruijnIndex) -> bool

Returns true if this type has any regions that escape binder (and hence are not bound by it).

fn has_escaping_bound_vars(&self) -> bool

Return true if this type has regions that are not a part of the type. For example, for<'a> fn(&'a i32) return false, while fn(&'a i32) would return true. The latter can occur when traversing through the former. Read more

fn has_aliases(&self) -> bool

fn has_opaque_types(&self) -> bool

fn has_coroutines(&self) -> bool

fn references_error(&self) -> bool

fn has_non_region_param(&self) -> bool

fn has_infer_regions(&self) -> bool

fn has_infer_types(&self) -> bool

fn has_non_region_infer(&self) -> bool

fn has_infer(&self) -> bool

fn has_placeholders(&self) -> bool

fn has_non_region_placeholders(&self) -> bool

fn has_param(&self) -> bool

fn has_free_regions(&self) -> bool

“Free” regions in this context means that it has any region that is not (a) erased or (b) late-bound.

fn has_erased_regions(&self) -> bool

fn has_erasable_regions(&self) -> bool

True if there are any un-erased free regions.

fn is_global(&self) -> bool

Indicates whether this value references only ‘global’ generic parameters that are the same regardless of what fn we are in. This is used for caching.

fn has_bound_regions(&self) -> bool

True if there are any late-bound regions

fn has_non_region_bound_vars(&self) -> bool

True if there are any late-bound non-region variables

fn has_bound_vars(&self) -> bool

True if there are any bound variables

fn still_further_specializable(&self) -> bool

Indicates whether this value still has parameters/placeholders/inference variables which could be replaced later, in a way that would change the results of impl specialization.

impl<I, T, U> Upcast<I, U> for T
where U: UpcastFrom<I, T>,

fn upcast(self, interner: I) -> U

impl<I, T> UpcastFrom<I, T> for T

fn upcast_from(from: T, _tcx: I) -> T

impl<V, T> VZip<V> for T
where V: MultiLane<T>,

fn vzip(self) -> V

impl<Tcx, T> Value<Tcx> for T
where Tcx: DepContext,

default fn from_cycle_error( tcx: Tcx, cycle_error: &CycleError, _guar: ErrorGuaranteed, ) -> T

impl<T> WithSubscriber for T

fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>
where S: Into<Dispatch>,

Attaches the provided Subscriber to this type, returning a WithDispatch wrapper. Read more

fn with_current_subscriber(self) -> WithDispatch<Self>

Attaches the current default Subscriber to this type, returning a WithDispatch wrapper. Read more