Check consts in ValidateBoundVars.

Alongside the existing type and region checking.

Author: nnethercote

compiler/rustc_middle/src/ty/mod.rs

@@ -977,8 +977,8 @@ impl<'tcx> rustc_type_ir::inherent::BoundVarLike<TyCtxt<'tcx>> for BoundConst {
         self.var
     }
 
-    fn assert_eq(self, _var: ty::BoundVariableKind) {
-        unreachable!()
+    fn assert_eq(self, var: ty::BoundVariableKind) {
+        var.expect_const()
     }
 }
 

compiler/rustc_type_ir/src/binder.rs

@@ -274,17 +274,17 @@ impl<I: Interner, T: IntoIterator> Binder<I, T> {
 pub struct ValidateBoundVars<I: Interner> {
     bound_vars: I::BoundVarKinds,
     binder_index: ty::DebruijnIndex,
-    // We may encounter the same variable at different levels of binding, so
-    // this can't just be `Ty`
-    visited: SsoHashSet<(ty::DebruijnIndex, I::Ty)>,
+    // A cache for types. We may encounter the same variable at different levels of binding, so
+    // this can't just be `Ty`.
+    visited_tys: SsoHashSet<(ty::DebruijnIndex, I::Ty)>,
 }
 
 impl<I: Interner> ValidateBoundVars<I> {
     pub fn new(bound_vars: I::BoundVarKinds) -> Self {
         ValidateBoundVars {
             bound_vars,
             binder_index: ty::INNERMOST,
-            visited: SsoHashSet::default(),
+            visited_tys: SsoHashSet::default(),
         }
     }
 }
@@ -301,7 +301,7 @@ impl<I: Interner> TypeVisitor<I> for ValidateBoundVars<I> {
 
     fn visit_ty(&mut self, t: I::Ty) -> Self::Result {
         if t.outer_exclusive_binder() < self.binder_index
-            || !self.visited.insert((self.binder_index, t))
+            || !self.visited_tys.insert((self.binder_index, t))
         {
             return ControlFlow::Break(());
         }
@@ -319,6 +319,24 @@ impl<I: Interner> TypeVisitor<I> for ValidateBoundVars<I> {
         t.super_visit_with(self)
     }
 
+    fn visit_const(&mut self, c: I::Const) -> Self::Result {
+        if c.outer_exclusive_binder() < self.binder_index {
+            return ControlFlow::Break(());
+        }
+        match c.kind() {
+            ty::ConstKind::Bound(debruijn, bound_const) if debruijn == self.binder_index => {
+                let idx = bound_const.var().as_usize();
+                if self.bound_vars.len() <= idx {
+                    panic!("Not enough bound vars: {:?} not found in {:?}", c, self.bound_vars);
+                }
+                bound_const.assert_eq(self.bound_vars.get(idx).unwrap());
+            }
+            _ => {}
+        };
+
+        c.super_visit_with(self)
+    }
+
     fn visit_region(&mut self, r: I::Region) -> Self::Result {
         match r.kind() {
             ty::ReBound(index, br) if index == self.binder_index => {