Rename fallible methods

Author: eggyal

chalk-derive/src/lib.rs

@@ -269,7 +269,7 @@ fn derive_type_foldable(mut s: synstructure::Structure) -> TokenStream {
         vi.construct(|_, index| {
             let bind = &bindings[index];
             quote! {
-                ::chalk_ir::fold::TypeFoldable::fold_with(#bind, folder, outer_binder)?
+                ::chalk_ir::fold::TypeFoldable::try_fold_with(#bind, folder, outer_binder)?
             }
         })
     });
@@ -285,7 +285,7 @@ fn derive_type_foldable(mut s: synstructure::Structure) -> TokenStream {
     s.bound_impl(
         quote!(::chalk_ir::fold::TypeFoldable<#interner>),
         quote! {
-            fn fold_with<E>(
+            fn try_fold_with<E>(
                 self,
                 folder: &mut dyn ::chalk_ir::fold::FallibleTypeFolder < #interner, Error = E >,
                 outer_binder: ::chalk_ir::DebruijnIndex,

chalk-engine/src/normalize_deep.rs

@@ -27,7 +27,7 @@ impl<I: Interner> DeepNormalizer<'_, I> {
         value: T,
     ) -> T {
         value
-            .fold_with(
+            .try_fold_with(
                 &mut DeepNormalizer { interner, table },
                 DebruijnIndex::INNERMOST,
             )
@@ -42,7 +42,7 @@ impl<I: Interner> FallibleTypeFolder<I> for DeepNormalizer<'_, I> {
         self
     }
 
-    fn fold_inference_ty(
+    fn try_fold_inference_ty(
         &mut self,
         var: InferenceVar,
         kind: TyVariableKind,
@@ -53,7 +53,7 @@ impl<I: Interner> FallibleTypeFolder<I> for DeepNormalizer<'_, I> {
             Some(ty) => Ok(ty
                 .assert_ty_ref(interner)
                 .clone()
-                .fold_with(self, DebruijnIndex::INNERMOST)?
+                .try_fold_with(self, DebruijnIndex::INNERMOST)?
                 .shifted_in(interner)), // FIXME shift
             None => {
                 // Normalize all inference vars which have been unified into a
@@ -63,7 +63,7 @@ impl<I: Interner> FallibleTypeFolder<I> for DeepNormalizer<'_, I> {
         }
     }
 
-    fn fold_inference_lifetime(
+    fn try_fold_inference_lifetime(
         &mut self,
         var: InferenceVar,
         _outer_binder: DebruijnIndex,
@@ -73,13 +73,13 @@ impl<I: Interner> FallibleTypeFolder<I> for DeepNormalizer<'_, I> {
             Some(l) => Ok(l
                 .assert_lifetime_ref(interner)
                 .clone()
-                .fold_with(self, DebruijnIndex::INNERMOST)?
+                .try_fold_with(self, DebruijnIndex::INNERMOST)?
                 .shifted_in(interner)),
             None => Ok(var.to_lifetime(interner)), // FIXME shift
         }
     }
 
-    fn fold_inference_const(
+    fn try_fold_inference_const(
         &mut self,
         ty: Ty<I>,
         var: InferenceVar,
@@ -90,7 +90,7 @@ impl<I: Interner> FallibleTypeFolder<I> for DeepNormalizer<'_, I> {
             Some(c) => Ok(c
                 .assert_const_ref(interner)
                 .clone()
-                .fold_with(self, DebruijnIndex::INNERMOST)?
+                .try_fold_with(self, DebruijnIndex::INNERMOST)?
                 .shifted_in(interner)),
             None => Ok(var.to_const(interner, ty)), // FIXME shift
         }

chalk-engine/src/strand.rs

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