From 5363f350887b1e5b5dd21a86f88c8af9d7fea6da Mon Sep 17 00:00:00 2001
From: Daniel Baumann <daniel.baumann@progress-linux.org>
Date: Wed, 17 Apr 2024 14:18:25 +0200
Subject: Merging upstream version 1.67.1+dfsg1.

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>
---
 vendor/chalk-engine/src/normalize_deep.rs | 46 +++++++++++++++----------------
 1 file changed, 23 insertions(+), 23 deletions(-)

(limited to 'vendor/chalk-engine/src/normalize_deep.rs')

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
         }
     }
 
-- 
cgit v1.2.3