introduce fallible universal region to region inference var conversion

and use it to clean up variance extraction

Author: lqd

compiler/rustc_borrowck/src/polonius/liveness_constraints.rs

@@ -231,11 +231,9 @@ struct VarianceExtractor<'a, 'tcx> {
 impl<'tcx> VarianceExtractor<'_, 'tcx> {
     fn record_variance(&mut self, region: ty::Region<'tcx>, variance: ty::Variance) {
         // We're only interested in the variance of vars and free regions.
-
-        if region.is_bound() || region.is_erased() {
-            // ignore these
+        let Some(region) = self.universal_regions.try_to_region_vid(region) else {
             return;
-        }
+        };
 
         let direction = match variance {
             ty::Variance::Covariant => ConstraintDirection::Forward,
@@ -247,7 +245,6 @@ impl<'tcx> VarianceExtractor<'_, 'tcx> {
             }
         };
 
-        let region = self.universal_regions.to_region_vid(region);
         self.directions
             .entry(region)
             .and_modify(|entry| {

compiler/rustc_borrowck/src/universal_regions.rs

@@ -337,11 +337,16 @@ impl<'tcx> UniversalRegions<'tcx> {
         self.indices.indices.iter().map(|(&r, &v)| (r, v))
     }
 
-    /// See `UniversalRegionIndices::to_region_vid`.
+    /// See [UniversalRegionIndices::to_region_vid].
     pub(crate) fn to_region_vid(&self, r: ty::Region<'tcx>) -> RegionVid {
         self.indices.to_region_vid(r)
     }
 
+    /// See [UniversalRegionIndices::try_to_region_vid].
+    pub(crate) fn try_to_region_vid(&self, r: ty::Region<'tcx>) -> Option<RegionVid> {
+        self.indices.try_to_region_vid(r)
+    }
+
     /// As part of the NLL unit tests, you can annotate a function with
     /// `#[rustc_regions]`, and we will emit information about the region
     /// inference context and -- in particular -- the external constraints
@@ -886,19 +891,25 @@ impl<'tcx> UniversalRegionIndices<'tcx> {
     /// if it is a placeholder. Handling placeholders requires access to the
     /// `MirTypeckRegionConstraints`.
     fn to_region_vid(&self, r: ty::Region<'tcx>) -> RegionVid {
+        self.try_to_region_vid(r)
+            .unwrap_or_else(|| bug!("cannot convert `{:?}` to a region vid", r))
+    }
+
+    /// Converts `r` into a local inference variable.
+    /// This is a fallible version of [UniversalRegionIndices::to_region_vid], see that method for
+    /// more details.
+    #[inline]
+    fn try_to_region_vid(&self, r: ty::Region<'tcx>) -> Option<RegionVid> {
         if let ty::ReVar(..) = *r {
-            r.as_var()
+            Some(r.as_var())
         } else if let ty::ReError(guar) = *r {
             self.tainted_by_errors.set(Some(guar));
             // We use the `'static` `RegionVid` because `ReError` doesn't actually exist in the
             // `UniversalRegionIndices`. This is fine because 1) it is a fallback only used if
             // errors are being emitted and 2) it leaves the happy path unaffected.
-            self.fr_static
+            Some(self.fr_static)
         } else {
-            *self
-                .indices
-                .get(&r)
-                .unwrap_or_else(|| bug!("cannot convert `{:?}` to a region vid", r))
+            self.indices.get(&r).copied()
         }
     }