Trait 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> { ... }
}

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§

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

Provided Methods§

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

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

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

Provided Methods§

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

Dyn Compatibility§

Implementations on Foreign Types§

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

impl<I> TypeFoldable<I> for boolwhere 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) -> boolwhere F: TypeFolder<I>,

impl<I> TypeFoldable<I> for u16where 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) -> u16where F: TypeFolder<I>,

impl<I> TypeFoldable<I> for u32where 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) -> u32where F: TypeFolder<I>,

impl<I> TypeFoldable<I> for u64where 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) -> u64where 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>,

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<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> TypeFoldable<I> for ThinVec<T>
where I: Interner, T: TypeFoldable<I>,

fn try_fold_with<F>( self, folder: &mut F, ) -> Result<ThinVec<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>,