actual MayInvalidate implementation for consts + remove dead code

Author: basil-cow

chalk-ir/src/lib.rs

@@ -938,22 +938,6 @@ impl<I: Interner> Parameter<I> {
             _ => None,
         }
     }
-
-    pub fn bound_var(&self, interner: &I) -> Option<BoundVar> {
-        match self.data(interner) {
-            ParameterKind::Ty(t) => t.bound_var(interner),
-            ParameterKind::Lifetime(l) => l.bound_var(interner),
-            ParameterKind::Const(c) => c.bound_var(interner),
-        }
-    }
-
-    pub fn inference_var(&self, interner: &I) -> Option<InferenceVar> {
-        match self.data(interner) {
-            ParameterKind::Ty(t) => t.inference_var(interner),
-            ParameterKind::Lifetime(l) => l.inference_var(interner),
-            ParameterKind::Const(c) => c.inference_var(interner),
-        }
-    }
 }
 
 #[allow(type_alias_bounds)]

chalk-solve/src/solve/slg.rs

@@ -572,7 +572,7 @@ impl<I: Interner> MayInvalidate<'_, I> {
             }
 
             (TyData::Placeholder(p1), TyData::Placeholder(p2)) => {
-                self.aggregate_placeholder_tys(p1, p2)
+                self.aggregate_placeholders(p1, p2)
             }
 
             (TyData::Alias(alias1), TyData::Alias(alias2)) => {
@@ -592,8 +592,36 @@ impl<I: Interner> MayInvalidate<'_, I> {
         true
     }
 
-    fn aggregate_consts(&mut self, _: &Const<I>, _: &Const<I>) -> bool {
-        true
+    // Returns true if the two consts could be unequal.
+    fn aggregate_consts(&mut self, new: &Const<I>, current: &Const<I>) -> bool {
+        let interner = self.interner;
+        match (new.data(interner), current.data(interner)) {
+            (_, ConstData::BoundVar(_)) => {
+                // see comment in aggregate_tys
+                false
+            }
+
+            (ConstData::BoundVar(_), _) => {
+                // see comment in aggregate_tys
+                true
+            }
+
+            (ConstData::InferenceVar(_), _) | (_, ConstData::InferenceVar(_)) => {
+                panic!(
+                    "unexpected free inference variable in may-invalidate: {:?} vs {:?}",
+                    new, current,
+                );
+            }
+
+            (ConstData::Placeholder(p1), ConstData::Placeholder(p2)) => {
+                self.aggregate_placeholders(p1, p2)
+            }
+
+            (ConstData::Concrete(c1), ConstData::Concrete(c2)) => !c1.c_eq(c2, interner),
+
+            // Only variants left are placeholder = concrete, which always fails
+            (ConstData::Placeholder(_), _) | (ConstData::Concrete(_), _) => true,
+        }
     }
 
     fn aggregate_application_tys(
@@ -618,7 +646,7 @@ impl<I: Interner> MayInvalidate<'_, I> {
         )
     }
 
-    fn aggregate_placeholder_tys(
+    fn aggregate_placeholders(
         &mut self,
         new: &PlaceholderIndex,
         current: &PlaceholderIndex,