Merging upstream version 1.67.1+dfsg1.

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

4 files changed, 38 insertions, 41 deletions

diff --git a/vendor/chalk-engine/src/lib.rs b/vendor/chalk-engine/src/lib.rs
index 499b33e4f..f139f5cc0 100644
--- a/vendor/chalk-engine/src/lib.rs
+++ b/vendor/chalk-engine/src/lib.rs
@@ -56,7 +56,7 @@
 use std::cmp::min;
 use std::usize;
 
-use chalk_derive::{Fold, HasInterner, Visit};
+use chalk_derive::{HasInterner, TypeFoldable, TypeVisitable};
 use chalk_ir::interner::Interner;
 use chalk_ir::{
     AnswerSubst, Canonical, ConstrainedSubst, Constraint, DebruijnIndex, Goal, InEnvironment,
@@ -78,13 +78,13 @@ mod table;
 mod tables;
 
 index_struct! {
-    pub struct TableIndex { // FIXME: pub b/c Fold
+    pub struct TableIndex { // FIXME: pub b/c TypeFoldable
         value: usize,
     }
 }
 
 /// The paper describes these as `A :- D | G`.
-#[derive(Clone, Debug, PartialEq, Eq, Hash, Fold, 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, Fold, 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, Fold, Visit)]
+#[derive(Clone, Debug, TypeFoldable, TypeVisitable)]
 pub enum Literal<I: Interner> {
     // FIXME: pub b/c fold
     Positive(InEnvironment<Goal<I>>),
diff --git a/vendor/chalk-engine/src/normalize_deep.rs b/vendor/chalk-engine/src/normalize_deep.rs
index 0c4a01ccb..9f36f3ce5 100644
--- a/vendor/chalk-engine/src/normalize_deep.rs
+++ b/vendor/chalk-engine/src/normalize_deep.rs
@@ -1,9 +1,11 @@
+use chalk_derive::FallibleTypeFolder;
 use chalk_ir::fold::shift::Shift;
-use chalk_ir::fold::{Fold, Folder};
+use chalk_ir::fold::{TypeFoldable, TypeFolder};
 use chalk_ir::interner::Interner;
 use chalk_ir::*;
 use chalk_solve::infer::InferenceTable;
 
+#[derive(FallibleTypeFolder)]
 pub(crate) struct DeepNormalizer<'table, I: Interner> {
     table: &'table mut InferenceTable<I>,
     interner: I,
@@ -21,13 +23,13 @@ impl<I: Interner> DeepNormalizer<'_, I> {
     /// See also `InferenceTable::canonicalize`, which -- during real
     /// processing -- is often used to capture the "current state" of
     /// variables.
-    pub fn normalize_deep<T: Fold<I>>(
+    pub fn normalize_deep<T: TypeFoldable<I>>(
         table: &mut InferenceTable<I>,
         interner: I,
         value: T,
-    ) -> T::Result {
+    ) -> T {
         value
-            .fold_with(
+            .try_fold_with(
                 &mut DeepNormalizer { interner, table },
                 DebruijnIndex::INNERMOST,
             )
@@ -35,10 +37,8 @@ impl<I: Interner> DeepNormalizer<'_, I> {
     }
 }
 
-impl<I: Interner> Folder<I> for DeepNormalizer<'_, I> {
-    type Error = NoSolution;
-
-    fn as_dyn(&mut self) -> &mut dyn Folder<I, Error = Self::Error> {
+impl<I: Interner> TypeFolder<I> for DeepNormalizer<'_, I> {
+    fn as_dyn(&mut self) -> &mut dyn TypeFolder<I> {
         self
     }
 
@@ -47,18 +47,18 @@ impl<I: Interner> Folder<I> for DeepNormalizer<'_, I> {
         var: InferenceVar,
         kind: TyVariableKind,
         _outer_binder: DebruijnIndex,
-    ) -> Fallible<Ty<I>> {
+    ) -> Ty<I> {
         let interner = self.interner;
         match self.table.probe_var(var) {
-            Some(ty) => Ok(ty
+            Some(ty) => ty
                 .assert_ty_ref(interner)
                 .clone()
-                .fold_with(self, DebruijnIndex::INNERMOST)?
-                .shifted_in(interner)), // FIXME shift
+                .fold_with(self, DebruijnIndex::INNERMOST)
+                .shifted_in(interner), // FIXME shift
             None => {
                 // Normalize all inference vars which have been unified into a
                 // single variable. Ena calls this the "root" variable.
-                Ok(self.table.inference_var_root(var).to_ty(interner, kind))
+                self.table.inference_var_root(var).to_ty(interner, kind)
             }
         }
     }
@@ -67,15 +67,15 @@ impl<I: Interner> Folder<I> for DeepNormalizer<'_, I> {
         &mut self,
         var: InferenceVar,
         _outer_binder: DebruijnIndex,
-    ) -> Fallible<Lifetime<I>> {
+    ) -> Lifetime<I> {
         let interner = self.interner;
         match self.table.probe_var(var) {
-            Some(l) => Ok(l
+            Some(l) => l
                 .assert_lifetime_ref(interner)
                 .clone()
-                .fold_with(self, DebruijnIndex::INNERMOST)?
-                .shifted_in(interner)),
-            None => Ok(var.to_lifetime(interner)), // FIXME shift
+                .fold_with(self, DebruijnIndex::INNERMOST)
+                .shifted_in(interner),
+            None => var.to_lifetime(interner), // FIXME shift
         }
     }
 
@@ -84,15 +84,15 @@ impl<I: Interner> Folder<I> for DeepNormalizer<'_, I> {
         ty: Ty<I>,
         var: InferenceVar,
         _outer_binder: DebruijnIndex,
-    ) -> Fallible<Const<I>> {
+    ) -> Const<I> {
         let interner = self.interner;
         match self.table.probe_var(var) {
-            Some(c) => Ok(c
+            Some(c) => c
                 .assert_const_ref(interner)
                 .clone()
-                .fold_with(self, DebruijnIndex::INNERMOST)?
-                .shifted_in(interner)),
-            None => Ok(var.to_const(interner, ty)), // FIXME shift
+                .fold_with(self, DebruijnIndex::INNERMOST)
+                .shifted_in(interner),
+            None => var.to_const(interner, ty), // FIXME shift
         }
     }
 
diff --git a/vendor/chalk-engine/src/slg/resolvent.rs b/vendor/chalk-engine/src/slg/resolvent.rs
index c6d0f8d5c..3863fc429 100644
--- a/vendor/chalk-engine/src/slg/resolvent.rs
+++ b/vendor/chalk-engine/src/slg/resolvent.rs
@@ -3,7 +3,7 @@ use crate::slg::ResolventOps;
 use crate::{ExClause, Literal, TimeStamp};
 use chalk_ir::cast::Caster;
 use chalk_ir::fold::shift::Shift;
-use chalk_ir::fold::Fold;
+use chalk_ir::fold::TypeFoldable;
 use chalk_ir::interner::{HasInterner, Interner};
 use chalk_ir::zip::{Zip, Zipper};
 use chalk_ir::*;
@@ -614,8 +614,7 @@ impl<'i, I: Interner> Zipper<I> for AnswerSubstitutor<'i, I> {
 
             (LifetimeData::Static, LifetimeData::Static)
             | (LifetimeData::Placeholder(_), LifetimeData::Placeholder(_))
-            | (LifetimeData::Erased, LifetimeData::Erased)
-            | (LifetimeData::Empty(_), LifetimeData::Empty(_)) => {
+            | (LifetimeData::Erased, LifetimeData::Erased) => {
                 assert_eq!(answer, pending);
                 Ok(())
             }
@@ -628,8 +627,7 @@ impl<'i, I: Interner> Zipper<I> for AnswerSubstitutor<'i, I> {
             (LifetimeData::Static, _)
             | (LifetimeData::BoundVar(_), _)
             | (LifetimeData::Placeholder(_), _)
-            | (LifetimeData::Erased, _)
-            | (LifetimeData::Empty(_), _) => panic!(
+            | (LifetimeData::Erased, _) => panic!(
                 "structural mismatch between answer `{:?}` and pending goal `{:?}`",
                 answer, pending,
             ),
@@ -708,7 +706,7 @@ impl<'i, I: Interner> Zipper<I> for AnswerSubstitutor<'i, I> {
         pending: &Binders<T>,
     ) -> Fallible<()>
     where
-        T: HasInterner<Interner = I> + Zip<I> + Fold<I, Result = T>,
+        T: HasInterner<Interner = I> + Zip<I> + TypeFoldable<I>,
     {
         self.outer_binder.shift_in();
         Zip::zip_with(
diff --git a/vendor/chalk-engine/src/strand.rs b/vendor/chalk-engine/src/strand.rs
index 91196ec94..da25a778d 100644
--- a/vendor/chalk-engine/src/strand.rs
+++ b/vendor/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::{Fold, Folder};
+use chalk_ir::fold::{FallibleTypeFolder, TypeFoldable};
 use chalk_ir::interner::Interner;
 use chalk_ir::{Canonical, DebruijnIndex, UniverseMap};
 
@@ -35,15 +35,14 @@ pub(crate) struct SelectedSubgoal {
     pub(crate) universe_map: UniverseMap,
 }
 
-impl<I: Interner> Fold<I> for Strand<I> {
-    type Result = Strand<I>;
-    fn fold_with<E>(
+impl<I: Interner> TypeFoldable<I> for Strand<I> {
+    fn try_fold_with<E>(
         self,
-        folder: &mut dyn Folder<I, Error = E>,
+        folder: &mut dyn FallibleTypeFolder<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)?,
+            ex_clause: self.ex_clause.try_fold_with(folder, outer_binder)?,
             last_pursued_time: self.last_pursued_time,
             selected_subgoal: self.selected_subgoal,
         })