use visit_free_var for everything instead for visit_free_var_* and remove visit_bound_var

Author: basil-cow

chalk-ir/src/visit.rs

@@ -139,60 +139,9 @@ where
         false
     }
 
-    /// Invoked for `TyData::BoundVar` instances that are not bound
+    /// Invoked for `BoundVar` instances that are not bound
     /// within the type being visited over:
-    fn visit_free_var_ty(
-        &mut self,
-        bound_var: BoundVar,
-        outer_binder: DebruijnIndex,
-    ) -> Self::Result {
-        if self.forbid_free_vars() {
-            panic!(
-                "unexpected free variable `{:?}` with outer binder {:?}",
-                bound_var, outer_binder
-            )
-        } else {
-            Self::Result::new()
-        }
-    }
-
-    fn visit_bound_var_ty(
-        &mut self,
-        _bound_var: BoundVar,
-        _outer_binder: DebruijnIndex,
-    ) -> Self::Result {
-        Self::Result::new()
-    }
-
-    /// As `visit_free_var_ty`, but for lifetimes.
-    fn visit_free_var_lifetime(
-        &mut self,
-        bound_var: BoundVar,
-        outer_binder: DebruijnIndex,
-    ) -> Self::Result {
-        if self.forbid_free_vars() {
-            panic!(
-                "unexpected free variable `{:?}` with outer binder {:?}",
-                bound_var, outer_binder
-            )
-        } else {
-            Self::Result::new()
-        }
-    }
-
-    fn visit_bound_var_lifetime(
-        &mut self,
-        _bound_var: BoundVar,
-        _outer_binder: DebruijnIndex,
-    ) -> Self::Result {
-        Self::Result::new()
-    }
-
-    fn visit_free_var_const(
-        &mut self,
-        bound_var: BoundVar,
-        outer_binder: DebruijnIndex,
-    ) -> Self::Result {
+    fn visit_free_var(&mut self, bound_var: BoundVar, outer_binder: DebruijnIndex) -> Self::Result {
         if self.forbid_free_vars() {
             panic!(
                 "unexpected free variable `{:?}` with outer binder {:?}",
@@ -203,14 +152,6 @@ where
         }
     }
 
-    fn visit_bound_var_const(
-        &mut self,
-        _bound_var: BoundVar,
-        _outer_binder: DebruijnIndex,
-    ) -> Self::Result {
-        Self::Result::new()
-    }
-
     /// If overridden to return true, we will panic when a free
     /// placeholder type/lifetime is encountered.
     fn forbid_free_placeholders(&self) -> bool {
@@ -376,9 +317,9 @@ where
         match self.data(interner) {
             TyData::BoundVar(bound_var) => {
                 if let Some(_) = bound_var.shifted_out_to(outer_binder) {
-                    visitor.visit_free_var_lifetime(*bound_var, outer_binder)
+                    visitor.visit_free_var(*bound_var, outer_binder)
                 } else {
-                    visitor.visit_bound_var_lifetime(*bound_var, outer_binder)
+                    R::new()
                 }
             }
             TyData::Dyn(clauses) => clauses.visit_with(visitor, outer_binder),
@@ -417,9 +358,9 @@ impl<I: Interner> SuperVisit<I> for Lifetime<I> {
         match self.data(interner) {
             LifetimeData::BoundVar(bound_var) => {
                 if let Some(_) = bound_var.shifted_out_to(outer_binder) {
-                    visitor.visit_free_var_lifetime(*bound_var, outer_binder)
+                    visitor.visit_free_var(*bound_var, outer_binder)
                 } else {
-                    visitor.visit_bound_var_lifetime(*bound_var, outer_binder)
+                    R::new()
                 }
             }
             LifetimeData::InferenceVar(var) => visitor.visit_inference_lifetime(*var, outer_binder),
@@ -457,9 +398,9 @@ impl<I: Interner> SuperVisit<I> for Const<I> {
         match self.data(interner) {
             ConstData::BoundVar(bound_var) => {
                 if let Some(_) = bound_var.shifted_out_to(outer_binder) {
-                    visitor.visit_free_var_const(*bound_var, outer_binder)
+                    visitor.visit_free_var(*bound_var, outer_binder)
                 } else {
-                    visitor.visit_bound_var_const(*bound_var, outer_binder)
+                    R::new()
                 }
             }
             ConstData::InferenceVar(var) => visitor.visit_inference_const(*var, outer_binder),

chalk-ir/src/visit/visitors.rs

@@ -55,15 +55,7 @@ impl<'i, I: Interner> Visitor<'i, I> for FindFreeVarsVisitor<'i, I> {
         self.interner
     }
 
-    fn visit_free_var_ty(
-        &mut self,
-        _bound_var: BoundVar,
-        _outer_binder: DebruijnIndex,
-    ) -> Self::Result {
-        FindAny::FOUND
-    }
-
-    fn visit_free_var_lifetime(
+    fn visit_free_var(
         &mut self,
         _bound_var: BoundVar,
         _outer_binder: DebruijnIndex,

chalk-solve/src/infer/unify.rs

@@ -85,11 +85,11 @@ impl<'t, I: Interner> Unifier<'t, I> {
     fn unify_ty_ty<'a>(&mut self, a: &'a Ty<I>, b: &'a Ty<I>) -> Fallible<()> {
         let interner = self.interner;
         //         ^^                 ^^         ^^ FIXME rustc bug
-        if let Some(n_a) = self.table.normalize_ty_shallow(interner, a) {
-            return self.unify_ty_ty(&n_a, b);
-        } else if let Some(n_b) = self.table.normalize_ty_shallow(interner, b) {
-            return self.unify_ty_ty(a, &n_b);
-        }
+
+        let n_a = self.table.normalize_ty_shallow(interner, a);
+        let n_b = self.table.normalize_ty_shallow(interner, b);
+        let a = n_a.as_ref().unwrap_or(a);
+        let b = n_b.as_ref().unwrap_or(b);
 
         debug_heading!(
             "unify_ty_ty(a={:?}\