Trait TypeFolder

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

    // Provided methods
    fn fold_binder<T>(&mut self, t: Binder<I, T>) -> Binder<I, T>
       where T: TypeFoldable<I> { ... }
    fn fold_ty(&mut self, t: <I as Interner>::Ty) -> <I as Interner>::Ty { ... }
    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 { ... }
    fn fold_predicate(
        &mut self,
        p: <I as Interner>::Predicate,
    ) -> <I as Interner>::Predicate { ... }
}

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 cx(&self) -> I

Provided Methods

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

where T: TypeFoldable<I>,

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

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

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

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementations on Foreign Types

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>,

fn cx(&self) -> TyCtxt<'tcx>

fn fold_ty(&mut self, ty: Ty<'tcx>) -> Ty<'tcx>

fn fold_region(&mut self, r: Region<'tcx>) -> Region<'tcx>

fn fold_const(&mut self, ct: Const<'tcx>) -> Const<'tcx>

impl<D, I> TypeFolder<I> for Canonicalizer<'_, D, I>

where D: SolverDelegate<Interner = I>, I: Interner,

fn cx(&self) -> I

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

where T: TypeFoldable<I>,

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

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

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

impl<D, I> TypeFolder<I> for EagerResolver<'_, D, I>

where D: SolverDelegate<Interner = I>, I: Interner,

fn cx(&self) -> I

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

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

Implementors

impl<'a, 'b, 'tcx> TypeFolder<TyCtxt<'tcx>> for AssocTypeNormalizer<'a, 'b, 'tcx>

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

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

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

impl<'a, I> TypeFolder<I> for RegionFolder<'a, I>

where I: Interner,

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

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

impl<'tcx> TypeFolder<TyCtxt<'tcx>> for DeeplyNormalizeForDiagnosticsFolder<'_, 'tcx>

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

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

impl<'tcx> TypeFolder<TyCtxt<'tcx>> for PlaceholderReplacer<'_, 'tcx>