Struct rustc_middle::ty::fold::RegionFolder
source · pub struct RegionFolder<'a, 'tcx> {
tcx: TyCtxt<'tcx>,
current_index: DebruijnIndex,
fold_region_fn: &'a mut (dyn FnMut(Region<'tcx>, DebruijnIndex) -> Region<'tcx> + 'a),
}
Expand description
Folds over the substructure of a type, visiting its component types and all regions that occur free within it.
That is, Ty
can contain function or method types that bind
regions at the call site (ReLateBound
), and occurrences of
regions (aka “lifetimes”) that are bound within a type are not
visited by this folder; only regions that occur free will be
visited by fld_r
.
Fields
tcx: TyCtxt<'tcx>
current_index: DebruijnIndex
Stores the index of a binder just outside the stuff we have
visited. So this begins as INNERMOST; when we pass through a
binder, it is incremented (via shift_in
).
fold_region_fn: &'a mut (dyn FnMut(Region<'tcx>, DebruijnIndex) -> Region<'tcx> + 'a)
Callback invokes for each free region. The DebruijnIndex
points to the binder just outside the ones we have passed
through.
Implementations
sourceimpl<'a, 'tcx> RegionFolder<'a, 'tcx>
impl<'a, 'tcx> RegionFolder<'a, 'tcx>
pub fn new(
tcx: TyCtxt<'tcx>,
fold_region_fn: &'a mut dyn FnMut(Region<'tcx>, DebruijnIndex) -> Region<'tcx>
) -> RegionFolder<'a, 'tcx>
Trait Implementations
sourceimpl<'a, 'tcx> TypeFolder<'tcx> for RegionFolder<'a, 'tcx>
impl<'a, 'tcx> TypeFolder<'tcx> for RegionFolder<'a, 'tcx>
fn tcx<'b>(&'b self) -> TyCtxt<'tcx>
fn fold_binder<T: TypeFoldable<'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>
fn fold_unevaluated(&mut self, uv: Unevaluated<'tcx>) -> Unevaluated<'tcx>
fn fold_predicate(&mut self, p: Predicate<'tcx>) -> Predicate<'tcx>
fn fold_mir_const(&mut self, c: ConstantKind<'tcx>) -> ConstantKind<'tcx>
Auto Trait Implementations
impl<'a, 'tcx> !RefUnwindSafe for RegionFolder<'a, 'tcx>
impl<'a, 'tcx> !Send for RegionFolder<'a, 'tcx>
impl<'a, 'tcx> !Sync for RegionFolder<'a, 'tcx>
impl<'a, 'tcx> Unpin for RegionFolder<'a, 'tcx>where
'tcx: 'a,
impl<'a, 'tcx> !UnwindSafe for RegionFolder<'a, 'tcx>
Blanket Implementations
sourceimpl<T> BorrowMut<T> for Twhere
T: ?Sized,
impl<T> BorrowMut<T> for Twhere
T: ?Sized,
const: unstable · sourcefn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
sourceimpl<'tcx, F> FallibleTypeFolder<'tcx> for Fwhere
F: TypeFolder<'tcx>,
impl<'tcx, F> FallibleTypeFolder<'tcx> for Fwhere
F: TypeFolder<'tcx>,
type Error = !
fn tcx(&'a self) -> TyCtxt<'tcx>
fn try_fold_binder<T>(
&mut self,
t: Binder<'tcx, T>
) -> Result<Binder<'tcx, T>, !>where
T: TypeFoldable<'tcx>,
fn try_fold_ty(&mut self, t: Ty<'tcx>) -> Result<Ty<'tcx>, !>
fn try_fold_region(&mut self, r: Region<'tcx>) -> Result<Region<'tcx>, !>
fn try_fold_const(&mut self, c: Const<'tcx>) -> Result<Const<'tcx>, !>
fn try_fold_unevaluated(
&mut self,
c: Unevaluated<'tcx, Option<Promoted>>
) -> Result<Unevaluated<'tcx, Option<Promoted>>, !>
fn try_fold_predicate(
&mut self,
p: Predicate<'tcx>
) -> Result<Predicate<'tcx>, !>
fn try_fold_mir_const(
&mut self,
c: ConstantKind<'tcx>
) -> Result<ConstantKind<'tcx>, !>
sourceimpl<T, R> InternIteratorElement<T, R> for T
impl<T, R> InternIteratorElement<T, R> for T
type Output = R
fn intern_with<I, F>(iter: I, f: F) -> <T as InternIteratorElement<T, R>>::Outputwhere
I: Iterator<Item = T>,
F: FnOnce(&[T]) -> R,
sourceimpl<T> MaybeResult<T> for T
impl<T> MaybeResult<T> for T
sourceimpl<CTX, T> Value<CTX> for Twhere
CTX: DepContext,
impl<CTX, T> Value<CTX> for Twhere
CTX: DepContext,
default fn from_cycle_error(tcx: CTX) -> T
impl<'a, T> Captures<'a> for Twhere
T: ?Sized,
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