Trait rustc_middle::ty::TypeFolder

pub trait TypeFolder<I>: FallibleTypeFolder<I, Error = !>
where
    I: Interner,
{
    // Required method
    fn interner(&self) -> I;

    // Provided methods
    fn fold_binder<T>(
        &mut self,
        t: <I as Interner>::Binder<T>
    ) -> <I as Interner>::Binder<T>
       where T: TypeFoldable<I>,
             <I as Interner>::Binder<T>: TypeSuperFoldable<I> { ... }
    fn fold_ty(&mut self, t: <I as Interner>::Ty) -> <I as Interner>::Ty
       where <I as Interner>::Ty: TypeSuperFoldable<I> { ... }
    fn fold_region(
        &mut self,
        r: <I as Interner>::Region
    ) -> <I as Interner>::Region { ... }
    fn fold_const(
        &mut self,
        c: <I as Interner>::Const
    ) -> <I as Interner>::Const
       where <I as Interner>::Const: TypeSuperFoldable<I> { ... }
    fn fold_predicate(
        &mut self,
        p: <I as Interner>::Predicate
    ) -> <I as Interner>::Predicate
       where <I as Interner>::Predicate: TypeSuperFoldable<I> { ... }
}

This trait is implemented for every infallible folding traversal. There is a fold method defined for every type of interest. Each such method has a default that does an “identity” fold. Implementations of these methods often fall back to a super_fold_with method if the primary argument doesn’t satisfy a particular condition.

A blanket implementation of FallibleTypeFolder will defer to the infallible methods of this trait to ensure that the two APIs are coherent.

Required Methods

fn interner(&self) -> I

Provided Methods

fn fold_binder<T>( &mut self, t: <I as Interner>::Binder<T> ) -> <I as Interner>::Binder<T>

where T: TypeFoldable<I>, <I as Interner>::Binder<T>: TypeSuperFoldable<I>,

fn fold_ty(&mut self, t: <I as Interner>::Ty) -> <I as Interner>::Ty

where <I as Interner>::Ty: TypeSuperFoldable<I>,

fn fold_region(&mut self, r: <I as Interner>::Region) -> <I as Interner>::Region

fn fold_const(&mut self, c: <I as Interner>::Const) -> <I as Interner>::Const

where <I as Interner>::Const: TypeSuperFoldable<I>,

fn fold_predicate( &mut self, p: <I as Interner>::Predicate ) -> <I as Interner>::Predicate

where <I as Interner>::Predicate: TypeSuperFoldable<I>,

Object Safety

This trait is not object safe.

Implementors

impl<'a, 'tcx> TypeFolder<TyCtxt<'tcx>> for rustc_middle::ty::fold::RegionFolder<'a, 'tcx>

impl<'a, 'tcx> TypeFolder<TyCtxt<'tcx>> for ArgFolder<'a, 'tcx>

impl<'a, 'tcx> TypeFolder<TyCtxt<'tcx>> for rustc_middle::ty::print::pretty::RegionFolder<'a, 'tcx>

impl<'tcx> TypeFolder<TyCtxt<'tcx>> for RegionEraserVisitor<'tcx>

impl<'tcx> TypeFolder<TyCtxt<'tcx>> for Shifter<'tcx>

impl<'tcx> TypeFolder<TyCtxt<'tcx>> for NormalizeAfterErasingRegionsFolder<'tcx>

impl<'tcx> TypeFolder<TyCtxt<'tcx>> for ReverseMapper<'tcx>

impl<'tcx> TypeFolder<TyCtxt<'tcx>> for OpaqueTypeExpander<'tcx>

impl<'tcx> TypeFolder<TyCtxt<'tcx>> for WeakAliasTypeExpander<'tcx>

impl<'tcx, D> TypeFolder<TyCtxt<'tcx>> for BoundVarReplacer<'tcx, D>

where D: BoundVarReplacerDelegate<'tcx>,

impl<'tcx, F, G, H> TypeFolder<TyCtxt<'tcx>> for BottomUpFolder<'tcx, F, G, H>

where F: FnMut(Ty<'tcx>) -> Ty<'tcx>, G: FnMut(Region<'tcx>) -> Region<'tcx>, H: FnMut(Const<'tcx>) -> Const<'tcx>,