Struct rustc_middle::ty::generic_args::ArgFolder
source · struct ArgFolder<'a, 'tcx> {
tcx: TyCtxt<'tcx>,
args: &'a [GenericArg<'tcx>],
binders_passed: u32,
}
Fields§
§tcx: TyCtxt<'tcx>
§args: &'a [GenericArg<'tcx>]
§binders_passed: u32
Number of region binders we have passed through while doing the substitution
Implementations§
source§impl<'a, 'tcx> ArgFolder<'a, 'tcx>
impl<'a, 'tcx> ArgFolder<'a, 'tcx>
fn ty_for_param(&self, p: ParamTy, source_ty: Ty<'tcx>) -> Ty<'tcx>
fn type_param_expected( &self, p: ParamTy, ty: Ty<'tcx>, kind: GenericArgKind<'tcx> ) -> !
fn type_param_out_of_range(&self, p: ParamTy, ty: Ty<'tcx>) -> !
fn const_for_param(&self, p: ParamConst, source_ct: Const<'tcx>) -> Const<'tcx>
fn const_param_expected( &self, p: ParamConst, ct: Const<'tcx>, kind: GenericArgKind<'tcx> ) -> !
fn const_param_out_of_range(&self, p: ParamConst, ct: Const<'tcx>) -> !
sourcefn shift_vars_through_binders<T: TypeFoldable<TyCtxt<'tcx>>>(&self, val: T) -> T
fn shift_vars_through_binders<T: TypeFoldable<TyCtxt<'tcx>>>(&self, val: T) -> T
It is sometimes necessary to adjust the De Bruijn indices during substitution. This occurs when we are substituting a type with escaping bound vars into a context where we have passed through binders. That’s quite a mouthful. Let’s see an example:
type Func<A> = fn(A);
type MetaFunc = for<'a> fn(Func<&'a i32>);
The type MetaFunc
, when fully expanded, will be
for<'a> fn(fn(&'a i32))
// ^~ ^~ ^~~
// | | |
// | | DebruijnIndex of 2
// Binders
Here the 'a
lifetime is bound in the outer function, but appears as an argument of the
inner one. Therefore, that appearance will have a DebruijnIndex of 2, because we must skip
over the inner binder (remember that we count De Bruijn indices from 1). However, in the
definition of MetaFunc
, the binder is not visible, so the type &'a i32
will have a
De Bruijn index of 1. It’s only during the substitution that we can see we must increase the
depth by 1 to account for the binder that we passed through.
As a second example, consider this twist:
type FuncTuple<A> = (A,fn(A));
type MetaFuncTuple = for<'a> fn(FuncTuple<&'a i32>);
Here the final type will be:
for<'a> fn((&'a i32, fn(&'a i32)))
// ^~~ ^~~
// | |
// DebruijnIndex of 1 |
// DebruijnIndex of 2
As indicated in the diagram, here the same type &'a i32
is substituted once, but in the
first case we do not increase the De Bruijn index and in the second case we do. The reason
is that only in the second case have we passed through a fn binder.
fn shift_region_through_binders(&self, region: Region<'tcx>) -> Region<'tcx>
Trait Implementations§
source§impl<'a, 'tcx> TypeFolder<TyCtxt<'tcx>> for ArgFolder<'a, 'tcx>
impl<'a, 'tcx> TypeFolder<TyCtxt<'tcx>> for ArgFolder<'a, 'tcx>
fn interner(&self) -> TyCtxt<'tcx>
fn fold_binder<T: TypeFoldable<TyCtxt<'tcx>>>( &mut self, t: Binder<'tcx, T> ) -> Binder<'tcx, T>
fn fold_region(&mut self, r: Region<'tcx>) -> Region<'tcx>
fn fold_ty(&mut self, t: Ty<'tcx>) -> Ty<'tcx>
fn fold_const(&mut self, c: Const<'tcx>) -> Const<'tcx>
Auto Trait Implementations§
impl<'a, 'tcx> !RefUnwindSafe for ArgFolder<'a, 'tcx>
impl<'a, 'tcx> !Send for ArgFolder<'a, 'tcx>
impl<'a, 'tcx> !Sync for ArgFolder<'a, 'tcx>
impl<'a, 'tcx> Unpin for ArgFolder<'a, 'tcx>
impl<'a, 'tcx> !UnwindSafe for ArgFolder<'a, 'tcx>
Blanket Implementations§
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, R> CollectAndApply<T, R> for T
impl<T, R> CollectAndApply<T, R> for T
source§impl<I, F> FallibleTypeFolder<I> for Fwhere
I: Interner,
F: TypeFolder<I>,
impl<I, F> FallibleTypeFolder<I> for Fwhere I: Interner, F: TypeFolder<I>,
type Error = !
fn interner(&self) -> I
fn try_fold_binder<T>( &mut self, t: <I as Interner>::Binder<T> ) -> Result<<I as Interner>::Binder<T>, !>where T: TypeFoldable<I>, <I as Interner>::Binder<T>: TypeSuperFoldable<I>,
fn try_fold_ty( &mut self, t: <I as Interner>::Ty ) -> Result<<I as Interner>::Ty, !>where <I as Interner>::Ty: TypeSuperFoldable<I>,
fn try_fold_region( &mut self, r: <I as Interner>::Region ) -> Result<<I as Interner>::Region, !>
fn try_fold_const( &mut self, c: <I as Interner>::Const ) -> Result<<I as Interner>::Const, !>where <I as Interner>::Const: TypeSuperFoldable<I>,
fn try_fold_predicate( &mut self, p: <I as Interner>::Predicate ) -> Result<<I as Interner>::Predicate, !>where <I as Interner>::Predicate: TypeSuperFoldable<I>,
source§impl<P> IntoQueryParam<P> for P
impl<P> IntoQueryParam<P> for P
fn into_query_param(self) -> P
source§impl<T> MaybeResult<T> for T
impl<T> MaybeResult<T> for T
source§impl<'tcx, T> ToPredicate<'tcx, T> for T
impl<'tcx, T> ToPredicate<'tcx, T> for T
fn to_predicate(self, _tcx: TyCtxt<'tcx>) -> 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: &[QueryInfo], _guar: ErrorGuaranteed ) -> 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: 32 bytes