Rename SuperFold to TypeSuperFoldable

Author: eggyal

book/src/types/operations/fold.md

@@ -29,7 +29,7 @@ folder can substitute a new type in its place.
 A common use for `TypeFoldable` is to permit a substitution -- that is,
 replacing generic type parameters with their values.
 
-## From TypeFoldable to Folder to SuperFold and back again
+## From TypeFoldable to Folder to TypeSuperFoldable and back again
 
 The overall flow of folding is like this.
 
@@ -39,7 +39,7 @@ The overall flow of folding is like this.
    callbacks in the [`Folder`] trait, invoking [`TypeFoldable::fold_with`] will in turn
    invoke the corresponding method on the [`Folder`] trait, such as `Folder::fold_ty`.
 3. The default implementation of `Folder::fold_ty`, in turn, invokes
-   `SuperFold::super_fold_with`.  This will recursively fold the
+   `TypeSuperFoldable::super_fold_with`.  This will recursively fold the
    contents of the type. In some cases, the `super_fold_with`
    implementation invokes more specialized methods on [`Folder`], such
    as [`Folder::fold_free_var_ty`], which makes it easier to write
@@ -53,7 +53,7 @@ Thus, as a user, you can customize folding by:
 * Implementing the appropriate methods to "intercept" types/lifetimes/etc at the right level of
   detail
 * In those methods, if you find a case where you would prefer not to
-  substitute a new value, then invoke `SuperFold::super_fold_with` to
+  substitute a new value, then invoke `TypeSuperFoldable::super_fold_with` to
   return to the default behavior.
 
 ## The `binders` argument
@@ -77,21 +77,21 @@ type that will result from folding.
 
 [`Result`]: https://rust-lang.github.io/chalk/chalk_ir/fold/trait.TypeFoldable.html#associatedtype.Result
 
-## When to implement the TypeFoldable and SuperFold traits
+## When to implement the TypeFoldable and TypeSuperFoldable traits
 
 Any piece of IR that represents a kind of "term" (e.g., a type, part
 of a type, or a goal, etc) in the logic should implement `TypeFoldable`. We
 also implement `TypeFoldable` for common collection types like `Vec` as well
 as tuples, references, etc.
 
-The `SuperFold` trait should only be implemented for those types that
+The `TypeSuperFoldable` trait should only be implemented for those types that
 have a callback defined on the `Folder` trait (e.g., types and
 lifetimes).
 
 ## Derives
 
 Using the `chalk-derive` crate, you can auto-derive the `TypeFoldable` trait.
-There isn't presently a derive for `SuperFold` since it is very rare
+There isn't presently a derive for `TypeSuperFoldable` since it is very rare
 to require it. The derive for `TypeFoldable` is a bit cludgy and requires:
 
 * You must import `TypeFoldable` into scope.

chalk-ir/src/fold.rs

@@ -331,9 +331,9 @@ pub trait TypeFoldable<I: Interner>: Debug {
 }
 
 /// For types where "fold" invokes a callback on the `Folder`, the
-/// `SuperFold` trait captures the recursive behavior that folds all
+/// `TypeSuperFoldable` trait captures the recursive behavior that folds all
 /// the contents of the type.
-pub trait SuperFold<I: Interner>: TypeFoldable<I> {
+pub trait TypeSuperFoldable<I: Interner>: TypeFoldable<I> {
     /// Recursively folds the value.
     fn super_fold_with<E>(
         self,
@@ -358,7 +358,7 @@ impl<I: Interner> TypeFoldable<I> for Ty<I> {
 }
 
 /// "Super fold" for a type invokes te more detailed callbacks on the type
-impl<I> SuperFold<I> for Ty<I>
+impl<I> TypeSuperFoldable<I> for Ty<I>
 where
     I: Interner,
 {
@@ -481,7 +481,7 @@ impl<I: Interner> TypeFoldable<I> for Lifetime<I> {
     }
 }
 
-impl<I> SuperFold<I> for Lifetime<I>
+impl<I> TypeSuperFoldable<I> for Lifetime<I>
 where
     I: Interner,
 {
@@ -533,7 +533,7 @@ impl<I: Interner> TypeFoldable<I> for Const<I> {
     }
 }
 
-impl<I> SuperFold<I> for Const<I>
+impl<I> TypeSuperFoldable<I> for Const<I>
 where
     I: Interner,
 {
@@ -585,7 +585,7 @@ impl<I: Interner> TypeFoldable<I> for Goal<I> {
 }
 
 /// Superfold folds recursively.
-impl<I: Interner> SuperFold<I> for Goal<I> {
+impl<I: Interner> TypeSuperFoldable<I> for Goal<I> {
     fn super_fold_with<E>(
         self,
         folder: &mut dyn Folder<I, Error = E>,

chalk-ir/src/fold/boring_impls.rs

@@ -220,7 +220,7 @@ id_fold!(ClosureId);
 id_fold!(GeneratorId);
 id_fold!(ForeignDefId);
 
-impl<I: Interner> SuperFold<I> for ProgramClauseData<I> {
+impl<I: Interner> TypeSuperFoldable<I> for ProgramClauseData<I> {
     fn super_fold_with<E>(
         self,
         folder: &mut dyn Folder<I, Error = E>,
@@ -230,7 +230,7 @@ impl<I: Interner> SuperFold<I> for ProgramClauseData<I> {
     }
 }
 
-impl<I: Interner> SuperFold<I> for ProgramClause<I> {
+impl<I: Interner> TypeSuperFoldable<I> for ProgramClause<I> {
     fn super_fold_with<E>(
         self,
         folder: &mut dyn Folder<I, Error = E>,

chalk-ir/src/lib.rs

@@ -8,7 +8,7 @@ extern crate self as chalk_ir;
 
 use crate::cast::{Cast, CastTo, Caster};
 use crate::fold::shift::Shift;
-use crate::fold::{Folder, Subst, SuperFold, TypeFoldable};
+use crate::fold::{Folder, Subst, TypeFoldable, TypeSuperFoldable};
 use crate::visit::{SuperVisit, Visit, VisitExt, Visitor};
 use chalk_derive::{HasInterner, SuperVisit, TypeFoldable, Visit, Zip};
 use std::marker::PhantomData;

chalk-solve/src/infer/canonicalize.rs

@@ -1,6 +1,6 @@
 use crate::debug_span;
 use chalk_ir::fold::shift::Shift;
-use chalk_ir::fold::{Folder, SuperFold, TypeFoldable};
+use chalk_ir::fold::{Folder, TypeFoldable, TypeSuperFoldable};
 use chalk_ir::interner::{HasInterner, Interner};
 use chalk_ir::*;
 use std::cmp::max;