Add default to TypeFoldable::fold_with

compiler/rustc_macros/src/type_foldable.rs

@@ -28,22 +28,6 @@ pub(super) fn type_foldable_derive(mut s: synstructure::Structure<'_>) -> proc_m
         })
     });
 
-    let body_fold = s.each_variant(|vi| {
-        let bindings = vi.bindings();
-        vi.construct(|_, index| {
-            let bind = &bindings[index];
-
-            // retain value of fields with #[type_foldable(identity)]
-            if has_ignore_attr(&bind.ast().attrs, "type_foldable", "identity") {
-                bind.to_token_stream()
-            } else {
-                quote! {
-                    ::rustc_middle::ty::TypeFoldable::fold_with(#bind, __folder)
-                }
-            }
-        })
-    });
-
     s.bound_impl(
         quote!(::rustc_middle::ty::TypeFoldable<::rustc_middle::ty::TyCtxt<'tcx>>),
         quote! {
@@ -53,13 +37,6 @@ pub(super) fn type_foldable_derive(mut s: synstructure::Structure<'_>) -> proc_m
             ) -> Result<Self, __F::Error> {
                 Ok(match self { #try_body_fold })
             }
-
-            fn fold_with<__F: ::rustc_middle::ty::TypeFolder<::rustc_middle::ty::TyCtxt<'tcx>>>(
-                self,
-                __folder: &mut __F
-            ) -> Self {
-                match self { #body_fold }
-            }
         },
     )
 }

compiler/rustc_middle/src/macros.rs

@@ -66,14 +66,6 @@ macro_rules! TrivialTypeTraversalImpls {
                 ) -> ::std::result::Result<Self, F::Error> {
                     Ok(self)
                 }
-
-                #[inline]
-                fn fold_with<F: $crate::ty::TypeFolder<$crate::ty::TyCtxt<'tcx>>>(
-                    self,
-                    _: &mut F,
-                ) -> Self {
-                    self
-                }
             }
 
             impl<'tcx> $crate::ty::TypeVisitable<$crate::ty::TyCtxt<'tcx>> for $ty {

compiler/rustc_middle/src/traits/solve.rs

@@ -4,8 +4,7 @@ use rustc_type_ir as ir;
 pub use rustc_type_ir::solve::*;
 
 use crate::ty::{
-    self, FallibleTypeFolder, Ty, TyCtxt, TypeFoldable, TypeFolder, TypeVisitable, TypeVisitor,
-    try_visit,
+    self, FallibleTypeFolder, Ty, TyCtxt, TypeFoldable, TypeVisitable, TypeVisitor, try_visit,
 };
 
 pub type Goal<'tcx, P> = ir::solve::Goal<TyCtxt<'tcx>, P>;
@@ -66,21 +65,6 @@ impl<'tcx> TypeFoldable<TyCtxt<'tcx>> for ExternalConstraints<'tcx> {
                 .try_fold_with(folder)?,
         }))
     }
-
-    fn fold_with<F: TypeFolder<TyCtxt<'tcx>>>(self, folder: &mut F) -> Self {
-        // Perf testing has found that this check is slightly faster than
-        // folding and re-interning an empty `ExternalConstraintsData`.
-        // See: <https://github.com/rust-lang/rust/pull/142430>.
-        if self.is_empty() {
-            return self;
-        }
-
-        TypeFolder::cx(folder).mk_external_constraints(ExternalConstraintsData {
-            region_constraints: self.region_constraints.clone().fold_with(folder),
-            opaque_types: self.opaque_types.iter().map(|opaque| opaque.fold_with(folder)).collect(),
-            normalization_nested_goals: self.normalization_nested_goals.clone().fold_with(folder),
-        })
-    }
 }
 
 impl<'tcx> TypeVisitable<TyCtxt<'tcx>> for ExternalConstraints<'tcx> {

compiler/rustc_middle/src/ty/generic_args.rs

@@ -17,7 +17,7 @@ use smallvec::SmallVec;
 use crate::ty::codec::{TyDecoder, TyEncoder};
 use crate::ty::{
     self, ClosureArgs, CoroutineArgs, CoroutineClosureArgs, FallibleTypeFolder, InlineConstArgs,
-    Lift, List, Ty, TyCtxt, TypeFoldable, TypeFolder, TypeVisitable, TypeVisitor, VisitorResult,
+    Lift, List, Ty, TyCtxt, TypeFoldable, TypeVisitable, TypeVisitor, VisitorResult,
     walk_visitable_list,
 };
 
@@ -340,14 +340,6 @@ impl<'tcx> TypeFoldable<TyCtxt<'tcx>> for GenericArg<'tcx> {
             GenericArgKind::Const(ct) => ct.try_fold_with(folder).map(Into::into),
         }
     }
-
-    fn fold_with<F: TypeFolder<TyCtxt<'tcx>>>(self, folder: &mut F) -> Self {
-        match self.kind() {
-            GenericArgKind::Lifetime(lt) => lt.fold_with(folder).into(),
-            GenericArgKind::Type(ty) => ty.fold_with(folder).into(),
-            GenericArgKind::Const(ct) => ct.fold_with(folder).into(),
-        }
-    }
 }
 
 impl<'tcx> TypeVisitable<TyCtxt<'tcx>> for GenericArg<'tcx> {
@@ -630,27 +622,6 @@ impl<'tcx> TypeFoldable<TyCtxt<'tcx>> for GenericArgsRef<'tcx> {
             _ => ty::util::try_fold_list(self, folder, |tcx, v| tcx.mk_args(v)),
         }
     }
-
-    fn fold_with<F: TypeFolder<TyCtxt<'tcx>>>(self, folder: &mut F) -> Self {
-        // See justification for this behavior in `try_fold_with`.
-        match self.len() {
-            1 => {
-                let param0 = self[0].fold_with(folder);
-                if param0 == self[0] { self } else { folder.cx().mk_args(&[param0]) }
-            }
-            2 => {
-                let param0 = self[0].fold_with(folder);
-                let param1 = self[1].fold_with(folder);
-                if param0 == self[0] && param1 == self[1] {
-                    self
-                } else {
-                    folder.cx().mk_args(&[param0, param1])
-                }
-            }
-            0 => self,
-            _ => ty::util::fold_list(self, folder, |tcx, v| tcx.mk_args(v)),
-        }
-    }
 }
 
 impl<'tcx> TypeFoldable<TyCtxt<'tcx>> for &'tcx ty::List<Ty<'tcx>> {
@@ -686,22 +657,6 @@ impl<'tcx> TypeFoldable<TyCtxt<'tcx>> for &'tcx ty::List<Ty<'tcx>> {
             _ => ty::util::try_fold_list(self, folder, |tcx, v| tcx.mk_type_list(v)),
         }
     }
-
-    fn fold_with<F: TypeFolder<TyCtxt<'tcx>>>(self, folder: &mut F) -> Self {
-        // See comment justifying behavior in `try_fold_with`.
-        match self.len() {
-            2 => {
-                let param0 = self[0].fold_with(folder);
-                let param1 = self[1].fold_with(folder);
-                if param0 == self[0] && param1 == self[1] {
-                    self
-                } else {
-                    folder.cx().mk_type_list(&[param0, param1])
-                }
-            }
-            _ => ty::util::fold_list(self, folder, |tcx, v| tcx.mk_type_list(v)),
-        }
-    }
 }
 
 impl<'tcx, T: TypeVisitable<TyCtxt<'tcx>>> TypeVisitable<TyCtxt<'tcx>> for &'tcx ty::List<T> {

compiler/rustc_middle/src/ty/mod.rs

@@ -630,13 +630,6 @@ impl<'tcx> TypeFoldable<TyCtxt<'tcx>> for Term<'tcx> {
             ty::TermKind::Const(ct) => ct.try_fold_with(folder).map(Into::into),
         }
     }
-
-    fn fold_with<F: TypeFolder<TyCtxt<'tcx>>>(self, folder: &mut F) -> Self {
-        match self.kind() {
-            ty::TermKind::Ty(ty) => ty.fold_with(folder).into(),
-            ty::TermKind::Const(ct) => ct.fold_with(folder).into(),
-        }
-    }
 }
 
 impl<'tcx> TypeVisitable<TyCtxt<'tcx>> for Term<'tcx> {