Rename SuperFold to TypeSuperFoldable

Author: eggyal

book/src/SUMMARY.md

@@ -12,7 +12,7 @@
         - [Application types](./types/rust_types/application_ty.md)
     - [Rust lifetimes](./types/rust_lifetimes.md)
     - [Operations](./types/operations.md)
-        - [TypeFoldable and the Folder trait](./types/operations/fold.md)
+        - [TypeFoldable and the TypeFolder trait](./types/operations/fold.md)
 - [Lowering Rust IR to logic](./clauses.md)
     - [Goals and clauses](./clauses/goals_and_clauses.md)
     - [Type equality and unification](./clauses/type_equality.md)

book/src/types/operations/fold.md

@@ -1,4 +1,4 @@
-# TypeFoldable and the Folder trait
+# TypeFoldable and the TypeFolder trait
 
 The [`TypeFoldable`] trait permits one to traverse a type or other term in the
 chalk-ir and make a copy of it, possibly making small substitutions or
@@ -17,48 +17,48 @@ let output_ty = input_ty.fold_with(&mut folder, 0);
 
 [`TypeFoldable::fold_with`]: https://rust-lang.github.io/chalk/chalk_ir/fold/trait.TypeFoldable.html#tymethod.fold_with
 
-The folder is some instance of the [`Folder`] trait. This trait
+The folder is some instance of the [`TypeFolder`] trait. This trait
 defines a few key callbacks that allow you to substitute different
 values as the fold proceeds. For example, when a type is folded, the
 folder can substitute a new type in its place.
 
-[`Folder`]: https://rust-lang.github.io/chalk/chalk_ir/fold/trait.Folder.html
+[`TypeFolder`]: https://rust-lang.github.io/chalk/chalk_ir/fold/trait.TypeFolder.html
 
 ## Uses for folders
 
 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 TypeFolder to TypeSuperFoldable and back again
 
 The overall flow of folding is like this.
 
 1. [`TypeFoldable::fold_with`] is invoked on the outermost term. It recursively
    walks the term.
 2. For those sorts of terms (types, lifetimes, goals, program clauses) that have
-   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
+   callbacks in the [`TypeFolder`] trait, invoking [`TypeFoldable::fold_with`] will in turn
+   invoke the corresponding method on the [`TypeFolder`] trait, such as `TypeFolder::fold_ty`.
+3. The default implementation of `TypeFolder::fold_ty`, in turn, invokes
+   `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
+   implementation invokes more specialized methods on [`TypeFolder`], such
+   as [`TypeFolder::fold_free_var_ty`], which makes it easier to write
    folders that just intercept *certain* types.
 
-[`Folder::fold_free_var_ty`]: https://rust-lang.github.io/chalk/chalk_ir/fold/trait.Folder.html#method.fold_free_var_ty
+[`TypeFolder::fold_free_var_ty`]: https://rust-lang.github.io/chalk/chalk_ir/fold/trait.TypeFolder.html#method.fold_free_var_ty
 
 Thus, as a user, you can customize folding by:
 
-* Defining your own `Folder` type
+* Defining your own `TypeFolder` type
 * 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
 
-Each callback in the [`Folder`] trait takes a `binders` argument. This indicates
+Each callback in the [`TypeFolder`] trait takes a `binders` argument. This indicates
 the number of binders that we have traversed during folding, which is relevant for De Bruijn indices.
 So e.g. a bound variable with depth 1, if invoked with a `binders` value of 1, indicates something that was bound to something external to the fold.
 
@@ -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
-have a callback defined on the `Folder` trait (e.g., types and
+The `TypeSuperFoldable` trait should only be implemented for those types that
+have a callback defined on the `TypeFolder` 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-derive/src/lib.rs

@@ -118,8 +118,8 @@ enum DeriveKind {
 }
 
 decl_derive!([HasInterner, attributes(has_interner)] => derive_has_interner);
-decl_derive!([Visit, attributes(has_interner)] => derive_visit);
-decl_derive!([SuperVisit, attributes(has_interner)] => derive_super_visit);
+decl_derive!([TypeVisitable, attributes(has_interner)] => derive_type_visitable);
+decl_derive!([TypeSuperVisitable, attributes(has_interner)] => derive_type_super_visitable);
 decl_derive!([TypeFoldable, attributes(has_interner)] => derive_type_foldable);
 decl_derive!([Zip, attributes(has_interner)] => derive_zip);
 
@@ -136,24 +136,28 @@ fn derive_has_interner(mut s: synstructure::Structure) -> TokenStream {
     )
 }
 
-/// Derives Visit for structs and enums for which one of the following is true:
+/// Derives TypeVisitable for structs and enums for which one of the following is true:
 /// - It has a `#[has_interner(TheInterner)]` attribute
 /// - There is a single parameter `T: HasInterner` (does not have to be named `T`)
 /// - There is a single parameter `I: Interner` (does not have to be named `I`)
-fn derive_visit(s: synstructure::Structure) -> TokenStream {
-    derive_any_visit(s, parse_quote! { Visit }, parse_quote! { visit_with })
+fn derive_type_visitable(s: synstructure::Structure) -> TokenStream {
+    derive_any_type_visitable(
+        s,
+        parse_quote! { TypeVisitable },
+        parse_quote! { visit_with },
+    )
 }
 
-/// Same as Visit, but derives SuperVisit instead
-fn derive_super_visit(s: synstructure::Structure) -> TokenStream {
-    derive_any_visit(
+/// Same as TypeVisitable, but derives TypeSuperVisitable instead
+fn derive_type_super_visitable(s: synstructure::Structure) -> TokenStream {
+    derive_any_type_visitable(
         s,
-        parse_quote! { SuperVisit },
+        parse_quote! { TypeSuperVisitable },
         parse_quote! { super_visit_with },
     )
 }
 
-fn derive_any_visit(
+fn derive_any_type_visitable(
     mut s: synstructure::Structure,
     trait_name: Ident,
     method_name: Ident,
@@ -164,13 +168,13 @@ fn derive_any_visit(
 
     let body = s.each(|bi| {
         quote! {
-            ::chalk_ir::try_break!(::chalk_ir::visit::Visit::visit_with(#bi, visitor, outer_binder));
+            ::chalk_ir::try_break!(::chalk_ir::visit::TypeVisitable::visit_with(#bi, visitor, outer_binder));
         }
     });
 
     if kind == DeriveKind::FromHasInterner {
         let param = get_generic_param_name(input).unwrap();
-        s.add_where_predicate(parse_quote! { #param: ::chalk_ir::visit::Visit<#interner> });
+        s.add_where_predicate(parse_quote! { #param: ::chalk_ir::visit::TypeVisitable<#interner> });
     }
 
     s.add_bounds(synstructure::AddBounds::None);
@@ -295,7 +299,7 @@ fn derive_type_foldable(mut s: synstructure::Structure) -> TokenStream {
 
             fn fold_with<E>(
                 self,
-                folder: &mut dyn ::chalk_ir::fold::Folder < #interner, Error = E >,
+                folder: &mut dyn ::chalk_ir::fold::TypeFolder < #interner, Error = E >,
                 outer_binder: ::chalk_ir::DebruijnIndex,
             ) -> ::std::result::Result<Self::Result, E> {
                 Ok(match self { #body })

chalk-engine/src/lib.rs

@@ -56,7 +56,7 @@
 use std::cmp::min;
 use std::usize;
 
-use chalk_derive::{HasInterner, TypeFoldable, Visit};
+use chalk_derive::{HasInterner, TypeFoldable, TypeVisitable};
 use chalk_ir::interner::Interner;
 use chalk_ir::{
     AnswerSubst, Canonical, ConstrainedSubst, Constraint, DebruijnIndex, Goal, InEnvironment,
@@ -84,7 +84,7 @@ index_struct! {
 }
 
 /// The paper describes these as `A :- D | G`.
-#[derive(Clone, Debug, PartialEq, Eq, Hash, TypeFoldable, Visit, HasInterner)]
+#[derive(Clone, Debug, PartialEq, Eq, Hash, TypeFoldable, TypeVisitable, HasInterner)]
 pub struct ExClause<I: Interner> {
     /// The substitution which, applied to the goal of our table,
     /// would yield A.
@@ -168,7 +168,7 @@ impl TimeStamp {
 ///
 /// trying to solve `?T: Foo` would immediately require solving `?T:
 /// Sized`, and hence would flounder.
-#[derive(Clone, Debug, PartialEq, Eq, Hash, TypeFoldable, Visit)]
+#[derive(Clone, Debug, PartialEq, Eq, Hash, TypeFoldable, TypeVisitable)]
 pub struct FlounderedSubgoal<I: Interner> {
     /// Literal that floundered.
     pub floundered_literal: Literal<I>,
@@ -209,7 +209,7 @@ pub struct CompleteAnswer<I: Interner> {
 }
 
 /// Either `A` or `~A`, where `A` is a `Env |- Goal`.
-#[derive(Clone, Debug, TypeFoldable, Visit)]
+#[derive(Clone, Debug, TypeFoldable, TypeVisitable)]
 pub enum Literal<I: Interner> {
     // FIXME: pub b/c fold
     Positive(InEnvironment<Goal<I>>),

chalk-engine/src/normalize_deep.rs

@@ -1,5 +1,5 @@
 use chalk_ir::fold::shift::Shift;
-use chalk_ir::fold::{Folder, TypeFoldable};
+use chalk_ir::fold::{TypeFoldable, TypeFolder};
 use chalk_ir::interner::Interner;
 use chalk_ir::*;
 use chalk_solve::infer::InferenceTable;
@@ -35,10 +35,10 @@ impl<I: Interner> DeepNormalizer<'_, I> {
     }
 }
 
-impl<I: Interner> Folder<I> for DeepNormalizer<'_, I> {
+impl<I: Interner> TypeFolder<I> for DeepNormalizer<'_, I> {
     type Error = NoSolution;
 
-    fn as_dyn(&mut self) -> &mut dyn Folder<I, Error = Self::Error> {
+    fn as_dyn(&mut self) -> &mut dyn TypeFolder<I, Error = Self::Error> {
         self
     }
 

chalk-engine/src/strand.rs

@@ -3,7 +3,7 @@ use crate::{ExClause, TableIndex, TimeStamp};
 use std::fmt::Debug;
 
 use chalk_derive::HasInterner;
-use chalk_ir::fold::{Folder, TypeFoldable};
+use chalk_ir::fold::{TypeFoldable, TypeFolder};
 use chalk_ir::interner::Interner;
 use chalk_ir::{Canonical, DebruijnIndex, UniverseMap};
 
@@ -39,7 +39,7 @@ impl<I: Interner> TypeFoldable<I> for Strand<I> {
     type Result = Strand<I>;
     fn fold_with<E>(
         self,
-        folder: &mut dyn Folder<I, Error = E>,
+        folder: &mut dyn TypeFolder<I, Error = E>,
         outer_binder: DebruijnIndex,
     ) -> Result<Self::Result, E> {
         Ok(Strand {