pub struct Binder<I, T>where
I: Interner,{
value: T,
bound_vars: <I as Interner>::BoundVarKinds,
}
Expand description
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§
source§impl<I, T> Binder<I, T>where
I: Interner,
T: TypeVisitable<I>,
impl<I, T> Binder<I, T>where
I: Interner,
T: TypeVisitable<I>,
sourcepub fn dummy(value: T) -> Binder<I, T>
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>
source§impl<I, T> Binder<I, T>where
I: Interner,
impl<I, T> Binder<I, T>where
I: Interner,
sourcepub fn skip_binder(self) -> T
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 typeX
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>
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>
sourcepub fn rebind<U>(&self, value: U) -> Binder<I, U>where
U: TypeVisitable<I>,
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.
sourcepub fn no_bound_vars(self) -> Option<T>where
T: TypeVisitable<I>,
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.)
sourcepub fn split<U, V, F>(self, f: F) -> (Binder<I, U>, Binder<I, V>)
pub fn split<U, V, F>(self, f: F) -> (Binder<I, U>, Binder<I, 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<I, T> Binder<I, T>where
I: Interner,
T: IntoIterator,
impl<I, T> Binder<I, T>where
I: Interner,
T: IntoIterator,
source§impl<I> Binder<I, TraitPredicate<I>>where
I: Interner,
impl<I> Binder<I, TraitPredicate<I>>where
I: Interner,
source§impl<I> Binder<I, ExistentialPredicate<I>>where
I: Interner,
impl<I> Binder<I, ExistentialPredicate<I>>where
I: Interner,
sourcepub fn with_self_ty(
&self,
cx: I,
self_ty: <I as Interner>::Ty,
) -> <I as Interner>::Clause
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).
source§impl<I> Binder<I, ExistentialTraitRef<I>>where
I: Interner,
impl<I> Binder<I, ExistentialTraitRef<I>>where
I: Interner,
pub fn def_id(&self) -> <I as Interner>::DefId
sourcepub fn with_self_ty(
&self,
cx: I,
self_ty: <I as Interner>::Ty,
) -> Binder<I, TraitRef<I>>
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.
source§impl<I> Binder<I, ExistentialProjection<I>>where
I: Interner,
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
source§impl<I> Binder<I, ProjectionPredicate<I>>where
I: Interner,
impl<I> Binder<I, ProjectionPredicate<I>>where
I: Interner,
sourcepub fn trait_def_id(&self, cx: I) -> <I as Interner>::DefId
pub fn trait_def_id(&self, cx: I) -> <I as Interner>::DefId
Returns the DefId
of the trait of the associated item being projected.
sourcepub fn required_poly_trait_ref(&self, cx: I) -> Binder<I, TraitRef<I>>
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>
sourcepub fn projection_def_id(&self) -> <I as Interner>::DefId
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
.
source§impl<I> Binder<I, FnSig<I>>where
I: Interner,
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
Trait Implementations§
source§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>,
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>,
source§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>,
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>,
source§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>,
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>,
source§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>,
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>,
source§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>,
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>,
source§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>,
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>,
source§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>,
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>,
source§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>,
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>,
source§impl<I, T, __CTX> HashStable<__CTX> for Binder<I, T>
impl<I, T, __CTX> HashStable<__CTX> for Binder<I, T>
fn hash_stable( &self, __hcx: &mut __CTX, __hasher: &mut StableHasher<SipHasher128>, )
source§impl<I, T> IntoDiagArg for Binder<I, T>where
I: Interner,
T: IntoDiagArg,
impl<I, T> IntoDiagArg for Binder<I, T>where
I: Interner,
T: IntoDiagArg,
fn into_diag_arg(self) -> DiagArgValue
source§impl<'tcx> Key for Binder<TyCtxt<'tcx>, ExistentialTraitRef<TyCtxt<'tcx>>>
impl<'tcx> Key for Binder<TyCtxt<'tcx>, ExistentialTraitRef<TyCtxt<'tcx>>>
type Cache<V> = DefaultCache<Binder<TyCtxt<'tcx>, ExistentialTraitRef<TyCtxt<'tcx>>>, V>
source§fn default_span(&self, tcx: TyCtxt<'_>) -> Span
fn default_span(&self, tcx: TyCtxt<'_>) -> Span
self
, what span should we use?source§fn key_as_def_id(&self) -> Option<DefId>
fn key_as_def_id(&self) -> Option<DefId>
fn ty_def_id(&self) -> Option<DefId>
source§impl<'tcx> Key for Binder<TyCtxt<'tcx>, TraitRef<TyCtxt<'tcx>>>
impl<'tcx> Key for Binder<TyCtxt<'tcx>, TraitRef<TyCtxt<'tcx>>>
type Cache<V> = DefaultCache<Binder<TyCtxt<'tcx>, TraitRef<TyCtxt<'tcx>>>, V>
source§fn default_span(&self, tcx: TyCtxt<'_>) -> Span
fn default_span(&self, tcx: TyCtxt<'_>) -> Span
self
, what span should we use?source§fn key_as_def_id(&self) -> Option<DefId>
fn key_as_def_id(&self) -> Option<DefId>
fn ty_def_id(&self) -> Option<DefId>
source§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>,
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>,
source§impl<T> ParameterizedOverTcx for Binder<TyCtxt<'static>, T>where
T: ParameterizedOverTcx,
impl<T> ParameterizedOverTcx for Binder<TyCtxt<'static>, T>where
T: ParameterizedOverTcx,
source§impl<I, T> PartialEq for Binder<I, T>
impl<I, T> PartialEq for Binder<I, T>
source§impl<'tcx> PrintPolyTraitPredicateExt<'tcx> for Binder<TyCtxt<'tcx>, TraitPredicate<TyCtxt<'tcx>>>
impl<'tcx> PrintPolyTraitPredicateExt<'tcx> for Binder<TyCtxt<'tcx>, TraitPredicate<TyCtxt<'tcx>>>
fn print_modifiers_and_trait_path( self, ) -> Binder<TyCtxt<'tcx>, TraitPredPrintModifiersAndPath<'tcx>>
source§impl<'tcx> PrintPolyTraitRefExt<'tcx> for Binder<TyCtxt<'tcx>, TraitRef<TyCtxt<'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>>
source§impl<'tcx> ToPolyTraitRef<'tcx> for Binder<TyCtxt<'tcx>, TraitPredicate<TyCtxt<'tcx>>>
impl<'tcx> ToPolyTraitRef<'tcx> for Binder<TyCtxt<'tcx>, TraitPredicate<TyCtxt<'tcx>>>
source§impl<'tcx> ToTrace<'tcx> for Binder<TyCtxt<'tcx>, ExistentialProjection<TyCtxt<'tcx>>>
impl<'tcx> ToTrace<'tcx> for Binder<TyCtxt<'tcx>, ExistentialProjection<TyCtxt<'tcx>>>
fn to_trace( cause: &ObligationCause<'tcx>, a_is_expected: bool, a: Binder<TyCtxt<'tcx>, ExistentialProjection<TyCtxt<'tcx>>>, b: Binder<TyCtxt<'tcx>, ExistentialProjection<TyCtxt<'tcx>>>, ) -> TypeTrace<'tcx>
source§impl<'tcx> ToTrace<'tcx> for Binder<TyCtxt<'tcx>, ExistentialTraitRef<TyCtxt<'tcx>>>
impl<'tcx> ToTrace<'tcx> for Binder<TyCtxt<'tcx>, ExistentialTraitRef<TyCtxt<'tcx>>>
fn to_trace( cause: &ObligationCause<'tcx>, a_is_expected: bool, a: Binder<TyCtxt<'tcx>, ExistentialTraitRef<TyCtxt<'tcx>>>, b: Binder<TyCtxt<'tcx>, ExistentialTraitRef<TyCtxt<'tcx>>>, ) -> TypeTrace<'tcx>
source§impl<I, T> TypeFoldable<I> for Binder<I, T>where
I: Interner,
T: TypeFoldable<I>,
impl<I, T> TypeFoldable<I> for Binder<I, T>where
I: Interner,
T: TypeFoldable<I>,
source§fn try_fold_with<F>(
self,
folder: &mut F,
) -> Result<Binder<I, T>, <F as FallibleTypeFolder<I>>::Error>where
F: FallibleTypeFolder<I>,
fn try_fold_with<F>(
self,
folder: &mut F,
) -> Result<Binder<I, T>, <F as FallibleTypeFolder<I>>::Error>where
F: FallibleTypeFolder<I>,
source§fn fold_with<F>(self, folder: &mut F) -> Selfwhere
F: TypeFolder<I>,
fn fold_with<F>(self, folder: &mut F) -> Selfwhere
F: TypeFolder<I>,
try_fold_with
for use with infallible
folders. Do not override this method, to ensure coherence with
try_fold_with
.source§impl<I, T> TypeSuperFoldable<I> for Binder<I, T>where
I: Interner,
T: TypeFoldable<I>,
impl<I, T> TypeSuperFoldable<I> for Binder<I, T>where
I: Interner,
T: TypeFoldable<I>,
source§fn try_super_fold_with<F>(
self,
folder: &mut F,
) -> Result<Binder<I, T>, <F as FallibleTypeFolder<I>>::Error>where
F: FallibleTypeFolder<I>,
fn try_super_fold_with<F>(
self,
folder: &mut F,
) -> Result<Binder<I, T>, <F as FallibleTypeFolder<I>>::Error>where
F: FallibleTypeFolder<I>,
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>,
fn super_fold_with<F>(self, folder: &mut F) -> Selfwhere
F: TypeFolder<I>,
try_super_fold_with
for use with
infallible folders. Do not override this method, to ensure coherence
with try_super_fold_with
.source§impl<I, T> TypeSuperVisitable<I> for Binder<I, T>where
I: Interner,
T: TypeVisitable<I>,
impl<I, T> TypeSuperVisitable<I> for Binder<I, T>where
I: Interner,
T: TypeVisitable<I>,
source§fn super_visit_with<V>(&self, visitor: &mut V) -> <V as TypeVisitor<I>>::Resultwhere
V: TypeVisitor<I>,
fn super_visit_with<V>(&self, visitor: &mut V) -> <V as TypeVisitor<I>>::Resultwhere
V: TypeVisitor<I>,
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<I, T> TypeVisitable<I> for Binder<I, T>where
I: Interner,
T: TypeVisitable<I>,
impl<I, T> TypeVisitable<I> for Binder<I, T>where
I: Interner,
T: TypeVisitable<I>,
source§fn visit_with<V>(&self, visitor: &mut V) -> <V as TypeVisitor<I>>::Resultwhere
V: TypeVisitor<I>,
fn visit_with<V>(&self, visitor: &mut V) -> <V as TypeVisitor<I>>::Resultwhere
V: TypeVisitor<I>,
source§impl<'tcx> UpcastFrom<TyCtxt<'tcx>, Binder<TyCtxt<'tcx>, ClauseKind<TyCtxt<'tcx>>>> for Clause<'tcx>
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>
source§impl<'tcx> UpcastFrom<TyCtxt<'tcx>, Binder<TyCtxt<'tcx>, ClauseKind<TyCtxt<'tcx>>>> for Predicate<'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>
source§impl<'tcx> UpcastFrom<TyCtxt<'tcx>, Binder<TyCtxt<'tcx>, OutlivesPredicate<TyCtxt<'tcx>, Region<'tcx>>>> for 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>
source§impl<'tcx> UpcastFrom<TyCtxt<'tcx>, Binder<TyCtxt<'tcx>, PredicateKind<TyCtxt<'tcx>>>> for 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>
source§impl<'tcx> UpcastFrom<TyCtxt<'tcx>, Binder<TyCtxt<'tcx>, ProjectionPredicate<TyCtxt<'tcx>>>> for Clause<'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>
source§impl<'tcx> UpcastFrom<TyCtxt<'tcx>, Binder<TyCtxt<'tcx>, ProjectionPredicate<TyCtxt<'tcx>>>> for Predicate<'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>
source§impl<'tcx> UpcastFrom<TyCtxt<'tcx>, Binder<TyCtxt<'tcx>, TraitPredicate<TyCtxt<'tcx>>>> for Clause<'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>
source§impl<'tcx> UpcastFrom<TyCtxt<'tcx>, Binder<TyCtxt<'tcx>, TraitPredicate<TyCtxt<'tcx>>>> for Predicate<'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>
source§impl<'tcx> UpcastFrom<TyCtxt<'tcx>, Binder<TyCtxt<'tcx>, TraitRef<TyCtxt<'tcx>>>> for Binder<TyCtxt<'tcx>, TraitPredicate<TyCtxt<'tcx>>>
impl<'tcx> UpcastFrom<TyCtxt<'tcx>, Binder<TyCtxt<'tcx>, TraitRef<TyCtxt<'tcx>>>> for Binder<TyCtxt<'tcx>, TraitPredicate<TyCtxt<'tcx>>>
source§impl<'tcx> UpcastFrom<TyCtxt<'tcx>, Binder<TyCtxt<'tcx>, TraitRef<TyCtxt<'tcx>>>> for Clause<'tcx>
impl<'tcx> UpcastFrom<TyCtxt<'tcx>, Binder<TyCtxt<'tcx>, TraitRef<TyCtxt<'tcx>>>> for Clause<'tcx>
source§impl<'tcx> UpcastFrom<TyCtxt<'tcx>, Binder<TyCtxt<'tcx>, TraitRef<TyCtxt<'tcx>>>> for Predicate<'tcx>
impl<'tcx> UpcastFrom<TyCtxt<'tcx>, Binder<TyCtxt<'tcx>, TraitRef<TyCtxt<'tcx>>>> for Predicate<'tcx>
source§impl<'tcx> Value<TyCtxt<'tcx>> for Binder<TyCtxt<'_>, FnSig<TyCtxt<'_>>>
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>
impl<I, T> Eq for Binder<I, T>
Auto Trait Implementations§
impl<I, T> Freeze for Binder<I, T>
impl<I, T> RefUnwindSafe for Binder<I, T>
impl<I, T> Send for Binder<I, T>
impl<I, T> Sync for Binder<I, T>
impl<I, T> Unpin for Binder<I, T>
impl<I, T> UnwindSafe for Binder<I, T>
Blanket Implementations§
source§impl<'tcx, T> ArenaAllocatable<'tcx, IsCopy> for Twhere
T: Copy,
impl<'tcx, T> ArenaAllocatable<'tcx, IsCopy> for Twhere
T: Copy,
fn allocate_on<'a>(self, arena: &'a Arena<'tcx>) -> &'a mut T
fn allocate_from_iter<'a>( arena: &'a Arena<'tcx>, iter: impl IntoIterator<Item = T>, ) -> &'a mut [T]
source§impl<'tcx, T> ArenaAllocatable<'tcx, IsCopy> for Twhere
T: Copy,
impl<'tcx, T> ArenaAllocatable<'tcx, IsCopy> for Twhere
T: Copy,
fn allocate_on<'a>(self, arena: &'a Arena<'tcx>) -> &'a mut T
fn allocate_from_iter<'a>( arena: &'a Arena<'tcx>, iter: impl IntoIterator<Item = T>, ) -> &'a mut [T]
source§impl<T> BorrowMut<T> for Twhere
T: ?Sized,
impl<T> BorrowMut<T> for Twhere
T: ?Sized,
source§fn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
source§impl<T> CloneToUninit for Twhere
T: Copy,
impl<T> CloneToUninit for Twhere
T: Copy,
source§unsafe fn clone_to_uninit(&self, dst: *mut T)
unsafe fn clone_to_uninit(&self, dst: *mut T)
clone_to_uninit
)source§impl<T> CloneToUninit for Twhere
T: Clone,
impl<T> CloneToUninit for Twhere
T: Clone,
source§default unsafe fn clone_to_uninit(&self, dst: *mut T)
default unsafe fn clone_to_uninit(&self, dst: *mut T)
clone_to_uninit
)source§impl<T, R> CollectAndApply<T, R> for T
impl<T, R> CollectAndApply<T, R> for T
source§impl<Tcx, T> DepNodeParams<Tcx> for T
impl<Tcx, T> DepNodeParams<Tcx> for T
default fn fingerprint_style() -> FingerprintStyle
source§default fn to_fingerprint(&self, tcx: Tcx) -> Fingerprint
default fn to_fingerprint(&self, tcx: Tcx) -> Fingerprint
default fn to_debug_str(&self, _: Tcx) -> String
source§default fn recover(_: Tcx, _: &DepNode) -> Option<T>
default fn recover(_: Tcx, _: &DepNode) -> Option<T>
DepNode
,
something which is needed when forcing DepNode
s 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.source§impl<Q, K> Equivalent<K> for Q
impl<Q, K> Equivalent<K> for Q
source§impl<Q, K> Equivalent<K> for Q
impl<Q, K> Equivalent<K> for Q
source§impl<Q, K> Equivalent<K> for Q
impl<Q, K> Equivalent<K> for Q
source§fn equivalent(&self, key: &K) -> bool
fn equivalent(&self, key: &K) -> bool
key
and return true
if they are equal.source§impl<T> Filterable for T
impl<T> Filterable for T
source§fn filterable(
self,
filter_name: &'static str,
) -> RequestFilterDataProvider<T, fn(_: DataRequest<'_>) -> bool>
fn filterable( self, filter_name: &'static str, ) -> RequestFilterDataProvider<T, fn(_: DataRequest<'_>) -> bool>
source§impl<T> Instrument for T
impl<T> Instrument for T
source§fn instrument(self, span: Span) -> Instrumented<Self>
fn instrument(self, span: Span) -> Instrumented<Self>
source§fn in_current_span(self) -> Instrumented<Self>
fn in_current_span(self) -> Instrumented<Self>
source§impl<T> IntoEither for T
impl<T> IntoEither for T
source§fn into_either(self, into_left: bool) -> Either<Self, Self>
fn into_either(self, into_left: bool) -> Either<Self, Self>
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 moresource§fn into_either_with<F>(self, into_left: F) -> Either<Self, Self>
fn into_either_with<F>(self, into_left: F) -> Either<Self, Self>
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 moresource§impl<P> IntoQueryParam<P> for P
impl<P> IntoQueryParam<P> for P
fn into_query_param(self) -> P
source§impl<'tcx, T> IsSuggestable<'tcx> for T
impl<'tcx, T> IsSuggestable<'tcx> for T
source§impl<T> MaybeResult<T> for T
impl<T> MaybeResult<T> for T
source§impl<I, T> TypeVisitableExt<I> for Twhere
I: Interner,
T: TypeVisitable<I>,
impl<I, T> TypeVisitableExt<I> for Twhere
I: Interner,
T: TypeVisitable<I>,
fn has_type_flags(&self, flags: TypeFlags) -> bool
source§fn has_vars_bound_at_or_above(&self, binder: DebruijnIndex) -> bool
fn has_vars_bound_at_or_above(&self, binder: DebruijnIndex) -> bool
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<(), <I as Interner>::ErrorGuaranteed>
source§fn has_vars_bound_above(&self, binder: DebruijnIndex) -> bool
fn has_vars_bound_above(&self, binder: DebruijnIndex) -> bool
true
if this type has any regions that escape binder
(and
hence are not bound by it).source§fn has_escaping_bound_vars(&self) -> bool
fn has_escaping_bound_vars(&self) -> bool
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 morefn has_aliases(&self) -> bool
fn has_inherent_projections(&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
source§fn has_free_regions(&self) -> bool
fn has_free_regions(&self) -> bool
fn has_erased_regions(&self) -> bool
source§fn has_erasable_regions(&self) -> bool
fn has_erasable_regions(&self) -> bool
source§fn is_global(&self) -> bool
fn is_global(&self) -> bool
source§fn has_bound_regions(&self) -> bool
fn has_bound_regions(&self) -> bool
source§fn has_non_region_bound_vars(&self) -> bool
fn has_non_region_bound_vars(&self) -> bool
source§fn has_bound_vars(&self) -> bool
fn has_bound_vars(&self) -> bool
source§fn still_further_specializable(&self) -> bool
fn still_further_specializable(&self) -> bool
impl
specialization.source§impl<I, T, U> Upcast<I, U> for Twhere
U: UpcastFrom<I, T>,
impl<I, T, U> Upcast<I, U> for Twhere
U: UpcastFrom<I, T>,
source§impl<I, T> UpcastFrom<I, T> for T
impl<I, T> UpcastFrom<I, T> for T
fn upcast_from(from: T, _tcx: I) -> T
source§impl<Tcx, T> Value<Tcx> for Twhere
Tcx: DepContext,
impl<Tcx, T> Value<Tcx> for Twhere
Tcx: DepContext,
default fn from_cycle_error( tcx: Tcx, cycle_error: &CycleError, _guar: ErrorGuaranteed, ) -> T
source§impl<T> WithSubscriber for T
impl<T> WithSubscriber for T
source§fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>
fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>
source§fn with_current_subscriber(self) -> WithDispatch<Self>
fn with_current_subscriber(self) -> WithDispatch<Self>
impl<'a, T> Captures<'a> for Twhere
T: ?Sized,
impl<T> ErasedDestructor for Twhere
T: 'static,
impl<T> MaybeSendSync for T
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.