Type Alias rustc_middle::ty::sty::PolyTraitRef
source · pub type PolyTraitRef<'tcx> = Binder<'tcx, TraitRef<'tcx>>;
Aliased Type§
struct PolyTraitRef<'tcx> {
value: TraitRef<'tcx>,
bound_vars: &'tcx List<BoundVariableKind>,
}
Fields§
§value: TraitRef<'tcx>
§bound_vars: &'tcx List<BoundVariableKind>
Implementations§
source§impl<'tcx> PolyTraitRef<'tcx>
impl<'tcx> PolyTraitRef<'tcx>
source§impl<'tcx> Binder<'tcx, TraitRef<'tcx>>
impl<'tcx> Binder<'tcx, TraitRef<'tcx>>
pub fn print_only_trait_path( self ) -> Binder<'tcx, TraitRefPrintOnlyTraitPath<'tcx>>
source§impl<'tcx, T> Binder<'tcx, T>where
T: TypeVisitable<TyCtxt<'tcx>>,
impl<'tcx, T> Binder<'tcx, T>where T: TypeVisitable<TyCtxt<'tcx>>,
sourcepub fn dummy(value: T) -> Binder<'tcx, T>
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.
pub fn bind_with_vars( value: T, bound_vars: &'tcx List<BoundVariableKind> ) -> Binder<'tcx, T>
source§impl<'tcx, T> Binder<'tcx, T>
impl<'tcx, T> Binder<'tcx, T>
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
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 typeX
does not reference any regions
pub fn bound_vars(&self) -> &'tcx List<BoundVariableKind>
pub fn as_ref(&self) -> Binder<'tcx, &T>
pub fn as_deref(&self) -> Binder<'tcx, &T::Target>where T: Deref,
pub fn map_bound_ref_unchecked<F, U>(&self, f: F) -> Binder<'tcx, U>where F: FnOnce(&T) -> U,
pub fn map_bound_ref<F, U: TypeVisitable<TyCtxt<'tcx>>>( &self, f: F ) -> Binder<'tcx, U>where F: FnOnce(&T) -> U,
pub fn map_bound<F, U: TypeVisitable<TyCtxt<'tcx>>>( self, f: F ) -> Binder<'tcx, U>where F: FnOnce(T) -> U,
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>,
sourcepub fn rebind<U>(&self, value: U) -> Binder<'tcx, U>where
U: TypeVisitable<TyCtxt<'tcx>>,
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.
sourcepub fn no_bound_vars(self) -> Option<T>where
T: TypeVisitable<TyCtxt<'tcx>>,
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.)
sourcepub fn split<U, V, F>(self, f: F) -> (Binder<'tcx, U>, Binder<'tcx, V>)where
F: FnOnce(T) -> (U, V),
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.
Trait Implementations§
source§impl<'tcx, T: DebugWithInfcx<TyCtxt<'tcx>>> DebugWithInfcx<TyCtxt<'tcx>> for Binder<'tcx, T>
impl<'tcx, T: DebugWithInfcx<TyCtxt<'tcx>>> DebugWithInfcx<TyCtxt<'tcx>> for Binder<'tcx, T>
fn fmt<InfCtx: InferCtxtLike<TyCtxt<'tcx>>>( this: OptWithInfcx<'_, TyCtxt<'tcx>, InfCtx, &Self>, f: &mut Formatter<'_> ) -> Result
source§impl<'tcx, '__ctx, T> HashStable<StableHashingContext<'__ctx>> for Binder<'tcx, T>where
T: HashStable<StableHashingContext<'__ctx>>,
impl<'tcx, '__ctx, T> HashStable<StableHashingContext<'__ctx>> for Binder<'tcx, T>where T: HashStable<StableHashingContext<'__ctx>>,
fn hash_stable( &self, __hcx: &mut StableHashingContext<'__ctx>, __hasher: &mut StableHasher )
source§impl<'tcx, T> IntoDiagnosticArg for Binder<'tcx, T>where
T: IntoDiagnosticArg,
impl<'tcx, T> IntoDiagnosticArg for Binder<'tcx, T>where T: IntoDiagnosticArg,
fn into_diagnostic_arg(self) -> DiagnosticArgValue<'static>
source§impl<'tcx> Key for PolyTraitRef<'tcx>
impl<'tcx> Key for PolyTraitRef<'tcx>
type CacheSelector = DefaultCacheSelector<Binder<'tcx, TraitRef<'tcx>>>
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_adt_id(&self) -> Option<DefId>
source§impl<'tcx, T: Ord> Ord for Binder<'tcx, T>
impl<'tcx, T: Ord> Ord for Binder<'tcx, T>
1.21.0 · source§fn max(self, other: Self) -> Selfwhere
Self: Sized,
fn max(self, other: Self) -> Selfwhere Self: Sized,
source§impl<T: ParameterizedOverTcx> ParameterizedOverTcx for Binder<'static, T>
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>
impl<'tcx, T: PartialEq> PartialEq<Binder<'tcx, T>> for Binder<'tcx, T>
source§impl<'tcx, T: PartialOrd> PartialOrd<Binder<'tcx, T>> for Binder<'tcx, T>
impl<'tcx, T: PartialOrd> PartialOrd<Binder<'tcx, T>> for Binder<'tcx, T>
1.0.0 · source§fn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
self
and other
) and is used by the <=
operator. Read moresource§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>>,
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>>,
source§impl<'tcx, T: Relate<'tcx>> Relate<'tcx> for Binder<'tcx, T>
impl<'tcx, T: Relate<'tcx>> Relate<'tcx> for Binder<'tcx, T>
fn relate<R: TypeRelation<'tcx>>( relation: &mut R, a: Binder<'tcx, T>, b: Binder<'tcx, T> ) -> RelateResult<'tcx, Binder<'tcx, T>>
source§impl<'tcx> ToPredicate<'tcx, Binder<'tcx, TraitPredicate<'tcx>>> for Binder<'tcx, TraitRef<'tcx>>
impl<'tcx> ToPredicate<'tcx, Binder<'tcx, TraitPredicate<'tcx>>> for Binder<'tcx, TraitRef<'tcx>>
fn to_predicate(self, _: TyCtxt<'tcx>) -> PolyTraitPredicate<'tcx>
source§impl<'tcx> ToPredicate<'tcx, Clause<'tcx>> for Binder<'tcx, TraitRef<'tcx>>
impl<'tcx> ToPredicate<'tcx, Clause<'tcx>> for Binder<'tcx, TraitRef<'tcx>>
fn to_predicate(self, tcx: TyCtxt<'tcx>) -> Clause<'tcx>
source§impl<'tcx> ToPredicate<'tcx, Predicate<'tcx>> for Binder<'tcx, TraitRef<'tcx>>
impl<'tcx> ToPredicate<'tcx, Predicate<'tcx>> for Binder<'tcx, TraitRef<'tcx>>
fn to_predicate(self, tcx: TyCtxt<'tcx>) -> Predicate<'tcx>
source§impl<'tcx, T: TypeFoldable<TyCtxt<'tcx>>> TypeFoldable<TyCtxt<'tcx>> for Binder<'tcx, T>
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>
fn try_fold_with<F: FallibleTypeFolder<TyCtxt<'tcx>>>( self, folder: &mut F ) -> Result<Self, F::Error>
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<'tcx, T: TypeFoldable<TyCtxt<'tcx>>> TypeSuperFoldable<TyCtxt<'tcx>> for Binder<'tcx, T>
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>
fn try_super_fold_with<F: FallibleTypeFolder<TyCtxt<'tcx>>>( self, folder: &mut F ) -> Result<Self, F::Error>
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<'tcx, T: TypeVisitable<TyCtxt<'tcx>>> TypeSuperVisitable<TyCtxt<'tcx>> for Binder<'tcx, T>
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>
fn super_visit_with<V: TypeVisitor<TyCtxt<'tcx>>>( &self, visitor: &mut V ) -> ControlFlow<V::BreakTy>
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>
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>
fn visit_with<V: TypeVisitor<TyCtxt<'tcx>>>( &self, visitor: &mut V ) -> ControlFlow<V::BreakTy>
impl<'tcx, T: Copy> Copy for Binder<'tcx, T>
impl<'tcx, T: Eq> Eq for Binder<'tcx, T>
impl<'tcx, T> StructuralEq for Binder<'tcx, T>
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: 24 bytes