Trait rustc_trait_selection::infer::canonical::ir::fold::TypeFoldable

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

    // Provided method
    fn fold_with<F>(self, folder: &mut F) -> Self
       where F: TypeFolder<I> { ... }
}

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

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

where F: FallibleTypeFolder<I>,

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 TypeFolder.

Provided Methods

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

where F: TypeFolder<I>,

A convenient alternative to try_fold_with for use with infallible folders. Do not override this method, to ensure coherence with try_fold_with.

Object Safety

This trait is not object safe.

Implementations on Foreign Types

impl<'tcx> TypeFoldable<TyCtxt<'tcx>> for &'tcx [InlineAsmTemplatePiece]

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

where F: FallibleTypeFolder<TyCtxt<'tcx>>,

impl<'tcx> TypeFoldable<TyCtxt<'tcx>> for &'tcx [Span]

fn try_fold_with<F>( self, _folder: &mut F, ) -> Result<&'tcx [Span], <F as FallibleTypeFolder<TyCtxt<'tcx>>>::Error>

where F: FallibleTypeFolder<TyCtxt<'tcx>>,

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

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

where F: FallibleTypeFolder<TyCtxt<'tcx>>,

fn fold_with<F>(self, _: &mut F) -> ByRef

where F: TypeFolder<TyCtxt<'tcx>>,

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) -> InlineAsmTemplatePiece

where F: TypeFolder<TyCtxt<'tcx>>,

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

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

where F: FallibleTypeFolder<TyCtxt<'tcx>>,

fn fold_with<F>(self, _: &mut F) -> Res

where 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) -> CoroutineKind

where 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) -> MatchSource

where F: TypeFolder<TyCtxt<'tcx>>,

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

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

where F: FallibleTypeFolder<TyCtxt<'tcx>>,

fn fold_with<F>(self, _: &mut F) -> Safety

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

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

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

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 CovTerm

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

where __F: FallibleTypeFolder<TyCtxt<'tcx>>,

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

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

where __F: FallibleTypeFolder<TyCtxt<'tcx>>,

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

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

where __F: FallibleTypeFolder<TyCtxt<'tcx>>,

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

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

where __F: FallibleTypeFolder<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>>,

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

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

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

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

where F: FallibleTypeFolder<TyCtxt<'tcx>>,

fn fold_with<F>(self, _: &mut F) -> ErrorHandled

where F: TypeFolder<TyCtxt<'tcx>>,

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

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

where F: FallibleTypeFolder<TyCtxt<'tcx>>,

fn fold_with<F>(self, _: &mut F) -> Scalar

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

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

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

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

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) -> BorrowKind

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

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) -> CastKind

where 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) -> FakeReadCause

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

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

fn fold_with<F>(self, _: &mut F) -> MirPhase

where F: TypeFolder<TyCtxt<'tcx>>,

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

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

where __F: FallibleTypeFolder<TyCtxt<'tcx>>,

impl<'tcx> TypeFoldable<TyCtxt<'tcx>> for NullOp<'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>>,

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

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

where __F: FallibleTypeFolder<TyCtxt<'tcx>>,

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

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

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

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

where __F: FallibleTypeFolder<TyCtxt<'tcx>>,

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

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

where __F: FallibleTypeFolder<TyCtxt<'tcx>>,

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

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

where __F: FallibleTypeFolder<TyCtxt<'tcx>>,

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

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

where __F: FallibleTypeFolder<TyCtxt<'tcx>>,

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

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

where __F: FallibleTypeFolder<TyCtxt<'tcx>>,

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

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

where __F: FallibleTypeFolder<TyCtxt<'tcx>>,

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

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

where __F: FallibleTypeFolder<TyCtxt<'tcx>>,

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

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

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

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

where __F: FallibleTypeFolder<TyCtxt<'tcx>>,

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

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

where __F: FallibleTypeFolder<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) -> AutoBorrowMutability

where F: TypeFolder<TyCtxt<'tcx>>,

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

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

where F: FallibleTypeFolder<TyCtxt<'tcx>>,

fn fold_with<F>(self, _: &mut F) -> PointerCoercion

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) -> AdtKind

where 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) -> AssocKind

where F: TypeFolder<TyCtxt<'tcx>>,

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

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

where __F: FallibleTypeFolder<TyCtxt<'tcx>>,

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

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

where __F: FallibleTypeFolder<TyCtxt<'tcx>>,

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

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

where __F: FallibleTypeFolder<TyCtxt<'tcx>>,

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

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

where F: FallibleTypeFolder<TyCtxt<'tcx>>,

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

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

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

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

where __F: FallibleTypeFolder<TyCtxt<'tcx>>,

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

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

where __F: FallibleTypeFolder<TyCtxt<'tcx>>,

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

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

where F: FallibleTypeFolder<TyCtxt<'tcx>>,

fn fold_with<F>(self, _: &mut F) -> ReifyReason

where F: TypeFolder<TyCtxt<'tcx>>,

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

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

where __F: FallibleTypeFolder<TyCtxt<'tcx>>,

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

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

where F: FallibleTypeFolder<TyCtxt<'tcx>>,

fn fold_with<F>(self, _: &mut F) -> BoundRegionKind

where F: TypeFolder<TyCtxt<'tcx>>,

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

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

where __F: FallibleTypeFolder<TyCtxt<'tcx>>,

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

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

where __F: FallibleTypeFolder<TyCtxt<'tcx>>,

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

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

where F: FallibleTypeFolder<TyCtxt<'tcx>>,

fn fold_with<F>(self, _: &mut F) -> InlineAsmRegOrRegClass

where F: TypeFolder<TyCtxt<'tcx>>,

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

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

where F: FallibleTypeFolder<TyCtxt<'tcx>>,

fn fold_with<F>(self, _: &mut F) -> Abi

where F: TypeFolder<TyCtxt<'tcx>>,

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

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

where F: FallibleTypeFolder<TyCtxt<'tcx>>,

fn fold_with<F>(self, _: &mut F) -> Size

where F: TypeFolder<TyCtxt<'tcx>>,

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

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

where F: FallibleTypeFolder<TyCtxt<'tcx>>,

fn fold_with<F>(self, _: &mut F) -> InlineAsmOptions

where F: TypeFolder<TyCtxt<'tcx>>,

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

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

where F: FallibleTypeFolder<TyCtxt<'tcx>>,

fn fold_with<F>(self, _: &mut F) -> NodeId

where F: TypeFolder<TyCtxt<'tcx>>,

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

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

where F: FallibleTypeFolder<TyCtxt<'tcx>>,

fn fold_with<F>(self, _: &mut F) -> HirId

where F: TypeFolder<TyCtxt<'tcx>>,

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

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

where __F: FallibleTypeFolder<TyCtxt<'tcx>>,

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

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

where __F: FallibleTypeFolder<TyCtxt<'tcx>>,

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

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

where F: FallibleTypeFolder<TyCtxt<'tcx>>,

fn fold_with<F>(self, _: &mut F) -> Scope

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

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

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

where __F: FallibleTypeFolder<TyCtxt<'tcx>>,

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

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

where F: FallibleTypeFolder<TyCtxt<'tcx>>,

fn fold_with<F>(self, _: &mut F) -> BlockMarkerId

where F: TypeFolder<TyCtxt<'tcx>>,

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

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

where __F: FallibleTypeFolder<TyCtxt<'tcx>>,

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

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

where __F: FallibleTypeFolder<TyCtxt<'tcx>>,

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

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

where F: FallibleTypeFolder<TyCtxt<'tcx>>,

fn fold_with<F>(self, _: &mut F) -> ConditionId

where F: TypeFolder<TyCtxt<'tcx>>,

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

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

where __F: FallibleTypeFolder<TyCtxt<'tcx>>,

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

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

where F: FallibleTypeFolder<TyCtxt<'tcx>>,

fn fold_with<F>(self, _: &mut F) -> CounterId

where F: TypeFolder<TyCtxt<'tcx>>,

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

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

where __F: FallibleTypeFolder<TyCtxt<'tcx>>,

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

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

where __F: FallibleTypeFolder<TyCtxt<'tcx>>,

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

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

where __F: FallibleTypeFolder<TyCtxt<'tcx>>,

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

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

where F: FallibleTypeFolder<TyCtxt<'tcx>>,

fn fold_with<F>(self, _: &mut F) -> ExpressionId

where F: TypeFolder<TyCtxt<'tcx>>,

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

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

where __F: FallibleTypeFolder<TyCtxt<'tcx>>,

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

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

where __F: FallibleTypeFolder<TyCtxt<'tcx>>,

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

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

where __F: FallibleTypeFolder<TyCtxt<'tcx>>,

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

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

where __F: FallibleTypeFolder<TyCtxt<'tcx>>,

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

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

where F: FallibleTypeFolder<TyCtxt<'tcx>>,

fn fold_with<F>(self, _: &mut F) -> CtfeProvenance

where F: TypeFolder<TyCtxt<'tcx>>,

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

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

where F: FallibleTypeFolder<TyCtxt<'tcx>>,

fn fold_with<F>(self, _: &mut F) -> AllocId

where F: TypeFolder<TyCtxt<'tcx>>,

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

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

where __F: FallibleTypeFolder<TyCtxt<'tcx>>,

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

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

where __F: FallibleTypeFolder<TyCtxt<'tcx>>,

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

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

where F: FallibleTypeFolder<TyCtxt<'tcx>>,

fn fold_with<F>(self, _: &mut F) -> CoroutineSavedLocal

where F: TypeFolder<TyCtxt<'tcx>>,

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

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

where __F: FallibleTypeFolder<TyCtxt<'tcx>>,

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

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

where __F: FallibleTypeFolder<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) -> BasicBlock

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

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) -> BlockTailInfo

where F: TypeFolder<TyCtxt<'tcx>>,

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

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

where __F: FallibleTypeFolder<TyCtxt<'tcx>>,

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

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

where __F: FallibleTypeFolder<TyCtxt<'tcx>>,

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

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

where F: FallibleTypeFolder<TyCtxt<'tcx>>,

fn fold_with<F>(self, _: &mut F) -> Local

where F: TypeFolder<TyCtxt<'tcx>>,

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

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

where __F: FallibleTypeFolder<TyCtxt<'tcx>>,

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

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

where __F: FallibleTypeFolder<TyCtxt<'tcx>>,

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

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

where F: FallibleTypeFolder<TyCtxt<'tcx>>,

fn fold_with<F>(self, _: &mut F) -> Promoted

where F: TypeFolder<TyCtxt<'tcx>>,

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

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

where F: FallibleTypeFolder<TyCtxt<'tcx>>,

fn fold_with<F>(self, _: &mut F) -> SourceInfo

where F: TypeFolder<TyCtxt<'tcx>>,

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

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

where F: FallibleTypeFolder<TyCtxt<'tcx>>,

fn fold_with<F>(self, _: &mut F) -> SourceScope

where F: TypeFolder<TyCtxt<'tcx>>,

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

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

where __F: FallibleTypeFolder<TyCtxt<'tcx>>,

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

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

where F: FallibleTypeFolder<TyCtxt<'tcx>>,

fn fold_with<F>(self, _: &mut F) -> SourceScopeLocalData

where F: TypeFolder<TyCtxt<'tcx>>,

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

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

where __F: FallibleTypeFolder<TyCtxt<'tcx>>,

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

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

where __F: FallibleTypeFolder<TyCtxt<'tcx>>,

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

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

where __F: FallibleTypeFolder<TyCtxt<'tcx>>,

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

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

where __F: FallibleTypeFolder<TyCtxt<'tcx>>,

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

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

where __F: FallibleTypeFolder<TyCtxt<'tcx>>,

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

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

where __F: FallibleTypeFolder<TyCtxt<'tcx>>,

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

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

where __F: FallibleTypeFolder<TyCtxt<'tcx>>,

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

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

where F: FallibleTypeFolder<TyCtxt<'tcx>>,

fn fold_with<F>(self, _: &mut F) -> SwitchTargets

where F: TypeFolder<TyCtxt<'tcx>>,

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

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

where __F: FallibleTypeFolder<TyCtxt<'tcx>>,

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

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

where __F: FallibleTypeFolder<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>>,

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

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

where __F: FallibleTypeFolder<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) -> AssocItem

where F: TypeFolder<TyCtxt<'tcx>>,

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

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

where __F: FallibleTypeFolder<TyCtxt<'tcx>>,

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

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

where __F: FallibleTypeFolder<TyCtxt<'tcx>>,

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

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

where __F: FallibleTypeFolder<TyCtxt<'tcx>>,

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

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

where __F: FallibleTypeFolder<TyCtxt<'tcx>>,

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

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

where __F: FallibleTypeFolder<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>>,

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

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

where F: FallibleTypeFolder<TyCtxt<'tcx>>,

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

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

where __F: FallibleTypeFolder<TyCtxt<'tcx>>,

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

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

where __F: FallibleTypeFolder<TyCtxt<'tcx>>,

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

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

where __F: FallibleTypeFolder<TyCtxt<'tcx>>,

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

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

where F: FallibleTypeFolder<TyCtxt<'tcx>>,

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

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

where F: FallibleTypeFolder<TyCtxt<'tcx>>,

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

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

where F: FallibleTypeFolder<TyCtxt<'tcx>>,

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

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

where __F: FallibleTypeFolder<TyCtxt<'tcx>>,

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

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

where __F: FallibleTypeFolder<TyCtxt<'tcx>>,

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

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

where __F: FallibleTypeFolder<TyCtxt<'tcx>>,

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

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

where __F: FallibleTypeFolder<TyCtxt<'tcx>>,

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

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

where F: FallibleTypeFolder<TyCtxt<'tcx>>,

fn fold_with<F>(self, _: &mut F) -> BoundRegion

where F: TypeFolder<TyCtxt<'tcx>>,

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

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

where F: FallibleTypeFolder<TyCtxt<'tcx>>,

fn fold_with<F>(self, _: &mut F) -> LateParamRegion

where F: TypeFolder<TyCtxt<'tcx>>,

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

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

where F: FallibleTypeFolder<TyCtxt<'tcx>>,

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

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

where __F: FallibleTypeFolder<TyCtxt<'tcx>>,

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

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

where __F: FallibleTypeFolder<TyCtxt<'tcx>>,

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

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

where __F: FallibleTypeFolder<TyCtxt<'tcx>>,

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

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

where __F: FallibleTypeFolder<TyCtxt<'tcx>>,

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

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

where F: FallibleTypeFolder<TyCtxt<'tcx>>,

impl<'tcx> TypeFoldable<TyCtxt<'tcx>> for Placeholder<BoundRegion>

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

where F: FallibleTypeFolder<TyCtxt<'tcx>>,

fn fold_with<F>(self, _: &mut F) -> Placeholder<BoundRegion>

where F: TypeFolder<TyCtxt<'tcx>>,

impl<'tcx> TypeFoldable<TyCtxt<'tcx>> for Placeholder<BoundTy>

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

where F: FallibleTypeFolder<TyCtxt<'tcx>>,

fn fold_with<F>(self, _: &mut F) -> Placeholder<BoundTy>

where F: TypeFolder<TyCtxt<'tcx>>,

impl<'tcx> TypeFoldable<TyCtxt<'tcx>> for Placeholder<BoundVar>

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

where F: FallibleTypeFolder<TyCtxt<'tcx>>,

fn fold_with<F>(self, _: &mut F) -> Placeholder<BoundVar>

where F: TypeFolder<TyCtxt<'tcx>>,

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

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

where F: FallibleTypeFolder<TyCtxt<'tcx>>,

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

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

where F: FallibleTypeFolder<TyCtxt<'tcx>>,

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

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

where F: FallibleTypeFolder<TyCtxt<'tcx>>,

fn fold_with<F>(self, _: &mut F) -> ParamConst

where F: TypeFolder<TyCtxt<'tcx>>,

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

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

where F: FallibleTypeFolder<TyCtxt<'tcx>>,

fn fold_with<F>(self, _: &mut F) -> ParamTy

where F: TypeFolder<TyCtxt<'tcx>>,

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

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

where __F: FallibleTypeFolder<TyCtxt<'tcx>>,

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

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

where F: FallibleTypeFolder<TyCtxt<'tcx>>,

fn fold_with<F>(self, _: &mut F) -> UserTypeAnnotationIndex

where F: TypeFolder<TyCtxt<'tcx>>,

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

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

where F: FallibleTypeFolder<TyCtxt<'tcx>>,

fn fold_with<F>(self, _: &mut F) -> DefId

where F: TypeFolder<TyCtxt<'tcx>>,

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

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

where F: FallibleTypeFolder<TyCtxt<'tcx>>,

fn fold_with<F>(self, _: &mut F) -> LocalDefId

where F: TypeFolder<TyCtxt<'tcx>>,

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

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

where F: FallibleTypeFolder<TyCtxt<'tcx>>,

fn fold_with<F>(self, _: &mut F) -> Span

where F: TypeFolder<TyCtxt<'tcx>>,

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

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

where F: FallibleTypeFolder<TyCtxt<'tcx>>,

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

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

where F: FallibleTypeFolder<TyCtxt<'tcx>>,

fn fold_with<F>(self, _: &mut F) -> Ident

where F: TypeFolder<TyCtxt<'tcx>>,

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

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

where F: FallibleTypeFolder<TyCtxt<'tcx>>,

fn fold_with<F>(self, _: &mut F) -> Symbol

where F: TypeFolder<TyCtxt<'tcx>>,

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

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

where F: FallibleTypeFolder<TyCtxt<'tcx>>,

fn fold_with<F>(self, _: &mut F) -> FieldIdx

where F: TypeFolder<TyCtxt<'tcx>>,

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

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

where F: FallibleTypeFolder<TyCtxt<'tcx>>,

fn fold_with<F>(self, _: &mut F) -> VariantIdx

where F: TypeFolder<TyCtxt<'tcx>>,

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

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

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

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

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

impl<I> TypeFoldable<I> for Movability

where I: Interner,

fn try_fold_with<F>( self, _: &mut F, ) -> Result<Movability, <F as FallibleTypeFolder<I>>::Error>

where F: FallibleTypeFolder<I>,

fn fold_with<F>(self, _: &mut F) -> Movability

where F: TypeFolder<I>,

impl<I> TypeFoldable<I> for Mutability

where I: Interner,

fn try_fold_with<F>( self, _: &mut F, ) -> Result<Mutability, <F as FallibleTypeFolder<I>>::Error>

where F: FallibleTypeFolder<I>,

fn fold_with<F>(self, _: &mut F) -> Mutability

where F: TypeFolder<I>,

impl<I> TypeFoldable<I> for bool

where I: Interner,

fn try_fold_with<F>( self, _: &mut F, ) -> Result<bool, <F as FallibleTypeFolder<I>>::Error>

where F: FallibleTypeFolder<I>,

fn fold_with<F>(self, _: &mut F) -> bool

where F: TypeFolder<I>,

impl<I> TypeFoldable<I> for u16

where I: Interner,

fn try_fold_with<F>( self, _: &mut F, ) -> Result<u16, <F as FallibleTypeFolder<I>>::Error>

where F: FallibleTypeFolder<I>,

fn fold_with<F>(self, _: &mut F) -> u16

where F: TypeFolder<I>,

impl<I> TypeFoldable<I> for u32

where I: Interner,

fn try_fold_with<F>( self, _: &mut F, ) -> Result<u32, <F as FallibleTypeFolder<I>>::Error>

where F: FallibleTypeFolder<I>,

fn fold_with<F>(self, _: &mut F) -> u32

where F: TypeFolder<I>,

impl<I> TypeFoldable<I> for u64

where I: Interner,

fn try_fold_with<F>( self, _: &mut F, ) -> Result<u64, <F as FallibleTypeFolder<I>>::Error>

where F: FallibleTypeFolder<I>,

fn fold_with<F>(self, _: &mut F) -> u64

where F: TypeFolder<I>,

impl<I> TypeFoldable<I> for ()

where I: Interner,

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

where F: FallibleTypeFolder<I>,

fn fold_with<F>(self, _: &mut F)

where F: TypeFolder<I>,

impl<I> TypeFoldable<I> for usize

where I: Interner,

fn try_fold_with<F>( self, _: &mut F, ) -> Result<usize, <F as FallibleTypeFolder<I>>::Error>

where F: FallibleTypeFolder<I>,

fn fold_with<F>(self, _: &mut F) -> usize

where F: TypeFolder<I>,

impl<I> TypeFoldable<I> for String

where I: Interner,

fn try_fold_with<F>( self, _: &mut F, ) -> Result<String, <F as FallibleTypeFolder<I>>::Error>

where F: FallibleTypeFolder<I>,

fn fold_with<F>(self, _: &mut F) -> String

where F: TypeFolder<I>,

impl<I, A, B, C> TypeFoldable<I> for (A, B, C)

where I: Interner, A: TypeFoldable<I>, B: TypeFoldable<I>, C: TypeFoldable<I>,

fn try_fold_with<F>( self, folder: &mut F, ) -> Result<(A, B, C), <F as FallibleTypeFolder<I>>::Error>

where F: FallibleTypeFolder<I>,

impl<I, T> TypeFoldable<I> for Option<T>

where I: Interner, T: TypeFoldable<I>,

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

where F: FallibleTypeFolder<I>,

impl<I, T> TypeFoldable<I> for Box<[T]>

where I: Interner, T: TypeFoldable<I>,

fn try_fold_with<F>( self, folder: &mut F, ) -> Result<Box<[T]>, <F as FallibleTypeFolder<I>>::Error>

where F: FallibleTypeFolder<I>,

impl<I, T> TypeFoldable<I> for Box<T>

where I: Interner, T: TypeFoldable<I>,

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

where F: FallibleTypeFolder<I>,

impl<I, T> TypeFoldable<I> for Vec<T>

where I: Interner, T: TypeFoldable<I>,

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

where F: FallibleTypeFolder<I>,

impl<I, T, E> TypeFoldable<I> for Result<T, E>

where I: Interner, T: TypeFoldable<I>, E: TypeFoldable<I>,

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

where F: FallibleTypeFolder<I>,

impl<I, T, Ix> TypeFoldable<I> for IndexVec<Ix, T>

where I: Interner, T: TypeFoldable<I>, Ix: Idx,

fn try_fold_with<F>( self, folder: &mut F, ) -> Result<IndexVec<Ix, T>, <F as FallibleTypeFolder<I>>::Error>

where F: FallibleTypeFolder<I>,

impl<I, T, U> TypeFoldable<I> for (T, U)

where I: Interner, T: TypeFoldable<I>, U: TypeFoldable<I>,

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

where F: FallibleTypeFolder<I>,

Implementors

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

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

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

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

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

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

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

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

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

impl<'tcx> TypeFoldable<TyCtxt<'tcx>> for rustc_trait_selection::infer::canonical::Certainty

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

impl<'tcx, N> TypeFoldable<TyCtxt<'tcx>> for ImplSource<'tcx, N>

where N: TypeFoldable<TyCtxt<'tcx>>,

impl<'tcx, N> TypeFoldable<TyCtxt<'tcx>> for ImplSourceUserDefinedData<'tcx, N>

where N: TypeFoldable<TyCtxt<'tcx>>,

impl<'tcx, O> TypeFoldable<TyCtxt<'tcx>> for Obligation<'tcx, O>

where O: TypeFoldable<TyCtxt<'tcx>>,

impl<'tcx, R> TypeFoldable<TyCtxt<'tcx>> for QueryResponse<'tcx, R>

where R: TypeFoldable<TyCtxt<'tcx>>,

impl<'tcx, T> TypeFoldable<TyCtxt<'tcx>> for Normalize<T>

where T: TypeFoldable<TyCtxt<'tcx>>,

impl<I> TypeFoldable<I> for BuiltinImplSource

where I: Interner,

impl<I> TypeFoldable<I> for rustc_trait_selection::traits::solve::Certainty

where I: Interner,

impl<I> TypeFoldable<I> for GoalSource

where I: Interner,

impl<I> TypeFoldable<I> for MaybeCause

where I: Interner,

impl<I> TypeFoldable<I> for ProbeKind<I>

where I: Interner, Result<Canonical<I, Response<I>>, NoSolution>: TypeFoldable<I>, CandidateSource<I>: TypeFoldable<I>,

impl<I> TypeFoldable<I> for IntVarValue

where I: Interner,

impl<I> TypeFoldable<I> for CanonicalTyVarKind

where I: Interner,

impl<I> TypeFoldable<I> for CanonicalVarKind<I>

where I: Interner, <I as Interner>::PlaceholderTy: TypeFoldable<I>, <I as Interner>::PlaceholderRegion: TypeFoldable<I>, <I as Interner>::PlaceholderConst: TypeFoldable<I>,

impl<I> TypeFoldable<I> for AliasRelationDirection

where I: Interner,

impl<I> TypeFoldable<I> for AliasTyKind

where I: Interner,

impl<I> TypeFoldable<I> for BoundConstness

where I: Interner,

impl<I> TypeFoldable<I> for ClauseKind<I>

where I: Interner, TraitPredicate<I>: TypeFoldable<I>, OutlivesPredicate<I, <I as Interner>::Region>: TypeFoldable<I>, OutlivesPredicate<I, <I as Interner>::Ty>: TypeFoldable<I>, ProjectionPredicate<I>: TypeFoldable<I>, <I as Interner>::Const: TypeFoldable<I>, <I as Interner>::Ty: TypeFoldable<I>, <I as Interner>::GenericArg: TypeFoldable<I>,

impl<I> TypeFoldable<I> for ExistentialPredicate<I>

where I: Interner, ExistentialTraitRef<I>: TypeFoldable<I>, ExistentialProjection<I>: TypeFoldable<I>, <I as Interner>::DefId: TypeFoldable<I>,

impl<I> TypeFoldable<I> for FloatTy

where I: Interner,

impl<I> TypeFoldable<I> for InferTy

where I: Interner,

impl<I> TypeFoldable<I> for PredicateKind<I>

where I: Interner, ClauseKind<I>: TypeFoldable<I>, <I as Interner>::DefId: TypeFoldable<I>, SubtypePredicate<I>: TypeFoldable<I>, CoercePredicate<I>: TypeFoldable<I>, <I as Interner>::Const: TypeFoldable<I>, NormalizesTo<I>: TypeFoldable<I>, <I as Interner>::Term: TypeFoldable<I>,

impl<I> TypeFoldable<I> for PredicatePolarity

where I: Interner,

impl<I> TypeFoldable<I> for Variance

where I: Interner,

impl<I> TypeFoldable<I> for ExternalConstraintsData<I>

where I: Interner, Vec<OutlivesPredicate<I, <I as Interner>::GenericArg>>: TypeFoldable<I>, Vec<(OpaqueTypeKey<I>, <I as Interner>::Ty)>: TypeFoldable<I>, NestedNormalizationGoals<I>: TypeFoldable<I>,

impl<I> TypeFoldable<I> for NestedNormalizationGoals<I>

where I: Interner, Vec<(GoalSource, Goal<I, <I as Interner>::Predicate>)>: TypeFoldable<I>,

impl<I> TypeFoldable<I> for NoSolution

where I: Interner,

impl<I> TypeFoldable<I> for PredefinedOpaquesData<I>

where I: Interner, Vec<(OpaqueTypeKey<I>, <I as Interner>::Ty)>: TypeFoldable<I>,

impl<I> TypeFoldable<I> for Response<I>

where I: Interner, CanonicalVarValues<I>: TypeFoldable<I>, <I as Interner>::ExternalConstraints: TypeFoldable<I>,

impl<I> TypeFoldable<I> for AliasTerm<I>

where I: Interner, <I as Interner>::GenericArgs: TypeFoldable<I>, <I as Interner>::DefId: TypeFoldable<I>,

impl<I> TypeFoldable<I> for AliasTy<I>

where I: Interner, <I as Interner>::GenericArgs: TypeFoldable<I>, <I as Interner>::DefId: TypeFoldable<I>,

impl<I> TypeFoldable<I> for CanonicalVarInfo<I>

where I: Interner, CanonicalVarKind<I>: TypeFoldable<I>,

impl<I> TypeFoldable<I> for CanonicalVarValues<I>

where I: Interner, <I as Interner>::GenericArgs: TypeFoldable<I>,

impl<I> TypeFoldable<I> for ClosureArgs<I>

where I: Interner, <I as Interner>::GenericArgs: TypeFoldable<I>,

impl<I> TypeFoldable<I> for CoercePredicate<I>

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

impl<I> TypeFoldable<I> for CoroutineArgs<I>

where I: Interner, <I as Interner>::GenericArgs: TypeFoldable<I>,

impl<I> TypeFoldable<I> for CoroutineClosureArgs<I>

where I: Interner, <I as Interner>::GenericArgs: TypeFoldable<I>,

impl<I> TypeFoldable<I> for CoroutineClosureSignature<I>

where I: Interner, <I as Interner>::Ty: TypeFoldable<I>, <I as Interner>::Safety: TypeFoldable<I>, <I as Interner>::Abi: TypeFoldable<I>,

impl<I> TypeFoldable<I> for DebruijnIndex

where I: Interner,

impl<I> TypeFoldable<I> for ExistentialProjection<I>

where I: Interner, <I as Interner>::DefId: TypeFoldable<I>, <I as Interner>::GenericArgs: TypeFoldable<I>, <I as Interner>::Term: TypeFoldable<I>,

impl<I> TypeFoldable<I> for ExistentialTraitRef<I>

where I: Interner, <I as Interner>::DefId: TypeFoldable<I>, <I as Interner>::GenericArgs: TypeFoldable<I>,

impl<I> TypeFoldable<I> for FnSig<I>

where I: Interner, <I as Interner>::Tys: TypeFoldable<I>, <I as Interner>::Safety: TypeFoldable<I>, <I as Interner>::Abi: TypeFoldable<I>,

impl<I> TypeFoldable<I> for GenSig<I>

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

impl<I> TypeFoldable<I> for NormalizesTo<I>

where I: Interner, AliasTerm<I>: TypeFoldable<I>, <I as Interner>::Term: TypeFoldable<I>,

impl<I> TypeFoldable<I> for OpaqueTypeKey<I>

where I: Interner, <I as Interner>::LocalDefId: TypeFoldable<I>, <I as Interner>::GenericArgs: TypeFoldable<I>,

impl<I> TypeFoldable<I> for ProjectionPredicate<I>

where I: Interner, AliasTerm<I>: TypeFoldable<I>, <I as Interner>::Term: TypeFoldable<I>,

impl<I> TypeFoldable<I> for RegionVid

where I: Interner,

impl<I> TypeFoldable<I> for SubtypePredicate<I>

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

impl<I> TypeFoldable<I> for TraitPredicate<I>

where I: Interner, TraitRef<I>: TypeFoldable<I>,

impl<I> TypeFoldable<I> for TraitRef<I>

where I: Interner, <I as Interner>::DefId: TypeFoldable<I>, <I as Interner>::GenericArgs: TypeFoldable<I>,

impl<I> TypeFoldable<I> for TypeAndMut<I>

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

impl<I> TypeFoldable<I> for rustc_trait_selection::infer::canonical::ir::UnevaluatedConst<I>

where I: Interner, <I as Interner>::DefId: TypeFoldable<I>, <I as Interner>::GenericArgs: TypeFoldable<I>,

impl<I> TypeFoldable<I> for UniverseIndex

where I: Interner,

impl<I, A> TypeFoldable<I> for OutlivesPredicate<I, A>

where I: Interner, A: TypeFoldable<I>, <I as Interner>::Region: TypeFoldable<I>,

impl<I, P> TypeFoldable<I> for Goal<I, P>

where I: Interner, <I as Interner>::ParamEnv: TypeFoldable<I>, P: TypeFoldable<I>,

impl<I, P> TypeFoldable<I> for QueryInput<I, P>

where I: Interner, Goal<I, P>: TypeFoldable<I>, <I as Interner>::PredefinedOpaques: TypeFoldable<I>,

impl<I, T> !TypeFoldable<I> for EarlyBinder<I, T>

where I: Interner,

For early binders, you should first call instantiate before using any visitors.

impl<I, T> TypeFoldable<I> for State<I, T>

where I: Interner, CanonicalVarValues<I>: TypeFoldable<I>, T: TypeFoldable<I>,

impl<I, T> TypeFoldable<I> for Arc<T>

where I: Interner, T: TypeFoldable<I>,

impl<I, T> TypeFoldable<I> for Binder<I, T>

where I: Interner, T: TypeFoldable<I>,

impl<I, V> TypeFoldable<I> for Canonical<I, V>

where I: Interner, V: TypeFoldable<I>, <I as Interner>::DefiningOpaqueTypes: TypeFoldable<I>, <I as Interner>::CanonicalVars: TypeFoldable<I>,

impl<T, I> TypeFoldable<I> for ExpectedFound<T>

where I: Interner, T: TypeFoldable<I>,