resolve to universal regions when possible

compiler/rustc_infer/src/infer/canonical/canonicalizer.rs

@@ -352,19 +352,17 @@ fn fold_region(&mut self, r: ty::Region<'tcx>) -> ty::Region<'tcx> {
             }
 
             ty::ReVar(vid) => {
-                let resolved_vid = self
+                let resolved = self
                     .infcx
                     .inner
                     .borrow_mut()
                     .unwrap_region_constraints()
-                    .opportunistic_resolve_var(vid);
+                    .opportunistic_resolve_var(self.tcx, vid);
                 debug!(
-                    "canonical: region var found with vid {:?}, \
+                    "canonical: region var found with vid {vid:?}, \
-                     opportunistically resolved to {:?}",
+                     opportunistically resolved to {resolved:?}",
-                    vid, resolved_vid
                 );
-                let r = self.tcx.mk_re_var(resolved_vid);
+                self.canonicalize_mode.canonicalize_free_region(self, resolved)
-                self.canonicalize_mode.canonicalize_free_region(self, r)
             }
 
             ty::ReStatic

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

@@ -633,29 +633,15 @@ pub(super) fn glb_regions(
         }
     }
 
-    /// Resolves the passed RegionVid to the root RegionVid in the unification table
+    /// Resolves a region var to its value in the unification table, if it exists.
-    pub(super) fn opportunistic_resolve_var(&mut self, rid: ty::RegionVid) -> ty::RegionVid {
+    /// Otherwise, it is resolved to the root `ReVar` in the table.
-        self.unification_table().find(rid).vid
+    pub fn opportunistic_resolve_var(
-    }
-
-    /// If the Region is a `ReVar`, then resolves it either to the root value in
-    /// the unification table, if it exists, or to the root `ReVar` in the table.
-    /// If the Region is not a `ReVar`, just returns the Region itself.
-    pub fn opportunistic_resolve_region(
         &mut self,
         tcx: TyCtxt<'tcx>,
-        region: ty::Region<'tcx>,
+        vid: ty::RegionVid,
     ) -> ty::Region<'tcx> {
-        match *region {
+        let root_vid = self.unification_table().find(vid).vid;
-            ty::ReVar(rid) => {
+        self.unification_table().probe_value(root_vid).0.unwrap_or_else(|| tcx.mk_re_var(root_vid))
-                let unified_region = self.unification_table().probe_value(rid);
-                unified_region.0.unwrap_or_else(|| {
-                    let root = self.unification_table().find(rid).vid;
-                    tcx.mk_re_var(root)
-                })
-            }
-            _ => region,
-        }
     }
 
     fn combine_map(&mut self, t: CombineMapType) -> &mut CombineMap<'tcx> {

compiler/rustc_infer/src/infer/resolve.rs

@@ -85,15 +85,12 @@ fn fold_ty(&mut self, t: Ty<'tcx>) -> Ty<'tcx> {
 
     fn fold_region(&mut self, r: ty::Region<'tcx>) -> ty::Region<'tcx> {
         match *r {
-            ty::ReVar(rid) => {
+            ty::ReVar(vid) => self
-                let resolved = self
+                .infcx
-                    .infcx
+                .inner
-                    .inner
+                .borrow_mut()
-                    .borrow_mut()
+                .unwrap_region_constraints()
-                    .unwrap_region_constraints()
+                .opportunistic_resolve_var(TypeFolder::interner(self), vid),
-                    .opportunistic_resolve_var(rid);
-                TypeFolder::interner(self).mk_re_var(resolved)
-            }
             _ => r,
         }
     }

compiler/rustc_trait_selection/src/traits/project.rs

@@ -871,12 +871,12 @@ fn fold_binder<T: TypeFoldable<TyCtxt<'tcx>>>(
 
     fn fold_region(&mut self, r0: ty::Region<'tcx>) -> ty::Region<'tcx> {
         let r1 = match *r0 {
-            ty::ReVar(_) => self
+            ty::ReVar(vid) => self
                 .infcx
                 .inner
                 .borrow_mut()
                 .unwrap_region_constraints()
-                .opportunistic_resolve_region(self.infcx.tcx, r0),
+                .opportunistic_resolve_var(self.infcx.tcx, vid),
             _ => r0,
         };