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", so this trait is not object safe.

Trait TypeFoldableCopy 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> TypeFoldable<TyCtxt<'tcx>> for InlineAsmTemplatePiece

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

fn fold_with<F>(self, _: &mut F) -> ConstValue<'tcx>where 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 LocalInfo<'tcx>

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

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

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

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

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

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

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

fn fold_with<__F>(self, __folder: &mut __F) -> VarDebugInfoContents<'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 ConstraintCategory<'tcx>

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

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

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

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

fn fold_with<__F>(self, __folder: &mut __F) -> ReturnConstraintwhere __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 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 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 BorrowKind

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) -> BorrowKindwhere F: TypeFolder<TyCtxt<'tcx>>,

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

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) -> CallSourcewhere __F: TypeFolder<TyCtxt<'tcx>>,

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

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) -> CastKindwhere F: TypeFolder<TyCtxt<'tcx>>,

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

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

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

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

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

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

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

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

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

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

fn try_fold_with<F>( self, _: &mut F, ) -> Result<MirPhase, <F as FallibleTypeFolder<TyCtxt<'tcx>>>::Error>where F: FallibleTypeFolder<TyCtxt<'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>,

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

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

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

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

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

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

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

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

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

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

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

fn fold_with<F>(self, folder: &mut F) -> ProjectionKind
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>>,

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

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

fn fold_with<F>(self, _: &mut F) -> ConstValue<'tcx>
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, folder: &mut F, ) -> Result<LocalInfo<'tcx>, <F as FallibleTypeFolder<TyCtxt<'tcx>>>::Error>
where __F: FallibleTypeFolder<TyCtxt<'tcx>>,

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

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

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

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

fn fold_with<F>(self, folder: &mut F) -> VarDebugInfoContents<'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, folder: &mut F, ) -> Result<ConstraintCategory<'tcx>, <F as FallibleTypeFolder<TyCtxt<'tcx>>>::Error>
where __F: FallibleTypeFolder<TyCtxt<'tcx>>,

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

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

fn fold_with<F>(self, folder: &mut F) -> ReturnConstraint
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<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, 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<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, _: &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, _: &mut F, ) -> Result<FakeReadCause, <F as FallibleTypeFolder<TyCtxt<'tcx>>>::Error>
where F: FallibleTypeFolder<TyCtxt<'tcx>>,

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

fn fold_with<F>(self, folder: &mut F) -> UnwindTerminateReason
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<NotConstEvaluatable, <F as FallibleTypeFolder<TyCtxt<'tcx>>>::Error>
where F: FallibleTypeFolder<TyCtxt<'tcx>>,

fn fold_with<F>(self, _: &mut F) -> NotConstEvaluatable
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>>,