Introduce ReError

CC rust-lang#69314

Author: estebank

compiler/rustc_borrowck/src/diagnostics/region_name.rs

@@ -343,11 +343,11 @@ impl<'tcx> MirBorrowckCtxt<'_, 'tcx> {
                     let note = match closure_kind_ty.to_opt_closure_kind() {
                         Some(ty::ClosureKind::Fn) => {
                             "closure implements `Fn`, so references to captured variables \
-                                can't escape the closure"
+                             can't escape the closure"
                         }
                         Some(ty::ClosureKind::FnMut) => {
                             "closure implements `FnMut`, so references to captured variables \
-                                can't escape the closure"
+                             can't escape the closure"
                         }
                         Some(ty::ClosureKind::FnOnce) => {
                             bug!("BrEnv in a `FnOnce` closure");
@@ -364,7 +364,11 @@ impl<'tcx> MirBorrowckCtxt<'_, 'tcx> {
                 ty::BoundRegionKind::BrAnon(..) => None,
             },
 
-            ty::ReLateBound(..) | ty::ReVar(..) | ty::RePlaceholder(..) | ty::ReErased => None,
+            ty::ReLateBound(..)
+            | ty::ReVar(..)
+            | ty::RePlaceholder(..)
+            | ty::ReErased
+            | ty::ReError => None,
         }
     }
 

compiler/rustc_borrowck/src/region_infer/opaque_types.rs

@@ -95,7 +95,7 @@ impl<'tcx> RegionInferenceContext<'tcx> {
                             concrete_type.span,
                             "opaque type with non-universal region substs",
                         );
-                        infcx.tcx.lifetimes.re_static
+                        infcx.tcx.lifetimes.re_error
                     }
                 }
             };

compiler/rustc_borrowck/src/universal_regions.rs

@@ -821,6 +821,8 @@ impl<'tcx> UniversalRegionIndices<'tcx> {
     pub fn to_region_vid(&self, r: ty::Region<'tcx>) -> RegionVid {
         if let ty::ReVar(..) = *r {
             r.to_region_vid()
+        } else if let ty::ReError = *r {
+            RegionVid::new(0)
         } else {
             *self
                 .indices

compiler/rustc_hir_analysis/src/astconv/mod.rs

@@ -264,10 +264,7 @@ impl<'o, 'tcx> dyn AstConv<'tcx> + 'o {
                     // reported an error in this case -- but if
                     // not, let's error out.
                     tcx.sess.delay_span_bug(lifetime.ident.span, "unelided lifetime in signature");
-
-                    // Supply some dummy value. We don't have an
-                    // `re_error`, annoyingly, so use `'static`.
-                    tcx.lifetimes.re_static
+                    tcx.lifetimes.re_error
                 })
             }
         }
@@ -482,10 +479,7 @@ impl<'o, 'tcx> dyn AstConv<'tcx> + 'o {
 
                             // This indicates an illegal lifetime in a non-assoc-trait position
                             tcx.sess.delay_span_bug(self.span, "unelided lifetime in signature");
-
-                            // Supply some dummy value. We don't have an
-                            // `re_error`, annoyingly, so use `'static`.
-                            tcx.lifetimes.re_static
+                            tcx.lifetimes.re_error
                         })
                         .into(),
                     GenericParamDefKind::Type { has_default, .. } => {
@@ -1629,7 +1623,7 @@ impl<'o, 'tcx> dyn AstConv<'tcx> + 'o {
                         } else {
                             err.emit();
                         }
-                        tcx.lifetimes.re_static
+                        tcx.lifetimes.re_error
                     })
                 }
             })

compiler/rustc_hir_analysis/src/check/compare_impl_item.rs

@@ -792,7 +792,7 @@ pub(super) fn collect_return_position_impl_trait_in_trait_tys<'tcx>(
                                 return_span,
                                 "expected ReFree to map to ReEarlyBound"
                             );
-                        return tcx.lifetimes.re_static;
+                        return tcx.lifetimes.re_error;
                     };
                     tcx.mk_region(ty::ReEarlyBound(ty::EarlyBoundRegion {
                         def_id: e.def_id,

compiler/rustc_hir_analysis/src/collect/type_of.rs

@@ -928,7 +928,7 @@ fn infer_placeholder_type<'a>(
 
     // Typeck doesn't expect erased regions to be returned from `type_of`.
     tcx.fold_regions(ty, |r, _| match *r {
-        ty::ReErased => tcx.lifetimes.re_static,
+        ty::ReErased | ty::ReError => tcx.lifetimes.re_static,
         _ => r,
     })
 }

compiler/rustc_hir_analysis/src/outlives/utils.rs

@@ -170,6 +170,8 @@ fn is_free_region(region: Region<'_>) -> bool {
         // ignore it. We can't put it on the struct header anyway.
         ty::ReLateBound(..) => false,
 
+        ty::ReError => false,
+
         // These regions don't appear in types from type declarations:
         ty::ReErased | ty::ReVar(..) | ty::RePlaceholder(..) | ty::ReFree(..) => {
             bug!("unexpected region in outlives inference: {:?}", region);

compiler/rustc_hir_analysis/src/variance/constraints.rs

@@ -409,6 +409,8 @@ impl<'a, 'tcx> ConstraintContext<'a, 'tcx> {
                 // way early-bound regions do, so we skip them here.
             }
 
+            ty::ReError => {}
+
             ty::ReFree(..) | ty::ReVar(..) | ty::RePlaceholder(..) | ty::ReErased => {
                 // We don't expect to see anything but 'static or bound
                 // regions when visiting member types or method types.

compiler/rustc_infer/src/errors/note_and_explain.rs

@@ -31,6 +31,8 @@ impl<'a> DescriptionCtx<'a> {
 
             ty::RePlaceholder(_) => return None,
 
+            ty::ReError => return None,
+
             // FIXME(#13998) RePlaceholder should probably print like
             // ReFree rather than dumping Debug output on the user.
             //

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

@@ -371,6 +371,7 @@ impl<'cx, 'tcx> TypeFolder<'tcx> for Canonicalizer<'cx, 'tcx> {
 
             ty::ReStatic
             | ty::ReEarlyBound(..)
+            | ty::ReError
             | ty::ReFree(_)
             | ty::RePlaceholder(..)
             | ty::ReErased => self.canonicalize_mode.canonicalize_free_region(self, r),