Trait TypeFoldable

Source

pub trait TypeFoldable<I>: TypeVisitable<I> + Clonewhere
    I: Interner,{
    // Required methods
    fn try_fold_with<F>(
        self,
        folder: &mut F,
    ) -> Result<Self, <F as FallibleTypeFolder<I>>::Error>
       where F: FallibleTypeFolder<I>;
    fn fold_with<F>(self, folder: &mut F) -> Self
       where F: TypeFolder<I>;
}

Expand description

This trait is implemented for every type that can be folded, providing the skeleton of the traversal.

To implement this conveniently, use the derive macro located in rustc_macros.

This trait is a sub-trait of TypeVisitable. This is because many TypeFolder instances use the methods in TypeVisitableExt while folding, which means in practice almost every foldable type needs to also be visitable. (However, there are some types that are visitable without being foldable.)

Required Methods§

Source

fn try_fold_with<F>( self, folder: &mut F, ) -> Result<Self, <F as FallibleTypeFolder>::Error>
where F: FallibleTypeFolder,

The entry point for folding. To fold a value t with a folder f call: t.try_fold_with(f).

For most types, this just traverses the value, calling try_fold_with on each field/element.

For types of interest (such as Ty), the implementation of this method calls a folder method specifically for that type (such as F::try_fold_ty). This is where control transfers from TypeFoldable to FallibleTypeFolder.

Source

fn fold_with<F>(self, folder: &mut F) -> Self
where F: TypeFolder,

The entry point for folding. To fold a value t with a folder f call: t.fold_with(f).

For most types, this just traverses the value, calling fold_with on each field/element.

For types of interest (such as Ty), the implementation of this method calls a folder method specifically for that type (such as F::fold_ty). This is where control transfers from TypeFoldable to TypeFolder.

Same as TypeFoldable::try_fold_with, but not fallible. Make sure to keep the behavior in sync across functions.

Dyn Compatibility§

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety".

TypeFoldable

Trait TypeFoldable Copy item path

Required Methods§

fn try_fold_with<F>( self, folder: &mut F, ) -> Result<Self, <F as FallibleTypeFolder<I>>::Error>where F: FallibleTypeFolder<I>,

fn fold_with<F>(self, folder: &mut F) -> Selfwhere F: TypeFolder<I>,

Dyn Compatibility§

Implementations on Foreign Types§

impl<'tcx, O> TypeFoldable<TyCtxt<'tcx>> for AssertKind<O>where O: TypeFoldable<TyCtxt<'tcx>>,

fn try_fold_with<__F>( self, __folder: &mut __F, ) -> Result<AssertKind<O>, <__F as FallibleTypeFolder<TyCtxt<'tcx>>>::Error>where __F: FallibleTypeFolder<TyCtxt<'tcx>>,

fn fold_with<__F>(self, __folder: &mut __F) -> AssertKind<O>where __F: TypeFolder<TyCtxt<'tcx>>,

impl<'tcx, T> TypeFoldable<TyCtxt<'tcx>> for ClearCrossCrate<T>where T: TypeFoldable<TyCtxt<'tcx>>,

fn try_fold_with<__F>( self, __folder: &mut __F, ) -> Result<ClearCrossCrate<T>, <__F as FallibleTypeFolder<TyCtxt<'tcx>>>::Error>where __F: FallibleTypeFolder<TyCtxt<'tcx>>,

fn fold_with<__F>(self, __folder: &mut __F) -> ClearCrossCrate<T>where __F: TypeFolder<TyCtxt<'tcx>>,

impl<'tcx, T> TypeFoldable<TyCtxt<'tcx>> for ParamEnvAnd<'tcx, T>where T: TypeFoldable<TyCtxt<'tcx>>,

fn try_fold_with<__F>( self, __folder: &mut __F, ) -> Result<ParamEnvAnd<'tcx, T>, <__F as FallibleTypeFolder<TyCtxt<'tcx>>>::Error>where __F: FallibleTypeFolder<TyCtxt<'tcx>>,

fn fold_with<__F>(self, __folder: &mut __F) -> ParamEnvAnd<'tcx, T>where __F: TypeFolder<TyCtxt<'tcx>>,

impl<'tcx, T> TypeFoldable<TyCtxt<'tcx>> for PseudoCanonicalInput<'tcx, T>where T: TypeFoldable<TyCtxt<'tcx>>,

fn try_fold_with<__F>( self, __folder: &mut __F, ) -> Result<PseudoCanonicalInput<'tcx, T>, <__F as FallibleTypeFolder<TyCtxt<'tcx>>>::Error>where __F: FallibleTypeFolder<TyCtxt<'tcx>>,

fn fold_with<__F>(self, __folder: &mut __F) -> PseudoCanonicalInput<'tcx, T>where __F: TypeFolder<TyCtxt<'tcx>>,

impl<'tcx, T> TypeFoldable<TyCtxt<'tcx>> for Spanned<T>where T: TypeFoldable<TyCtxt<'tcx>> + Debug + Clone,

fn try_fold_with<F>( self, folder: &mut F, ) -> Result<Spanned<T>, <F as FallibleTypeFolder<TyCtxt<'tcx>>>::Error>where F: FallibleTypeFolder<TyCtxt<'tcx>>,

fn fold_with<F>(self, folder: &mut F) -> Spanned<T>where F: TypeFolder<TyCtxt<'tcx>>,

impl<'tcx, V, T> TypeFoldable<TyCtxt<'tcx>> for ProjectionElem<V, T>where T: TypeFoldable<TyCtxt<'tcx>>, V: TypeFoldable<TyCtxt<'tcx>>,

fn try_fold_with<__F>( self, __folder: &mut __F, ) -> Result<ProjectionElem<V, T>, <__F as FallibleTypeFolder<TyCtxt<'tcx>>>::Error>where __F: FallibleTypeFolder<TyCtxt<'tcx>>,

fn fold_with<__F>(self, __folder: &mut __F) -> ProjectionElem<V, T>where __F: TypeFolder<TyCtxt<'tcx>>,

impl<'tcx> TypeFoldable<TyCtxt<'tcx>> for Adjust

fn try_fold_with<__F>( self, __folder: &mut __F, ) -> Result<Adjust, <__F as FallibleTypeFolder<TyCtxt<'tcx>>>::Error>where __F: FallibleTypeFolder<TyCtxt<'tcx>>,

fn fold_with<__F>(self, __folder: &mut __F) -> Adjustwhere __F: TypeFolder<TyCtxt<'tcx>>,

impl<'tcx> TypeFoldable<TyCtxt<'tcx>> for Adjustment<'tcx>

fn try_fold_with<__F>( self, __folder: &mut __F, ) -> Result<Adjustment<'tcx>, <__F as FallibleTypeFolder<TyCtxt<'tcx>>>::Error>where __F: FallibleTypeFolder<TyCtxt<'tcx>>,

fn fold_with<__F>(self, __folder: &mut __F) -> Adjustment<'tcx>where __F: TypeFolder<TyCtxt<'tcx>>,

impl<'tcx> TypeFoldable<TyCtxt<'tcx>> for AdtKind

fn try_fold_with<F>( self, _: &mut F, ) -> Result<AdtKind, <F as FallibleTypeFolder<TyCtxt<'tcx>>>::Error>where F: FallibleTypeFolder<TyCtxt<'tcx>>,

fn fold_with<F>(self, _: &mut F) -> AdtKindwhere F: TypeFolder<TyCtxt<'tcx>>,

impl<'tcx> TypeFoldable<TyCtxt<'tcx>> for AggregateKind<'tcx>

fn try_fold_with<__F>( self, __folder: &mut __F, ) -> Result<AggregateKind<'tcx>, <__F as FallibleTypeFolder<TyCtxt<'tcx>>>::Error>where __F: FallibleTypeFolder<TyCtxt<'tcx>>,

fn fold_with<__F>(self, __folder: &mut __F) -> AggregateKind<'tcx>where __F: TypeFolder<TyCtxt<'tcx>>,

impl<'tcx> TypeFoldable<TyCtxt<'tcx>> for AnnotationSource

fn try_fold_with<__F>( self, __folder: &mut __F, ) -> Result<AnnotationSource, <__F as FallibleTypeFolder<TyCtxt<'tcx>>>::Error>where __F: FallibleTypeFolder<TyCtxt<'tcx>>,

fn fold_with<__F>(self, __folder: &mut __F) -> AnnotationSourcewhere __F: TypeFolder<TyCtxt<'tcx>>,

impl<'tcx> TypeFoldable<TyCtxt<'tcx>> for AssocItem

fn try_fold_with<F>( self, _: &mut F, ) -> Result<AssocItem, <F as FallibleTypeFolder<TyCtxt<'tcx>>>::Error>where F: FallibleTypeFolder<TyCtxt<'tcx>>,

fn fold_with<F>(self, _: &mut F) -> AssocItemwhere F: TypeFolder<TyCtxt<'tcx>>,

impl<'tcx> TypeFoldable<TyCtxt<'tcx>> for AssocKind

fn try_fold_with<F>( self, _: &mut F, ) -> Result<AssocKind, <F as FallibleTypeFolder<TyCtxt<'tcx>>>::Error>where F: FallibleTypeFolder<TyCtxt<'tcx>>,

fn fold_with<F>(self, _: &mut F) -> AssocKindwhere F: TypeFolder<TyCtxt<'tcx>>,

impl<'tcx> TypeFoldable<TyCtxt<'tcx>> for Asyncness

fn try_fold_with<__F>( self, __folder: &mut __F, ) -> Result<Asyncness, <__F as FallibleTypeFolder<TyCtxt<'tcx>>>::Error>where __F: FallibleTypeFolder<TyCtxt<'tcx>>,

fn fold_with<__F>(self, __folder: &mut __F) -> Asyncnesswhere __F: TypeFolder<TyCtxt<'tcx>>,

impl<'tcx> TypeFoldable<TyCtxt<'tcx>> for AttributeKind

fn try_fold_with<F>( self, _: &mut F, ) -> Result<AttributeKind, <F as FallibleTypeFolder<TyCtxt<'tcx>>>::Error>where F: FallibleTypeFolder<TyCtxt<'tcx>>,

fn fold_with<F>(self, _: &mut F) -> AttributeKindwhere F: TypeFolder<TyCtxt<'tcx>>,

impl<'tcx> TypeFoldable<TyCtxt<'tcx>> for AutoBorrow

fn try_fold_with<__F>( self, __folder: &mut __F, ) -> Result<AutoBorrow, <__F as FallibleTypeFolder<TyCtxt<'tcx>>>::Error>where __F: FallibleTypeFolder<TyCtxt<'tcx>>,

fn fold_with<__F>(self, __folder: &mut __F) -> AutoBorrowwhere __F: TypeFolder<TyCtxt<'tcx>>,

impl<'tcx> TypeFoldable<TyCtxt<'tcx>> for AutoBorrowMutability

fn try_fold_with<F>( self, _: &mut F, ) -> Result<AutoBorrowMutability, <F as FallibleTypeFolder<TyCtxt<'tcx>>>::Error>where F: FallibleTypeFolder<TyCtxt<'tcx>>,

fn fold_with<F>(self, _: &mut F) -> AutoBorrowMutabilitywhere F: TypeFolder<TyCtxt<'tcx>>,

impl<'tcx> TypeFoldable<TyCtxt<'tcx>> for BackwardIncompatibleDropReason

fn try_fold_with<__F>( self, __folder: &mut __F, ) -> Result<BackwardIncompatibleDropReason, <__F as FallibleTypeFolder<TyCtxt<'tcx>>>::Error>where __F: FallibleTypeFolder<TyCtxt<'tcx>>,

fn fold_with<__F>(self, __folder: &mut __F) -> BackwardIncompatibleDropReasonwhere __F: TypeFolder<TyCtxt<'tcx>>,

impl<'tcx> TypeFoldable<TyCtxt<'tcx>> for BasicBlock

fn try_fold_with<F>( self, _: &mut F, ) -> Result<BasicBlock, <F as FallibleTypeFolder<TyCtxt<'tcx>>>::Error>where F: FallibleTypeFolder<TyCtxt<'tcx>>,

fn fold_with<F>(self, _: &mut F) -> BasicBlockwhere F: TypeFolder<TyCtxt<'tcx>>,

impl<'tcx> TypeFoldable<TyCtxt<'tcx>> for BasicBlockData<'tcx>

fn try_fold_with<__F>( self, __folder: &mut __F, ) -> Result<BasicBlockData<'tcx>, <__F as FallibleTypeFolder<TyCtxt<'tcx>>>::Error>where __F: FallibleTypeFolder<TyCtxt<'tcx>>,

fn fold_with<__F>(self, __folder: &mut __F) -> BasicBlockData<'tcx>where __F: TypeFolder<TyCtxt<'tcx>>,

impl<'tcx> TypeFoldable<TyCtxt<'tcx>> for BasicBlocks<'tcx>

fn try_fold_with<__F>( self, __folder: &mut __F, ) -> Result<BasicBlocks<'tcx>, <__F as FallibleTypeFolder<TyCtxt<'tcx>>>::Error>where __F: FallibleTypeFolder<TyCtxt<'tcx>>,

fn fold_with<__F>(self, __folder: &mut __F) -> BasicBlocks<'tcx>where __F: TypeFolder<TyCtxt<'tcx>>,

impl<'tcx> TypeFoldable<TyCtxt<'tcx>> for BinOp

fn try_fold_with<__F>( self, __folder: &mut __F, ) -> Result<BinOp, <__F as FallibleTypeFolder<TyCtxt<'tcx>>>::Error>where __F: FallibleTypeFolder<TyCtxt<'tcx>>,

fn fold_with<__F>(self, __folder: &mut __F) -> BinOpwhere __F: TypeFolder<TyCtxt<'tcx>>,

impl<'tcx> TypeFoldable<TyCtxt<'tcx>> for BindingForm<'tcx>

fn try_fold_with<F>( self, _: &mut F, ) -> Result<BindingForm<'tcx>, <F as FallibleTypeFolder<TyCtxt<'tcx>>>::Error>where F: FallibleTypeFolder<TyCtxt<'tcx>>,

fn fold_with<F>(self, _: &mut F) -> BindingForm<'tcx>where F: TypeFolder<TyCtxt<'tcx>>,

impl<'tcx> TypeFoldable<TyCtxt<'tcx>> for BlockTailInfo

fn try_fold_with<F>( self, _: &mut F, ) -> Result<BlockTailInfo, <F as FallibleTypeFolder<TyCtxt<'tcx>>>::Error>where F: FallibleTypeFolder<TyCtxt<'tcx>>,

fn fold_with<F>(self, _: &mut F) -> BlockTailInfowhere F: TypeFolder<TyCtxt<'tcx>>,

impl<'tcx> TypeFoldable<TyCtxt<'tcx>> for Body<'tcx>

Trait TypeFoldable

fn try_fold_with<F>( self, folder: &mut F, ) -> Result<Self, <F as FallibleTypeFolder<I>>::Error>
where F: FallibleTypeFolder<I>,

fn fold_with<F>(self, folder: &mut F) -> Self
where F: TypeFolder<I>,

impl<'tcx, O> TypeFoldable<TyCtxt<'tcx>> for AssertKind<O>
where O: TypeFoldable<TyCtxt<'tcx>>,

fn try_fold_with<F>( self, folder: &mut F, ) -> Result<AssertKind<O>, <F as FallibleTypeFolder<TyCtxt<'tcx>>>::Error>
where __F: FallibleTypeFolder<TyCtxt<'tcx>>,

fn fold_with<F>(self, folder: &mut F) -> AssertKind<O>
where F: TypeFolder<TyCtxt<'tcx>>,

impl<'tcx, T> TypeFoldable<TyCtxt<'tcx>> for ClearCrossCrate<T>
where T: TypeFoldable<TyCtxt<'tcx>>,

fn try_fold_with<F>( self, folder: &mut F, ) -> Result<ClearCrossCrate<T>, <F as FallibleTypeFolder<TyCtxt<'tcx>>>::Error>
where __F: FallibleTypeFolder<TyCtxt<'tcx>>,

fn fold_with<F>(self, folder: &mut F) -> ClearCrossCrate<T>
where F: TypeFolder<TyCtxt<'tcx>>,

impl<'tcx, T> TypeFoldable<TyCtxt<'tcx>> for ParamEnvAnd<'tcx, T>
where T: TypeFoldable<TyCtxt<'tcx>>,

fn try_fold_with<F>( self, folder: &mut F, ) -> Result<ParamEnvAnd<'tcx, T>, <F as FallibleTypeFolder<TyCtxt<'tcx>>>::Error>
where __F: FallibleTypeFolder<TyCtxt<'tcx>>,

fn fold_with<F>(self, folder: &mut F) -> ParamEnvAnd<'tcx, T>
where F: TypeFolder<TyCtxt<'tcx>>,

impl<'tcx, T> TypeFoldable<TyCtxt<'tcx>> for PseudoCanonicalInput<'tcx, T>
where T: TypeFoldable<TyCtxt<'tcx>>,

fn try_fold_with<F>( self, folder: &mut F, ) -> Result<PseudoCanonicalInput<'tcx, T>, <F as FallibleTypeFolder<TyCtxt<'tcx>>>::Error>
where __F: FallibleTypeFolder<TyCtxt<'tcx>>,

fn fold_with<F>(self, folder: &mut F) -> PseudoCanonicalInput<'tcx, T>
where F: TypeFolder<TyCtxt<'tcx>>,

impl<'tcx, T> TypeFoldable<TyCtxt<'tcx>> for Spanned<T>
where T: TypeFoldable<TyCtxt<'tcx>> + Debug + Clone,

fn try_fold_with<F>( self, folder: &mut F, ) -> Result<Spanned<T>, <F as FallibleTypeFolder<TyCtxt<'tcx>>>::Error>
where F: FallibleTypeFolder<TyCtxt<'tcx>>,

fn fold_with<F>(self, folder: &mut F) -> Spanned<T>
where F: TypeFolder<TyCtxt<'tcx>>,

impl<'tcx, V, T> TypeFoldable<TyCtxt<'tcx>> for ProjectionElem<V, T>
where T: TypeFoldable<TyCtxt<'tcx>>, V: TypeFoldable<TyCtxt<'tcx>>,

fn try_fold_with<F>( self, folder: &mut F, ) -> Result<ProjectionElem<V, T>, <F as FallibleTypeFolder<TyCtxt<'tcx>>>::Error>
where __F: FallibleTypeFolder<TyCtxt<'tcx>>,

fn fold_with<F>(self, folder: &mut F) -> ProjectionElem<V, T>
where F: TypeFolder<TyCtxt<'tcx>>,

fn try_fold_with<F>( self, folder: &mut F, ) -> Result<Adjust, <F as FallibleTypeFolder<TyCtxt<'tcx>>>::Error>
where __F: FallibleTypeFolder<TyCtxt<'tcx>>,

fn fold_with<F>(self, folder: &mut F) -> Adjust
where F: TypeFolder<TyCtxt<'tcx>>,

fn try_fold_with<F>( self, folder: &mut F, ) -> Result<Adjustment<'tcx>, <F as FallibleTypeFolder<TyCtxt<'tcx>>>::Error>
where __F: FallibleTypeFolder<TyCtxt<'tcx>>,

fn fold_with<F>(self, folder: &mut F) -> Adjustment<'tcx>
where F: TypeFolder<TyCtxt<'tcx>>,

fn try_fold_with<F>( self, _: &mut F, ) -> Result<AdtKind, <F as FallibleTypeFolder<TyCtxt<'tcx>>>::Error>
where F: FallibleTypeFolder<TyCtxt<'tcx>>,

fn fold_with<F>(self, _: &mut F) -> AdtKind
where F: TypeFolder<TyCtxt<'tcx>>,

fn try_fold_with<F>( self, folder: &mut F, ) -> Result<AggregateKind<'tcx>, <F as FallibleTypeFolder<TyCtxt<'tcx>>>::Error>
where __F: FallibleTypeFolder<TyCtxt<'tcx>>,

fn fold_with<F>(self, folder: &mut F) -> AggregateKind<'tcx>
where F: TypeFolder<TyCtxt<'tcx>>,

fn try_fold_with<F>( self, folder: &mut F, ) -> Result<AnnotationSource, <F as FallibleTypeFolder<TyCtxt<'tcx>>>::Error>
where __F: FallibleTypeFolder<TyCtxt<'tcx>>,

fn fold_with<F>(self, folder: &mut F) -> AnnotationSource
where F: TypeFolder<TyCtxt<'tcx>>,

fn try_fold_with<F>( self, _: &mut F, ) -> Result<AssocItem, <F as FallibleTypeFolder<TyCtxt<'tcx>>>::Error>
where F: FallibleTypeFolder<TyCtxt<'tcx>>,

fn fold_with<F>(self, _: &mut F) -> AssocItem
where F: TypeFolder<TyCtxt<'tcx>>,

fn try_fold_with<F>( self, _: &mut F, ) -> Result<AssocKind, <F as FallibleTypeFolder<TyCtxt<'tcx>>>::Error>
where F: FallibleTypeFolder<TyCtxt<'tcx>>,

fn fold_with<F>(self, _: &mut F) -> AssocKind
where F: TypeFolder<TyCtxt<'tcx>>,

fn try_fold_with<F>( self, folder: &mut F, ) -> Result<Asyncness, <F as FallibleTypeFolder<TyCtxt<'tcx>>>::Error>
where __F: FallibleTypeFolder<TyCtxt<'tcx>>,

fn fold_with<F>(self, folder: &mut F) -> Asyncness
where F: TypeFolder<TyCtxt<'tcx>>,

fn try_fold_with<F>( self, _: &mut F, ) -> Result<AttributeKind, <F as FallibleTypeFolder<TyCtxt<'tcx>>>::Error>
where F: FallibleTypeFolder<TyCtxt<'tcx>>,

fn fold_with<F>(self, _: &mut F) -> AttributeKind
where F: TypeFolder<TyCtxt<'tcx>>,

fn try_fold_with<F>( self, folder: &mut F, ) -> Result<AutoBorrow, <F as FallibleTypeFolder<TyCtxt<'tcx>>>::Error>
where __F: FallibleTypeFolder<TyCtxt<'tcx>>,

fn fold_with<F>(self, folder: &mut F) -> AutoBorrow
where F: TypeFolder<TyCtxt<'tcx>>,

fn try_fold_with<F>( self, _: &mut F, ) -> Result<AutoBorrowMutability, <F as FallibleTypeFolder<TyCtxt<'tcx>>>::Error>
where F: FallibleTypeFolder<TyCtxt<'tcx>>,

fn fold_with<F>(self, _: &mut F) -> AutoBorrowMutability
where F: TypeFolder<TyCtxt<'tcx>>,

fn try_fold_with<F>( self, folder: &mut F, ) -> Result<BackwardIncompatibleDropReason, <F as FallibleTypeFolder<TyCtxt<'tcx>>>::Error>
where __F: FallibleTypeFolder<TyCtxt<'tcx>>,

fn fold_with<F>(self, folder: &mut F) -> BackwardIncompatibleDropReason
where F: TypeFolder<TyCtxt<'tcx>>,

fn try_fold_with<F>( self, _: &mut F, ) -> Result<BasicBlock, <F as FallibleTypeFolder<TyCtxt<'tcx>>>::Error>
where F: FallibleTypeFolder<TyCtxt<'tcx>>,

fn fold_with<F>(self, _: &mut F) -> BasicBlock
where F: TypeFolder<TyCtxt<'tcx>>,

fn try_fold_with<F>( self, folder: &mut F, ) -> Result<BasicBlockData<'tcx>, <F as FallibleTypeFolder<TyCtxt<'tcx>>>::Error>
where __F: FallibleTypeFolder<TyCtxt<'tcx>>,

fn fold_with<F>(self, folder: &mut F) -> BasicBlockData<'tcx>
where F: TypeFolder<TyCtxt<'tcx>>,

fn try_fold_with<F>( self, folder: &mut F, ) -> Result<BasicBlocks<'tcx>, <F as FallibleTypeFolder<TyCtxt<'tcx>>>::Error>
where __F: FallibleTypeFolder<TyCtxt<'tcx>>,

fn fold_with<F>(self, folder: &mut F) -> BasicBlocks<'tcx>
where F: TypeFolder<TyCtxt<'tcx>>,

fn try_fold_with<F>( self, folder: &mut F, ) -> Result<BinOp, <F as FallibleTypeFolder<TyCtxt<'tcx>>>::Error>
where __F: FallibleTypeFolder<TyCtxt<'tcx>>,

fn fold_with<F>(self, folder: &mut F) -> BinOp
where F: TypeFolder<TyCtxt<'tcx>>,

fn try_fold_with<F>( self, _: &mut F, ) -> Result<BindingForm<'tcx>, <F as FallibleTypeFolder<TyCtxt<'tcx>>>::Error>
where F: FallibleTypeFolder<TyCtxt<'tcx>>,

fn fold_with<F>(self, _: &mut F) -> BindingForm<'tcx>
where F: TypeFolder<TyCtxt<'tcx>>,

fn try_fold_with<F>( self, _: &mut F, ) -> Result<BlockTailInfo, <F as FallibleTypeFolder<TyCtxt<'tcx>>>::Error>
where F: FallibleTypeFolder<TyCtxt<'tcx>>,

fn fold_with<F>(self, _: &mut F) -> BlockTailInfo
where F: TypeFolder<TyCtxt<'tcx>>,

fn try_fold_with<F>( self, folder: &mut F, ) -> Result<Body<'tcx>, <F as FallibleTypeFolder<TyCtxt<'tcx>>>::Error>
where __F: FallibleTypeFolder<TyCtxt<'tcx>>,

fn fold_with<F>(self, folder: &mut F) -> Body<'tcx>
where F: TypeFolder<TyCtxt<'tcx>>,

fn try_fold_with<F>( self, folder: &mut F, ) -> Result<BorrowKind, <F as FallibleTypeFolder<TyCtxt<'tcx>>>::Error>
where __F: FallibleTypeFolder<TyCtxt<'tcx>>,

fn fold_with<F>(self, folder: &mut F) -> BorrowKind
where F: TypeFolder<TyCtxt<'tcx>>,

fn try_fold_with<F>( self, _: &mut F, ) -> Result<BorrowKind, <F as FallibleTypeFolder<TyCtxt<'tcx>>>::Error>
where F: FallibleTypeFolder<TyCtxt<'tcx>>,

fn fold_with<F>(self, _: &mut F) -> BorrowKind
where F: TypeFolder<TyCtxt<'tcx>>,

fn try_fold_with<F>( self, folder: &mut F, ) -> Result<CallSource, <F as FallibleTypeFolder<TyCtxt<'tcx>>>::Error>
where __F: FallibleTypeFolder<TyCtxt<'tcx>>,

fn fold_with<F>(self, folder: &mut F) -> CallSource
where F: TypeFolder<TyCtxt<'tcx>>,

fn try_fold_with<F>( self, folder: &mut F, ) -> Result<CanonicalUserTypeAnnotation<'tcx>, <F as FallibleTypeFolder<TyCtxt<'tcx>>>::Error>
where __F: FallibleTypeFolder<TyCtxt<'tcx>>,

fn fold_with<F>(self, folder: &mut F) -> CanonicalUserTypeAnnotation<'tcx>
where F: TypeFolder<TyCtxt<'tcx>>,

fn try_fold_with<F>( self, folder: &mut F, ) -> Result<CaptureInfo, <F as FallibleTypeFolder<TyCtxt<'tcx>>>::Error>
where __F: FallibleTypeFolder<TyCtxt<'tcx>>,

fn fold_with<F>(self, folder: &mut F) -> CaptureInfo
where F: TypeFolder<TyCtxt<'tcx>>,

fn try_fold_with<F>( self, folder: &mut F, ) -> Result<CapturedPlace<'tcx>, <F as FallibleTypeFolder<TyCtxt<'tcx>>>::Error>
where __F: FallibleTypeFolder<TyCtxt<'tcx>>,

fn fold_with<F>(self, folder: &mut F) -> CapturedPlace<'tcx>
where F: TypeFolder<TyCtxt<'tcx>>,

fn try_fold_with<F>( self, folder: &mut F, ) -> Result<CastKind, <F as FallibleTypeFolder<TyCtxt<'tcx>>>::Error>
where __F: FallibleTypeFolder<TyCtxt<'tcx>>,

fn fold_with<F>(self, folder: &mut F) -> CastKind
where F: TypeFolder<TyCtxt<'tcx>>,

fn try_fold_with<F>( self, _: &mut F, ) -> Result<CastKind, <F as FallibleTypeFolder<TyCtxt<'tcx>>>::Error>
where F: FallibleTypeFolder<TyCtxt<'tcx>>,

fn fold_with<F>(self, _: &mut F) -> CastKind
where F: TypeFolder<TyCtxt<'tcx>>,

fn try_fold_with<F>( self, folder: &mut F, ) -> Result<Clause<'tcx>, <F as FallibleTypeFolder<TyCtxt<'tcx>>>::Error>
where F: FallibleTypeFolder<TyCtxt<'tcx>>,

fn fold_with<F>(self, folder: &mut F) -> Clause<'tcx>
where F: TypeFolder<TyCtxt<'tcx>>,

fn try_fold_with<F>( self, folder: &mut F, ) -> Result<ClosureSizeProfileData<'tcx>, <F as FallibleTypeFolder<TyCtxt<'tcx>>>::Error>
where __F: FallibleTypeFolder<TyCtxt<'tcx>>,

fn fold_with<F>(self, folder: &mut F) -> ClosureSizeProfileData<'tcx>
where F: TypeFolder<TyCtxt<'tcx>>,

fn try_fold_with<F>( self, folder: &mut F, ) -> Result<Const<'tcx>, <F as FallibleTypeFolder<TyCtxt<'tcx>>>::Error>
where __F: FallibleTypeFolder<TyCtxt<'tcx>>,