2 files changed, 62 insertions, 2 deletions

diff --git a/crates/hir_ty/src/infer/unify.rs b/crates/hir_ty/src/infer/unify.rs
index 56e06b7d0..d8edfb4e9 100644
--- a/crates/hir_ty/src/infer/unify.rs
+++ b/crates/hir_ty/src/infer/unify.rs
@@ -86,8 +86,12 @@ impl<T: HasInterner<Interner = Interner>> Canonicalized<T> {
     }
 }
 
-pub fn could_unify(db: &dyn HirDatabase, env: Arc<TraitEnvironment>, t1: &Ty, t2: &Ty) -> bool {
-    InferenceTable::new(db, env).unify(t1, t2)
+pub fn could_unify(
+    db: &dyn HirDatabase,
+    env: Arc<TraitEnvironment>,
+    tys: &Canonical<(Ty, Ty)>,
+) -> bool {
+    unify(db, env, tys).is_some()
 }
 
 pub(crate) fn unify(
diff --git a/crates/hir_ty/src/lib.rs b/crates/hir_ty/src/lib.rs
index 06d5cd0b6..56f60c46b 100644
--- a/crates/hir_ty/src/lib.rs
+++ b/crates/hir_ty/src/lib.rs
@@ -43,6 +43,7 @@ use hir_def::{
     type_ref::{ConstScalar, Rawness},
     TypeParamId,
 };
+use stdx::always;
 
 use crate::{db::HirDatabase, display::HirDisplay, utils::generics};
 
@@ -326,3 +327,58 @@ pub(crate) fn fold_tys<T: HasInterner<Interner = Interner> + Fold<Interner>>(
     }
     t.fold_with(&mut TyFolder(f), binders).expect("fold failed unexpectedly")
 }
+
+pub fn replace_errors_with_variables<T>(t: T) -> Canonical<T::Result>
+where
+    T: HasInterner<Interner = Interner> + Fold<Interner>,
+    T::Result: HasInterner<Interner = Interner>,
+{
+    use chalk_ir::{
+        fold::{Folder, SuperFold},
+        Fallible,
+    };
+    struct ErrorReplacer {
+        vars: usize,
+    }
+    impl<'i> Folder<'i, Interner> for ErrorReplacer {
+        fn as_dyn(&mut self) -> &mut dyn Folder<'i, Interner> {
+            self
+        }
+
+        fn interner(&self) -> &'i Interner {
+            &Interner
+        }
+
+        fn fold_ty(&mut self, ty: Ty, outer_binder: DebruijnIndex) -> Fallible<Ty> {
+            if let TyKind::Error = ty.kind(&Interner) {
+                let index = self.vars;
+                self.vars += 1;
+                Ok(TyKind::BoundVar(BoundVar::new(outer_binder, index)).intern(&Interner))
+            } else {
+                let ty = ty.super_fold_with(self.as_dyn(), outer_binder)?;
+                Ok(ty)
+            }
+        }
+
+        fn fold_inference_ty(
+            &mut self,
+            var: InferenceVar,
+            kind: TyVariableKind,
+            _outer_binder: DebruijnIndex,
+        ) -> Fallible<Ty> {
+            always!(false);
+            Ok(TyKind::InferenceVar(var, kind).intern(&Interner))
+        }
+    }
+    let mut error_replacer = ErrorReplacer { vars: 0 };
+    let value = t
+        .fold_with(&mut error_replacer, DebruijnIndex::INNERMOST)
+        .expect("fold failed unexpectedly");
+    let kinds = (0..error_replacer.vars).map(|_| {
+        chalk_ir::CanonicalVarKind::new(
+            chalk_ir::VariableKind::Ty(TyVariableKind::General),
+            chalk_ir::UniverseIndex::ROOT,
+        )
+    });
+    Canonical { value, binders: chalk_ir::CanonicalVarKinds::from_iter(&Interner, kinds) }
+}