Rename fold_subitems_with to super_fold_with

jseyfried · jseyfried · commit 632756396375 · 2016-01-07T00:42:30.000Z
diff --git a/src/librustc/middle/infer/combine.rs b/src/librustc/middle/infer/combine.rs
@@ -318,7 +318,7 @@ impl<'cx, 'tcx> ty::fold::TypeFolder<'tcx> for Generalizer<'cx, 'tcx> {
                 }
             }
             _ => {
-                t.fold_subitems_with(self)
+                t.super_fold_with(self)
             }
         }
     }
diff --git a/src/librustc/middle/infer/freshen.rs b/src/librustc/middle/infer/freshen.rs
@@ -168,7 +168,7 @@ impl<'a, 'tcx> TypeFolder<'tcx> for TypeFreshener<'a, 'tcx> {
             ty::TyTuple(..) |
             ty::TyProjection(..) |
             ty::TyParam(..) => {
-                t.fold_subitems_with(self)
+                t.super_fold_with(self)
             }
         }
     }
diff --git a/src/librustc/middle/infer/resolve.rs b/src/librustc/middle/infer/resolve.rs
@@ -39,7 +39,7 @@ impl<'a, 'tcx> ty::fold::TypeFolder<'tcx> for OpportunisticTypeResolver<'a, 'tcx
             t // micro-optimize -- if there is nothing in this type that this fold affects...
         } else {
             let t0 = self.infcx.shallow_resolve(t);
-            t0.fold_subitems_with(self)
+            t0.super_fold_with(self)
         }
     }
 }
@@ -67,7 +67,7 @@ impl<'a, 'tcx> ty::fold::TypeFolder<'tcx> for OpportunisticTypeAndRegionResolver
             t // micro-optimize -- if there is nothing in this type that this fold affects...
         } else {
             let t0 = self.infcx.shallow_resolve(t);
-            t0.fold_subitems_with(self)
+            t0.super_fold_with(self)
         }
     }
 
@@ -132,7 +132,7 @@ impl<'a, 'tcx> ty::fold::TypeFolder<'tcx> for FullTypeResolver<'a, 'tcx> {
                                 t));
                 }
                 _ => {
-                    t.fold_subitems_with(self)
+                    t.super_fold_with(self)
                 }
             }
         }
diff --git a/src/librustc/middle/subst.rs b/src/librustc/middle/subst.rs
@@ -674,7 +674,7 @@ impl<'a, 'tcx> TypeFolder<'tcx> for SubstFolder<'a, 'tcx> {
                 self.ty_for_param(p, t)
             }
             _ => {
-                t.fold_subitems_with(self)
+                t.super_fold_with(self)
             }
         };
 
diff --git a/src/librustc/middle/traits/project.rs b/src/librustc/middle/traits/project.rs
@@ -273,7 +273,7 @@ impl<'a,'b,'tcx> TypeFolder<'tcx> for AssociatedTypeNormalizer<'a,'b,'tcx> {
         // normalize it when we instantiate those bound regions (which
         // should occur eventually).
 
-        let ty = ty.fold_subitems_with(self);
+        let ty = ty.super_fold_with(self);
         match ty.sty {
             ty::TyProjection(ref data) if !data.has_escaping_regions() => { // (*)
 
diff --git a/src/librustc/middle/traits/structural_impls.rs b/src/librustc/middle/traits/structural_impls.rs
@@ -132,87 +132,87 @@ impl<'tcx> fmt::Debug for traits::MismatchedProjectionTypes<'tcx> {
 
 impl<'tcx, O: TypeFoldable<'tcx>> TypeFoldable<'tcx> for traits::Obligation<'tcx, O>
 {
-    fn fold_with<F:TypeFolder<'tcx>>(&self, folder: &mut F) -> traits::Obligation<'tcx, O> {
+    fn super_fold_with<F:TypeFolder<'tcx>>(&self, folder: &mut F) -> Self {
         traits::Obligation {
             cause: self.cause.clone(),
             recursion_depth: self.recursion_depth,
             predicate: self.predicate.fold_with(folder),
         }
     }
 
-    fn visit_with<V: TypeVisitor<'tcx>>(&self, visitor: &mut V) -> bool {
+    fn super_visit_with<V: TypeVisitor<'tcx>>(&self, visitor: &mut V) -> bool {
         self.predicate.visit_with(visitor)
     }
 }
 
 impl<'tcx, N: TypeFoldable<'tcx>> TypeFoldable<'tcx> for traits::VtableImplData<'tcx, N> {
-    fn fold_with<F:TypeFolder<'tcx>>(&self, folder: &mut F) -> traits::VtableImplData<'tcx, N> {
+    fn super_fold_with<F:TypeFolder<'tcx>>(&self, folder: &mut F) -> Self {
         traits::VtableImplData {
             impl_def_id: self.impl_def_id,
             substs: self.substs.fold_with(folder),
             nested: self.nested.fold_with(folder),
         }
     }
 
-    fn visit_with<V: TypeVisitor<'tcx>>(&self, visitor: &mut V) -> bool {
+    fn super_visit_with<V: TypeVisitor<'tcx>>(&self, visitor: &mut V) -> bool {
         self.substs.visit_with(visitor) || self.nested.visit_with(visitor)
     }
 }
 
 impl<'tcx, N: TypeFoldable<'tcx>> TypeFoldable<'tcx> for traits::VtableClosureData<'tcx, N> {
-    fn fold_with<F:TypeFolder<'tcx>>(&self, folder: &mut F) -> traits::VtableClosureData<'tcx, N> {
+    fn super_fold_with<F:TypeFolder<'tcx>>(&self, folder: &mut F) -> Self {
         traits::VtableClosureData {
             closure_def_id: self.closure_def_id,
             substs: self.substs.fold_with(folder),
             nested: self.nested.fold_with(folder),
         }
     }
 
-    fn visit_with<V: TypeVisitor<'tcx>>(&self, visitor: &mut V) -> bool {
+    fn super_visit_with<V: TypeVisitor<'tcx>>(&self, visitor: &mut V) -> bool {
         self.substs.visit_with(visitor) || self.nested.visit_with(visitor)
     }
 }
 
 impl<'tcx, N: TypeFoldable<'tcx>> TypeFoldable<'tcx> for traits::VtableDefaultImplData<N> {
-    fn fold_with<F:TypeFolder<'tcx>>(&self, folder: &mut F) -> traits::VtableDefaultImplData<N> {
+    fn super_fold_with<F:TypeFolder<'tcx>>(&self, folder: &mut F) -> Self {
         traits::VtableDefaultImplData {
             trait_def_id: self.trait_def_id,
             nested: self.nested.fold_with(folder),
         }
     }
 
-    fn visit_with<V: TypeVisitor<'tcx>>(&self, visitor: &mut V) -> bool {
+    fn super_visit_with<V: TypeVisitor<'tcx>>(&self, visitor: &mut V) -> bool {
         self.nested.visit_with(visitor)
     }
 }
 
 impl<'tcx, N: TypeFoldable<'tcx>> TypeFoldable<'tcx> for traits::VtableBuiltinData<N> {
-    fn fold_with<F:TypeFolder<'tcx>>(&self, folder: &mut F) -> traits::VtableBuiltinData<N> {
+    fn super_fold_with<F:TypeFolder<'tcx>>(&self, folder: &mut F) -> Self {
         traits::VtableBuiltinData {
             nested: self.nested.fold_with(folder),
         }
     }
 
-    fn visit_with<V: TypeVisitor<'tcx>>(&self, visitor: &mut V) -> bool {
+    fn super_visit_with<V: TypeVisitor<'tcx>>(&self, visitor: &mut V) -> bool {
         self.nested.visit_with(visitor)
     }
 }
 
 impl<'tcx> TypeFoldable<'tcx> for traits::VtableObjectData<'tcx> {
-    fn fold_with<F:TypeFolder<'tcx>>(&self, folder: &mut F) -> traits::VtableObjectData<'tcx> {
+    fn super_fold_with<F:TypeFolder<'tcx>>(&self, folder: &mut F) -> Self {
         traits::VtableObjectData {
             upcast_trait_ref: self.upcast_trait_ref.fold_with(folder),
             vtable_base: self.vtable_base
         }
     }
 
-    fn visit_with<V: TypeVisitor<'tcx>>(&self, visitor: &mut V) -> bool {
+    fn super_visit_with<V: TypeVisitor<'tcx>>(&self, visitor: &mut V) -> bool {
         self.upcast_trait_ref.visit_with(visitor)
     }
 }
 
 impl<'tcx, N: TypeFoldable<'tcx>> TypeFoldable<'tcx> for traits::Vtable<'tcx, N> {
-    fn fold_with<F:TypeFolder<'tcx>>(&self, folder: &mut F) -> traits::Vtable<'tcx, N> {
+    fn super_fold_with<F:TypeFolder<'tcx>>(&self, folder: &mut F) -> Self {
         match *self {
             traits::VtableImpl(ref v) => traits::VtableImpl(v.fold_with(folder)),
             traits::VtableDefaultImpl(ref t) => traits::VtableDefaultImpl(t.fold_with(folder)),
@@ -228,7 +228,7 @@ impl<'tcx, N: TypeFoldable<'tcx>> TypeFoldable<'tcx> for traits::Vtable<'tcx, N>
         }
     }
 
-    fn visit_with<V: TypeVisitor<'tcx>>(&self, visitor: &mut V) -> bool {
+    fn super_visit_with<V: TypeVisitor<'tcx>>(&self, visitor: &mut V) -> bool {
         match *self {
             traits::VtableImpl(ref v) => v.visit_with(visitor),
             traits::VtableDefaultImpl(ref t) => t.visit_with(visitor),
@@ -242,14 +242,14 @@ impl<'tcx, N: TypeFoldable<'tcx>> TypeFoldable<'tcx> for traits::Vtable<'tcx, N>
 }
 
 impl<'tcx, T: TypeFoldable<'tcx>> TypeFoldable<'tcx> for Normalized<'tcx, T> {
-    fn fold_with<F: TypeFolder<'tcx>>(&self, folder: &mut F) -> Normalized<'tcx, T> {
+    fn super_fold_with<F: TypeFolder<'tcx>>(&self, folder: &mut F) -> Self {
         Normalized {
             value: self.value.fold_with(folder),
             obligations: self.obligations.fold_with(folder),
         }
     }
 
-    fn visit_with<V: TypeVisitor<'tcx>>(&self, visitor: &mut V) -> bool {
+    fn super_visit_with<V: TypeVisitor<'tcx>>(&self, visitor: &mut V) -> bool {
         self.value.visit_with(visitor) || self.obligations.visit_with(visitor)
     }
 }
diff --git a/src/librustc/middle/ty/fold.rs b/src/librustc/middle/ty/fold.rs
@@ -14,18 +14,18 @@
 //! instance of a "folder" (a type which implements `TypeFolder`). Then
 //! the setup is intended to be:
 //!
-//!   T.fold_with(F) --calls--> F.fold_T(T) --calls--> T.fold_subitems_with(F)
+//!   T.fold_with(F) --calls--> F.fold_T(T) --calls--> T.super_fold_with(F)
 //!
 //! This way, when you define a new folder F, you can override
-//! `fold_T()` to customize the behavior, and invoke `T.fold_subitems_with()`
+//! `fold_T()` to customize the behavior, and invoke `T.super_fold_with()`
 //! to get the original behavior. Meanwhile, to actually fold
 //! something, you can just write `T.fold_with(F)`, which is
 //! convenient. (Note that `fold_with` will also transparently handle
 //! things like a `Vec<T>` where T is foldable and so on.)
 //!
 //! In this ideal setup, the only function that actually *does*
-//! anything is `T.fold_subitems_with()`, which traverses the type `T`.
-//! Moreover, `T.fold_subitems_with()` should only ever call `T.fold_with()`.
+//! anything is `T.super_fold_with()`, which traverses the type `T`.
+//! Moreover, `T.super_fold_with()` should only ever call `T.fold_with()`.
 //!
 //! In some cases, we follow a degenerate pattern where we do not have
 //! a `fold_T` method. Instead, `T.fold_with` traverses the structure directly.
@@ -35,7 +35,7 @@
 //! proper thing.
 //!
 //! A `TypeFoldable` T can also be visited by a `TypeVisitor` V using similar setup:
-//!   T.visit_with(V) --calls--> V.visit_T(T) --calls--> T.visit_subitems_with(V).
+//!   T.visit_with(V) --calls--> V.visit_T(T) --calls--> T.super_visit_with(V).
 //! These methods return true to indicate that the visitor has found what it is looking for
 //! and does not need to visit anything else.
 
@@ -50,14 +50,14 @@ use util::nodemap::{FnvHashMap, FnvHashSet};
 /// The TypeFoldable trait is implemented for every type that can be folded.
 /// Basically, every type that has a corresponding method in TypeFolder.
 pub trait TypeFoldable<'tcx>: fmt::Debug + Clone {
-    fn fold_with<F: TypeFolder<'tcx>>(&self, folder: &mut F) -> Self;
-    fn fold_subitems_with<F: TypeFolder<'tcx>>(&self, folder: &mut F) -> Self {
-        self.fold_with(folder)
+    fn super_fold_with<F: TypeFolder<'tcx>>(&self, folder: &mut F) -> Self;
+    fn fold_with<F: TypeFolder<'tcx>>(&self, folder: &mut F) -> Self {
+        self.super_fold_with(folder)
     }
 
-    fn visit_with<V: TypeVisitor<'tcx>>(&self, visitor: &mut V) -> bool;
-    fn visit_subitems_with<V: TypeVisitor<'tcx>>(&self, visitor: &mut V) -> bool {
-        self.visit_with(visitor)
+    fn super_visit_with<V: TypeVisitor<'tcx>>(&self, visitor: &mut V) -> bool;
+    fn visit_with<V: TypeVisitor<'tcx>>(&self, visitor: &mut V) -> bool {
+        self.super_visit_with(visitor)
     }
 
     fn has_regions_escaping_depth(&self, depth: u32) -> bool {
@@ -131,64 +131,64 @@ pub trait TypeFolder<'tcx> : Sized {
         where T : TypeFoldable<'tcx>
     {
         // FIXME(#20526) this should replace `enter_region_binder`/`exit_region_binder`.
-        t.fold_subitems_with(self)
+        t.super_fold_with(self)
     }
 
     fn fold_ty(&mut self, t: Ty<'tcx>) -> Ty<'tcx> {
-        t.fold_subitems_with(self)
+        t.super_fold_with(self)
     }
 
     fn fold_mt(&mut self, t: &ty::TypeAndMut<'tcx>) -> ty::TypeAndMut<'tcx> {
-        t.fold_subitems_with(self)
+        t.super_fold_with(self)
     }
 
     fn fold_trait_ref(&mut self, t: &ty::TraitRef<'tcx>) -> ty::TraitRef<'tcx> {
-        t.fold_subitems_with(self)
+        t.super_fold_with(self)
     }
 
     fn fold_substs(&mut self,
                    substs: &subst::Substs<'tcx>)
                    -> subst::Substs<'tcx> {
-        substs.fold_subitems_with(self)
+        substs.super_fold_with(self)
     }
 
     fn fold_fn_sig(&mut self,
                    sig: &ty::FnSig<'tcx>)
                    -> ty::FnSig<'tcx> {
-        sig.fold_subitems_with(self)
+        sig.super_fold_with(self)
     }
 
     fn fold_output(&mut self,
                       output: &ty::FnOutput<'tcx>)
                       -> ty::FnOutput<'tcx> {
-        output.fold_subitems_with(self)
+        output.super_fold_with(self)
     }
 
     fn fold_bare_fn_ty(&mut self,
                        fty: &ty::BareFnTy<'tcx>)
                        -> ty::BareFnTy<'tcx>
     {
-        fty.fold_subitems_with(self)
+        fty.super_fold_with(self)
     }
 
     fn fold_closure_ty(&mut self,
                        fty: &ty::ClosureTy<'tcx>)
                        -> ty::ClosureTy<'tcx> {
-        fty.fold_subitems_with(self)
+        fty.super_fold_with(self)
     }
 
     fn fold_region(&mut self, r: ty::Region) -> ty::Region {
-        r.fold_subitems_with(self)
+        r.super_fold_with(self)
     }
 
     fn fold_existential_bounds(&mut self, s: &ty::ExistentialBounds<'tcx>)
                                -> ty::ExistentialBounds<'tcx> {
-        s.fold_subitems_with(self)
+        s.super_fold_with(self)
     }
 
     fn fold_autoref(&mut self, ar: &adjustment::AutoRef<'tcx>)
                     -> adjustment::AutoRef<'tcx> {
-        ar.fold_subitems_with(self)
+        ar.super_fold_with(self)
     }
 }
 
@@ -197,11 +197,11 @@ pub trait TypeVisitor<'tcx> : Sized {
     fn exit_region_binder(&mut self) { }
 
     fn visit_ty(&mut self, t: Ty<'tcx>) -> bool {
-        t.visit_subitems_with(self)
+        t.super_visit_with(self)
     }
 
     fn visit_region(&mut self, r: ty::Region) -> bool {
-        r.visit_subitems_with(self)
+        r.super_visit_with(self)
     }
 }
 
@@ -219,7 +219,7 @@ impl<'a, 'tcx, F> TypeFolder<'tcx> for BottomUpFolder<'a, 'tcx, F> where
     fn tcx(&self) -> &ty::ctxt<'tcx> { self.tcx }
 
     fn fold_ty(&mut self, ty: Ty<'tcx>) -> Ty<'tcx> {
-        let t1 = ty.fold_subitems_with(self);
+        let t1 = ty.super_fold_with(self);
         (self.fldop)(t1)
     }
 }
@@ -447,7 +447,7 @@ impl<'a, 'tcx> TypeFolder<'tcx> for RegionReplacer<'a, 'tcx>
             return t;
         }
 
-        t.fold_subitems_with(self)
+        t.super_fold_with(self)
     }
 
     fn fold_region(&mut self, r: ty::Region) -> ty::Region {
@@ -498,7 +498,7 @@ impl<'tcx> ty::ctxt<'tcx> {
                     Some(u) => return u
                 }
 
-                let t_norm = ty.fold_subitems_with(self);
+                let t_norm = ty.super_fold_with(self);
                 self.tcx().normalized_cache.borrow_mut().insert(ty, t_norm);
                 return t_norm;
             }
@@ -507,7 +507,7 @@ impl<'tcx> ty::ctxt<'tcx> {
                 where T : TypeFoldable<'tcx>
             {
                 let u = self.tcx().anonymize_late_bound_regions(t);
-                u.fold_subitems_with(self)
+                u.super_fold_with(self)
             }
 
             fn fold_region(&mut self, r: ty::Region) -> ty::Region {
diff --git a/src/librustc/middle/ty/structural_impls.rs b/src/librustc/middle/ty/structural_impls.rs
diff --git a/src/librustc/util/ppaux.rs b/src/librustc/util/ppaux.rs

Original file line number	Diff line number	Diff line change
`@@ -318,7 +318,7 @@ impl<'cx, 'tcx> ty::fold::TypeFolder<'tcx> for Generalizer<'cx, 'tcx> {`
`318`	`318`	`}`
`319`	`319`	`}`
`320`	`320`	`_ => {`
`321`		`- t.fold_subitems_with(self)`
	`321`	`+ t.super_fold_with(self)`
`322`	`322`	`}`
`323`	`323`	`}`
`324`	`324`	`}`
Original file line number	Diff line number	Diff line change
`@@ -168,7 +168,7 @@ impl<'a, 'tcx> TypeFolder<'tcx> for TypeFreshener<'a, 'tcx> {`
`168`	`168`	`ty::TyTuple(..) \|`
`169`	`169`	`ty::TyProjection(..) \|`
`170`	`170`	`ty::TyParam(..) => {`
`171`		`- t.fold_subitems_with(self)`
	`171`	`+ t.super_fold_with(self)`
`172`	`172`	`}`
`173`	`173`	`}`
`174`	`174`	`}`
Original file line number	Diff line number	Diff line change
`@@ -39,7 +39,7 @@ impl<'a, 'tcx> ty::fold::TypeFolder<'tcx> for OpportunisticTypeResolver<'a, 'tcx`
`39`	`39`	`t // micro-optimize -- if there is nothing in this type that this fold affects...`
`40`	`40`	`} else {`
`41`	`41`	`let t0 = self.infcx.shallow_resolve(t);`
`42`		`- t0.fold_subitems_with(self)`
	`42`	`+ t0.super_fold_with(self)`
`43`	`43`	`}`
`44`	`44`	`}`
`45`	`45`	`}`
`@@ -67,7 +67,7 @@ impl<'a, 'tcx> ty::fold::TypeFolder<'tcx> for OpportunisticTypeAndRegionResolver`
`67`	`67`	`t // micro-optimize -- if there is nothing in this type that this fold affects...`
`68`	`68`	`} else {`
`69`	`69`	`let t0 = self.infcx.shallow_resolve(t);`
`70`		`- t0.fold_subitems_with(self)`
	`70`	`+ t0.super_fold_with(self)`
`71`	`71`	`}`
`72`	`72`	`}`
`73`	`73`
`@@ -132,7 +132,7 @@ impl<'a, 'tcx> ty::fold::TypeFolder<'tcx> for FullTypeResolver<'a, 'tcx> {`
`132`	`132`	`t));`
`133`	`133`	`}`
`134`	`134`	`_ => {`
`135`		`- t.fold_subitems_with(self)`
	`135`	`+ t.super_fold_with(self)`
`136`	`136`	`}`
`137`	`137`	`}`
`138`	`138`	`}`
Original file line number	Diff line number	Diff line change
`@@ -674,7 +674,7 @@ impl<'a, 'tcx> TypeFolder<'tcx> for SubstFolder<'a, 'tcx> {`
`674`	`674`	`self.ty_for_param(p, t)`
`675`	`675`	`}`
`676`	`676`	`_ => {`
`677`		`- t.fold_subitems_with(self)`
	`677`	`+ t.super_fold_with(self)`
`678`	`678`	`}`
`679`	`679`	`};`
`680`	`680`
Original file line number	Diff line number	Diff line change
`@@ -132,87 +132,87 @@ impl<'tcx> fmt::Debug for traits::MismatchedProjectionTypes<'tcx> {`
`132`	`132`
`133`	`133`	`impl<'tcx, O: TypeFoldable<'tcx>> TypeFoldable<'tcx> for traits::Obligation<'tcx, O>`
`134`	`134`	`{`
`135`		`- fn fold_with<F:TypeFolder<'tcx>>(&self, folder: &mut F) -> traits::Obligation<'tcx, O> {`
	`135`	`+ fn super_fold_with<F:TypeFolder<'tcx>>(&self, folder: &mut F) -> Self {`
`136`	`136`	`traits::Obligation {`
`137`	`137`	`cause: self.cause.clone(),`
`138`	`138`	`recursion_depth: self.recursion_depth,`
`139`	`139`	`predicate: self.predicate.fold_with(folder),`
`140`	`140`	`}`
`141`	`141`	`}`
`142`	`142`
`143`		`- fn visit_with<V: TypeVisitor<'tcx>>(&self, visitor: &mut V) -> bool {`
	`143`	`+ fn super_visit_with<V: TypeVisitor<'tcx>>(&self, visitor: &mut V) -> bool {`
`144`	`144`	`self.predicate.visit_with(visitor)`
`145`	`145`	`}`
`146`	`146`	`}`
`147`	`147`
`148`	`148`	`impl<'tcx, N: TypeFoldable<'tcx>> TypeFoldable<'tcx> for traits::VtableImplData<'tcx, N> {`
`149`		`- fn fold_with<F:TypeFolder<'tcx>>(&self, folder: &mut F) -> traits::VtableImplData<'tcx, N> {`
	`149`	`+ fn super_fold_with<F:TypeFolder<'tcx>>(&self, folder: &mut F) -> Self {`
`150`	`150`	`traits::VtableImplData {`
`151`	`151`	`impl_def_id: self.impl_def_id,`
`152`	`152`	`substs: self.substs.fold_with(folder),`
`153`	`153`	`nested: self.nested.fold_with(folder),`
`154`	`154`	`}`
`155`	`155`	`}`
`156`	`156`
`157`		`- fn visit_with<V: TypeVisitor<'tcx>>(&self, visitor: &mut V) -> bool {`
	`157`	`+ fn super_visit_with<V: TypeVisitor<'tcx>>(&self, visitor: &mut V) -> bool {`
`158`	`158`	`self.substs.visit_with(visitor) \|\| self.nested.visit_with(visitor)`
`159`	`159`	`}`
`160`	`160`	`}`
`161`	`161`
`162`	`162`	`impl<'tcx, N: TypeFoldable<'tcx>> TypeFoldable<'tcx> for traits::VtableClosureData<'tcx, N> {`
`163`		`- fn fold_with<F:TypeFolder<'tcx>>(&self, folder: &mut F) -> traits::VtableClosureData<'tcx, N> {`
	`163`	`+ fn super_fold_with<F:TypeFolder<'tcx>>(&self, folder: &mut F) -> Self {`
`164`	`164`	`traits::VtableClosureData {`
`165`	`165`	`closure_def_id: self.closure_def_id,`
`166`	`166`	`substs: self.substs.fold_with(folder),`
`167`	`167`	`nested: self.nested.fold_with(folder),`
`168`	`168`	`}`
`169`	`169`	`}`
`170`	`170`
`171`		`- fn visit_with<V: TypeVisitor<'tcx>>(&self, visitor: &mut V) -> bool {`
	`171`	`+ fn super_visit_with<V: TypeVisitor<'tcx>>(&self, visitor: &mut V) -> bool {`
`172`	`172`	`self.substs.visit_with(visitor) \|\| self.nested.visit_with(visitor)`
`173`	`173`	`}`
`174`	`174`	`}`
`175`	`175`
`176`	`176`	`impl<'tcx, N: TypeFoldable<'tcx>> TypeFoldable<'tcx> for traits::VtableDefaultImplData<N> {`
`177`		`- fn fold_with<F:TypeFolder<'tcx>>(&self, folder: &mut F) -> traits::VtableDefaultImplData<N> {`
	`177`	`+ fn super_fold_with<F:TypeFolder<'tcx>>(&self, folder: &mut F) -> Self {`
`178`	`178`	`traits::VtableDefaultImplData {`
`179`	`179`	`trait_def_id: self.trait_def_id,`
`180`	`180`	`nested: self.nested.fold_with(folder),`
`181`	`181`	`}`
`182`	`182`	`}`
`183`	`183`
`184`		`- fn visit_with<V: TypeVisitor<'tcx>>(&self, visitor: &mut V) -> bool {`
	`184`	`+ fn super_visit_with<V: TypeVisitor<'tcx>>(&self, visitor: &mut V) -> bool {`
`185`	`185`	`self.nested.visit_with(visitor)`
`186`	`186`	`}`
`187`	`187`	`}`
`188`	`188`
`189`	`189`	`impl<'tcx, N: TypeFoldable<'tcx>> TypeFoldable<'tcx> for traits::VtableBuiltinData<N> {`
`190`		`- fn fold_with<F:TypeFolder<'tcx>>(&self, folder: &mut F) -> traits::VtableBuiltinData<N> {`
	`190`	`+ fn super_fold_with<F:TypeFolder<'tcx>>(&self, folder: &mut F) -> Self {`
`191`	`191`	`traits::VtableBuiltinData {`
`192`	`192`	`nested: self.nested.fold_with(folder),`
`193`	`193`	`}`
`194`	`194`	`}`
`195`	`195`
`196`		`- fn visit_with<V: TypeVisitor<'tcx>>(&self, visitor: &mut V) -> bool {`
	`196`	`+ fn super_visit_with<V: TypeVisitor<'tcx>>(&self, visitor: &mut V) -> bool {`
`197`	`197`	`self.nested.visit_with(visitor)`
`198`	`198`	`}`
`199`	`199`	`}`
`200`	`200`
`201`	`201`	`impl<'tcx> TypeFoldable<'tcx> for traits::VtableObjectData<'tcx> {`
`202`		`- fn fold_with<F:TypeFolder<'tcx>>(&self, folder: &mut F) -> traits::VtableObjectData<'tcx> {`
	`202`	`+ fn super_fold_with<F:TypeFolder<'tcx>>(&self, folder: &mut F) -> Self {`
`203`	`203`	`traits::VtableObjectData {`
`204`	`204`	`upcast_trait_ref: self.upcast_trait_ref.fold_with(folder),`
`205`	`205`	`vtable_base: self.vtable_base`
`206`	`206`	`}`
`207`	`207`	`}`
`208`	`208`
`209`		`- fn visit_with<V: TypeVisitor<'tcx>>(&self, visitor: &mut V) -> bool {`
	`209`	`+ fn super_visit_with<V: TypeVisitor<'tcx>>(&self, visitor: &mut V) -> bool {`
`210`	`210`	`self.upcast_trait_ref.visit_with(visitor)`
`211`	`211`	`}`
`212`	`212`	`}`
`213`	`213`
`214`	`214`	`impl<'tcx, N: TypeFoldable<'tcx>> TypeFoldable<'tcx> for traits::Vtable<'tcx, N> {`
`215`		`- fn fold_with<F:TypeFolder<'tcx>>(&self, folder: &mut F) -> traits::Vtable<'tcx, N> {`
	`215`	`+ fn super_fold_with<F:TypeFolder<'tcx>>(&self, folder: &mut F) -> Self {`
`216`	`216`	`match *self {`
`217`	`217`	`traits::VtableImpl(ref v) => traits::VtableImpl(v.fold_with(folder)),`
`218`	`218`	`traits::VtableDefaultImpl(ref t) => traits::VtableDefaultImpl(t.fold_with(folder)),`
`@@ -228,7 +228,7 @@ impl<'tcx, N: TypeFoldable<'tcx>> TypeFoldable<'tcx> for traits::Vtable<'tcx, N>`
`228`	`228`	`}`
`229`	`229`	`}`
`230`	`230`
`231`		`- fn visit_with<V: TypeVisitor<'tcx>>(&self, visitor: &mut V) -> bool {`
	`231`	`+ fn super_visit_with<V: TypeVisitor<'tcx>>(&self, visitor: &mut V) -> bool {`
`232`	`232`	`match *self {`
`233`	`233`	`traits::VtableImpl(ref v) => v.visit_with(visitor),`
`234`	`234`	`traits::VtableDefaultImpl(ref t) => t.visit_with(visitor),`
`@@ -242,14 +242,14 @@ impl<'tcx, N: TypeFoldable<'tcx>> TypeFoldable<'tcx> for traits::Vtable<'tcx, N>`
`242`	`242`	`}`
`243`	`243`
`244`	`244`	`impl<'tcx, T: TypeFoldable<'tcx>> TypeFoldable<'tcx> for Normalized<'tcx, T> {`
`245`		`- fn fold_with<F: TypeFolder<'tcx>>(&self, folder: &mut F) -> Normalized<'tcx, T> {`
	`245`	`+ fn super_fold_with<F: TypeFolder<'tcx>>(&self, folder: &mut F) -> Self {`
`246`	`246`	`Normalized {`
`247`	`247`	`value: self.value.fold_with(folder),`
`248`	`248`	`obligations: self.obligations.fold_with(folder),`
`249`	`249`	`}`
`250`	`250`	`}`
`251`	`251`
`252`		`- fn visit_with<V: TypeVisitor<'tcx>>(&self, visitor: &mut V) -> bool {`
	`252`	`+ fn super_visit_with<V: TypeVisitor<'tcx>>(&self, visitor: &mut V) -> bool {`
`253`	`253`	`self.value.visit_with(visitor) \|\| self.obligations.visit_with(visitor)`
`254`	`254`	`}`
`255`	`255`	`}`