simply the IfEq bound -- we only ever use a region

the excessive generality becomes annoying later because
it wouldn't implement type folding etc

Author: nikomatsakis

compiler/rustc_borrowck/src/region_infer/mod.rs

@@ -1170,9 +1170,14 @@ impl<'tcx> RegionInferenceContext<'tcx> {
         debug!("eval_verify_bound(lower_bound={:?}, verify_bound={:?})", lower_bound, verify_bound);
 
         match verify_bound {
-            VerifyBound::IfEq(test_ty, verify_bound1) => {
-                self.eval_if_eq(tcx, body, generic_ty, lower_bound, *test_ty, verify_bound1)
-            }
+            VerifyBound::IfEq(test_ty, verify_bound1) => self.eval_if_eq(
+                tcx,
+                body,
+                generic_ty,
+                lower_bound,
+                *test_ty,
+                &VerifyBound::OutlivedBy(*verify_bound1),
+            ),
 
             VerifyBound::IsEmpty => {
                 let lower_bound_scc = self.constraint_sccs.scc(lower_bound);

compiler/rustc_infer/src/infer/lexical_region_resolve/mod.rs

@@ -818,9 +818,9 @@ impl<'cx, 'tcx> LexicalResolver<'cx, 'tcx> {
         min: ty::Region<'tcx>,
     ) -> bool {
         match bound {
-            VerifyBound::IfEq(k, b) => {
+            VerifyBound::IfEq(k, r) => {
                 (var_values.normalize(self.region_rels.tcx, *k) == generic_ty)
-                    && self.bound_is_met(b, var_values, generic_ty, min)
+                    && self.bound_is_met(&VerifyBound::OutlivedBy(*r), var_values, generic_ty, min)
             }
 
             VerifyBound::OutlivedBy(r) => {

compiler/rustc_infer/src/infer/outlives/verify.rs

@@ -160,14 +160,13 @@ impl<'cx, 'tcx> VerifyBoundCx<'cx, 'tcx> {
             .projection_approx_declared_bounds_from_env(projection_ty)
             .into_iter()
             .map(|ty::OutlivesPredicate(ty, r)| {
-                let vb = VerifyBound::OutlivedBy(r);
                 if ty == projection_ty_as_ty {
                     // Micro-optimize if this is an exact match (this
                     // occurs often when there are no region variables
                     // involved).
-                    vb
+                    VerifyBound::OutlivedBy(r)
                 } else {
-                    VerifyBound::IfEq(ty, Box::new(vb))
+                    VerifyBound::IfEq(ty, r)
                 }
             });
 

compiler/rustc_infer/src/infer/region_constraints/mod.rs

@@ -224,7 +224,7 @@ pub enum VerifyBound<'tcx> {
     ///
     /// meaning, if the subject G is equal to `<T as Trait<'a>>::Item`
     /// (after inference), and `'a: min`, then `G: min`.
-    IfEq(Ty<'tcx>, Box<VerifyBound<'tcx>>),
+    IfEq(Ty<'tcx>, Region<'tcx>),
 
     /// Given a region `R`, expands to the function:
     ///
@@ -770,7 +770,7 @@ impl<'tcx> VerifyBound<'tcx> {
 
     pub fn cannot_hold(&self) -> bool {
         match self {
-            VerifyBound::IfEq(_, b) => b.cannot_hold(),
+            VerifyBound::IfEq(_, _) => false,
             VerifyBound::IsEmpty => false,
             VerifyBound::OutlivedBy(_) => false,
             VerifyBound::AnyBound(bs) => bs.iter().all(|b| b.cannot_hold()),