Fix build failure

Author: amandasystems

compiler/rustc_borrowck/src/diagnostics/region_errors.rs

@@ -190,17 +190,16 @@ impl<'infcx, 'tcx> MirBorrowckCtxt<'_, 'infcx, 'tcx> {
     /// `to_error_region`.
     pub(super) fn to_error_region_vid(&self, r: RegionVid) -> Option<RegionVid> {
         if self.regioncx.universal_regions().is_universal_region(r) {
-            Some(r)
-        } else {
-            // We just want something nameable, even if it's not
-            // actually an upper bound.
-            let upper_bound = self.regioncx.approx_universal_upper_bound(r);
+            return Some(r);
+        }
+        // We just want something nameable, even if it's not
+        // actually an upper bound.
+        let upper_bound = self.regioncx.approx_universal_upper_bound(r);
 
-            if self.regioncx.upper_bound_in_region_scc(r, upper_bound) {
-                self.to_error_region_vid(upper_bound)
-            } else {
-                None
-            }
+        if self.regioncx.upper_bound_in_region_scc(r, upper_bound) {
+            self.to_error_region_vid(upper_bound)
+        } else {
+            None
         }
     }
 
@@ -210,7 +209,7 @@ impl<'infcx, 'tcx> MirBorrowckCtxt<'_, 'infcx, 'tcx> {
         T: TypeFoldable<TyCtxt<'tcx>>,
     {
         fold_regions(tcx, ty, |region, _| match *region {
-            ty::ReVar(vid) => self.to_error_region(vid).unwrap_or(region),
+            ty::ReVar(vid) => self.regioncx.first_named_region_reached(vid).unwrap_or(region),
             _ => region,
         })
     }
@@ -373,7 +372,8 @@ impl<'infcx, 'tcx> MirBorrowckCtxt<'_, 'infcx, 'tcx> {
                         );
                     };
                     debug!(?lower_bound_region);
-                    let generic_ty = generic_kind.to_ty(self.infcx.tcx);
+                    let generic_ty =
+                        self.name_regions(self.infcx.tcx, generic_kind.to_ty(self.infcx.tcx));
                     let origin = RelateParamBound(type_test_span, generic_ty, None);
                     self.buffer_error(self.infcx.err_ctxt().construct_generic_bound_failure(
                         self.body.source.def_id().expect_local(),

compiler/rustc_borrowck/src/eliminate_placeholders.rs

@@ -619,9 +619,6 @@ fn rewrite_verify_bound<'t>(
         // in an unnameable universe, they would compare equal since they
         // are both empty. This bit checks if we
         VerifyBound::IfEq(binder) => {
-            info!("Assuming, incorrectly, that Eq bound is universe-fine: {binder:?}");
-
-            // FIXME: does it matter that I don't normalise to SCCs?
             match test_type_match::extract_verify_if_eq(tcx, &binder, generic_kind.to_ty(tcx)) {
                 Some(r) => {
                     let r_vid = universal_regions.to_region_vid(r);
@@ -638,7 +635,13 @@ fn rewrite_verify_bound<'t>(
                         Either::Right(RewrittenVerifyBound::Unsatisfied)
                     }
                 }
-                None => Either::Right(RewrittenVerifyBound::Unsatisfied),
+                None => {
+                    info!(
+                        "Failed to extract type from {:#?}; assuming we are fine!",
+                        generic_kind.to_ty(tcx)
+                    );
+                    Either::Left(bound)
+                }
             }
         }
         // Rewrite an outlives bound to an outlives-static bound upon referencing

compiler/rustc_borrowck/src/region_infer/mod.rs

@@ -957,6 +957,19 @@ impl<'tcx> RegionInferenceContext<'tcx> {
         Some(ClosureOutlivesSubject::Ty(ClosureOutlivesSubjectTy::bind(tcx, ty)))
     }
 
+    /// Returns the first named region reachable in the constraint graph
+    /// from `from`. For when you are really desperate for something
+    /// nameable.
+    #[instrument(level = "info", skip(self), ret)]
+    pub(crate) fn first_named_region_reached(&self, from: RegionVid) -> Option<ty::Region<'tcx>> {
+        self.find_constraint_path_to(
+            from,
+            |reached| self.region_definition(reached).external_name.is_some(),
+            true,
+        )
+        .and_then(|x| self.region_definition(x.1).external_name)
+    }
+
     /// Like `universal_upper_bound`, but returns an approximation more suitable
     /// for diagnostics. If `r` contains multiple disjoint universal regions
     /// (e.g. 'a and 'b in `fn foo<'a, 'b> { ... }`, we pick the lower-numbered region.