Remove unused Result assoc type from Fold trait

chalk-derive/src/lib.rs

@@ -275,33 +275,21 @@ fn derive_type_foldable(mut s: synstructure::Structure) -> TokenStream {
     });
 
     let input = s.ast();
-    let type_name = &input.ident;
 
-    let result = if kind == DeriveKind::FromHasInterner {
+    if kind == DeriveKind::FromHasInterner {
         let param = get_generic_param_name(input).unwrap();
-        s.add_impl_generic(parse_quote! { _U })
-            .add_where_predicate(
-                parse_quote! { #param: ::chalk_ir::fold::TypeFoldable<#interner, Result = _U> },
-            )
-            .add_where_predicate(
-                parse_quote! { _U: ::chalk_ir::interner::HasInterner<Interner = #interner> },
-            );
-        quote! { #type_name <_U> }
-    } else {
-        quote! { #type_name < #interner > }
+        s.add_where_predicate(parse_quote! { #param: ::chalk_ir::fold::TypeFoldable<#interner> });
     };
 
     s.add_bounds(synstructure::AddBounds::None);
     s.bound_impl(
         quote!(::chalk_ir::fold::TypeFoldable<#interner>),
         quote! {
-            type Result = #result;
-
             fn fold_with<E>(
                 self,
                 folder: &mut dyn ::chalk_ir::fold::TypeFolder < #interner, Error = E >,
                 outer_binder: ::chalk_ir::DebruijnIndex,
-            ) -> ::std::result::Result<Self::Result, E> {
+            ) -> ::std::result::Result<Self, E> {
                 Ok(match self { #body })
             }
         },

chalk-engine/src/normalize_deep.rs

@@ -25,7 +25,7 @@ impl<I: Interner> DeepNormalizer<'_, I> {
         table: &mut InferenceTable<I>,
         interner: I,
         value: T,
-    ) -> T::Result {
+    ) -> T {
         value
             .fold_with(
                 &mut DeepNormalizer { interner, table },

chalk-engine/src/slg/resolvent.rs

@@ -708,7 +708,7 @@ impl<'i, I: Interner> Zipper<I> for AnswerSubstitutor<'i, I> {
         pending: &Binders<T>,
     ) -> Fallible<()>
     where
-        T: HasInterner<Interner = I> + Zip<I> + TypeFoldable<I, Result = T>,
+        T: HasInterner<Interner = I> + Zip<I> + TypeFoldable<I>,
     {
         self.outer_binder.shift_in();
         Zip::zip_with(

chalk-engine/src/strand.rs

@@ -36,12 +36,11 @@ pub(crate) struct SelectedSubgoal {
 }
 
 impl<I: Interner> TypeFoldable<I> for Strand<I> {
-    type Result = Strand<I>;
     fn fold_with<E>(
         self,
         folder: &mut dyn TypeFolder<I, Error = E>,
         outer_binder: DebruijnIndex,
-    ) -> Result<Self::Result, E> {
+    ) -> Result<Self, E> {
         Ok(Strand {
             ex_clause: self.ex_clause.fold_with(folder, outer_binder)?,
             last_pursued_time: self.last_pursued_time,

chalk-ir/src/fold.rs

@@ -310,14 +310,7 @@ pub trait TypeFolder<I: Interner> {
 /// the source type, but in some cases we convert from borrowed
 /// to owned as well (e.g., the folder for `&T` will fold to a fresh
 /// `T`; well, actually `T::Result`).
-pub trait TypeFoldable<I: Interner>: Debug {
-    /// The type of value that will be produced once folding is done.
-    /// Typically this is `Self`, unless `Self` contains borrowed
-    /// values, in which case owned values are produced (for example,
-    /// one can fold over a `&T` value where `T: TypeFoldable`, in which case
-    /// you get back a `T`, not a `&T`).
-    type Result;
-
+pub trait TypeFoldable<I: Interner>: Debug + Sized {
     /// Apply the given folder `folder` to `self`; `binders` is the
     /// number of binders that are in scope when beginning the
     /// folder. Typically `binders` starts as 0, but is adjusted when
@@ -327,7 +320,7 @@ pub trait TypeFoldable<I: Interner>: Debug {
         self,
         folder: &mut dyn TypeFolder<I, Error = E>,
         outer_binder: DebruijnIndex,
-    ) -> Result<Self::Result, E>;
+    ) -> Result<Self, E>;
 }
 
 /// For types where "fold" invokes a callback on the `TypeFolder`, the
@@ -339,20 +332,18 @@ pub trait TypeSuperFoldable<I: Interner>: TypeFoldable<I> {
         self,
         folder: &mut dyn TypeFolder<I, Error = E>,
         outer_binder: DebruijnIndex,
-    ) -> Result<Self::Result, E>;
+    ) -> Result<Self, E>;
 }
 
 /// "Folding" a type invokes the `fold_ty` method on the folder; this
 /// usually (in turn) invokes `super_fold_ty` to fold the individual
 /// parts.
 impl<I: Interner> TypeFoldable<I> for Ty<I> {
-    type Result = Ty<I>;
-
     fn fold_with<E>(
         self,
         folder: &mut dyn TypeFolder<I, Error = E>,
         outer_binder: DebruijnIndex,
-    ) -> Result<Self::Result, E> {
+    ) -> Result<Self, E> {
         folder.fold_ty(self, outer_binder)
     }
 }
@@ -470,13 +461,11 @@ where
 /// usually (in turn) invokes `super_fold_lifetime` to fold the individual
 /// parts.
 impl<I: Interner> TypeFoldable<I> for Lifetime<I> {
-    type Result = Lifetime<I>;
-
     fn fold_with<E>(
         self,
         folder: &mut dyn TypeFolder<I, Error = E>,
         outer_binder: DebruijnIndex,
-    ) -> Result<Self::Result, E> {
+    ) -> Result<Self, E> {
         folder.fold_lifetime(self, outer_binder)
     }
 }
@@ -522,13 +511,11 @@ where
 /// usually (in turn) invokes `super_fold_const` to fold the individual
 /// parts.
 impl<I: Interner> TypeFoldable<I> for Const<I> {
-    type Result = Const<I>;
-
     fn fold_with<E>(
         self,
         folder: &mut dyn TypeFolder<I, Error = E>,
         outer_binder: DebruijnIndex,
-    ) -> Result<Self::Result, E> {
+    ) -> Result<Self, E> {
         folder.fold_const(self, outer_binder)
     }
 }
@@ -573,13 +560,11 @@ where
 /// Folding a goal invokes the `fold_goal` callback (which will, by
 /// default, invoke super-fold).
 impl<I: Interner> TypeFoldable<I> for Goal<I> {
-    type Result = Goal<I>;
-
     fn fold_with<E>(
         self,
         folder: &mut dyn TypeFolder<I, Error = E>,
         outer_binder: DebruijnIndex,
-    ) -> Result<Self::Result, E> {
+    ) -> Result<Self, E> {
         folder.fold_goal(self, outer_binder)
     }
 }
@@ -590,7 +575,7 @@ impl<I: Interner> TypeSuperFoldable<I> for Goal<I> {
         self,
         folder: &mut dyn TypeFolder<I, Error = E>,
         outer_binder: DebruijnIndex,
-    ) -> Result<Self::Result, E> {
+    ) -> Result<Self, E> {
         let interner = folder.interner();
         Ok(Goal::new(
             interner,
@@ -605,13 +590,11 @@ impl<I: Interner> TypeSuperFoldable<I> for Goal<I> {
 /// callback on the folder (which will, by default, invoke the
 /// `super_fold_with` method on the program clause).
 impl<I: Interner> TypeFoldable<I> for ProgramClause<I> {
-    type Result = ProgramClause<I>;
-
     fn fold_with<E>(
         self,
         folder: &mut dyn TypeFolder<I, Error = E>,
         outer_binder: DebruijnIndex,
-    ) -> Result<Self::Result, E> {
+    ) -> Result<Self, E> {
         folder.fold_program_clause(self, outer_binder)
     }
 }

chalk-ir/src/fold/binder_impls.rs

@@ -6,12 +6,11 @@
 use crate::*;
 
 impl<I: Interner> TypeFoldable<I> for FnPointer<I> {
-    type Result = FnPointer<I>;
     fn fold_with<E>(
         self,
         folder: &mut dyn TypeFolder<I, Error = E>,
         outer_binder: DebruijnIndex,
-    ) -> Result<Self::Result, E> {
+    ) -> Result<Self, E> {
         let FnPointer {
             num_binders,
             substitution,
@@ -32,15 +31,13 @@ impl<I: Interner> TypeFoldable<I> for FnPointer<I> {
 impl<T, I: Interner> TypeFoldable<I> for Binders<T>
 where
     T: HasInterner<Interner = I> + TypeFoldable<I>,
-    <T as TypeFoldable<I>>::Result: HasInterner<Interner = I>,
     I: Interner,
 {
-    type Result = Binders<T::Result>;
     fn fold_with<E>(
         self,
         folder: &mut dyn TypeFolder<I, Error = E>,
         outer_binder: DebruijnIndex,
-    ) -> Result<Self::Result, E> {
+    ) -> Result<Self, E> {
         let Binders {
             binders: self_binders,
             value: self_value,
@@ -57,14 +54,12 @@ impl<I, T> TypeFoldable<I> for Canonical<T>
 where
     I: Interner,
     T: HasInterner<Interner = I> + TypeFoldable<I>,
-    <T as TypeFoldable<I>>::Result: HasInterner<Interner = I>,
 {
-    type Result = Canonical<T::Result>;
     fn fold_with<E>(
         self,
         folder: &mut dyn TypeFolder<I, Error = E>,
         outer_binder: DebruijnIndex,
-    ) -> Result<Self::Result, E> {
+    ) -> Result<Self, E> {
         let Canonical {
             binders: self_binders,
             value: self_value,