rename RegionVariableOrigin::MiscVariable to RegionVariableOrigin::Misc

compiler/rustc_borrowck/src/type_check/input_output.rs

@@ -66,10 +66,9 @@ impl<'a, 'tcx> TypeChecker<'a, 'tcx> {
                 Ty::new_tup(self.tcx(), user_provided_sig.inputs()),
                 args.tupled_upvars_ty(),
                 args.coroutine_captures_by_ref_ty(),
-                self.infcx
+                self.infcx.next_region_var(RegionVariableOrigin::Misc(self.body.span), || {
-                    .next_region_var(RegionVariableOrigin::MiscVariable(self.body.span), || {
+                    RegionCtxt::Unknown
-                        RegionCtxt::Unknown
+                }),
-                    }),
             );
 
             let next_ty_var = || self.infcx.next_ty_var(self.body.span);

compiler/rustc_hir_analysis/src/check/check.rs

@@ -312,7 +312,7 @@ fn check_opaque_meets_bounds<'tcx>(
     // here rather than using ReErased.
     let hidden_ty = tcx.type_of(def_id.to_def_id()).instantiate(tcx, args);
     let hidden_ty = fold_regions(tcx, hidden_ty, |re, _dbi| match re.kind() {
-        ty::ReErased => infcx.next_region_var(RegionVariableOrigin::MiscVariable(span)),
+        ty::ReErased => infcx.next_region_var(RegionVariableOrigin::Misc(span)),
         _ => re,
     });
 

compiler/rustc_hir_typeck/src/check.rs

@@ -58,7 +58,7 @@ pub(super) fn check_fn<'a, 'tcx>(
     let maybe_va_list = fn_sig.c_variadic.then(|| {
         let span = body.params.last().unwrap().span;
         let va_list_did = tcx.require_lang_item(LangItem::VaList, span);
-        let region = fcx.next_region_var(RegionVariableOrigin::MiscVariable(span));
+        let region = fcx.next_region_var(RegionVariableOrigin::Misc(span));
 
         tcx.type_of(va_list_did).instantiate(tcx, &[region.into()])
     });

compiler/rustc_hir_typeck/src/fn_ctxt/mod.rs

@@ -247,7 +247,7 @@ impl<'tcx> HirTyLowerer<'tcx> for FnCtxt<'_, 'tcx> {
             RegionInferReason::Param(def) => {
                 RegionVariableOrigin::RegionParameterDefinition(span, def.name)
             }
-            _ => RegionVariableOrigin::MiscVariable(span),
+            _ => RegionVariableOrigin::Misc(span),
         };
         self.next_region_var(v)
     }

compiler/rustc_hir_typeck/src/method/suggest.rs

@@ -2352,9 +2352,9 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                     if !arg.is_suggestable(self.tcx, true) {
                         has_unsuggestable_args = true;
                         match arg.kind() {
-                            GenericArgKind::Lifetime(_) => self
+                            GenericArgKind::Lifetime(_) => {
-                                .next_region_var(RegionVariableOrigin::MiscVariable(DUMMY_SP))
+                                self.next_region_var(RegionVariableOrigin::Misc(DUMMY_SP)).into()
-                                .into(),
+                            }
                             GenericArgKind::Type(_) => self.next_ty_var(DUMMY_SP).into(),
                             GenericArgKind::Const(_) => self.next_const_var(DUMMY_SP).into(),
                         }

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

@@ -128,10 +128,7 @@ impl<'tcx> InferCtxt<'tcx> {
             }
 
             CanonicalVarKind::Region(ui) => self
-                .next_region_var_in_universe(
+                .next_region_var_in_universe(RegionVariableOrigin::Misc(span), universe_map(ui))
-                    RegionVariableOrigin::MiscVariable(span),
-                    universe_map(ui),
-                )
                 .into(),
 
             CanonicalVarKind::PlaceholderRegion(ty::PlaceholderRegion { universe, bound }) => {

compiler/rustc_infer/src/infer/context.rs

@@ -141,7 +141,7 @@ impl<'tcx> rustc_type_ir::InferCtxtLike for InferCtxt<'tcx> {
     }
 
     fn next_region_infer(&self) -> ty::Region<'tcx> {
-        self.next_region_var(RegionVariableOrigin::MiscVariable(DUMMY_SP))
+        self.next_region_var(RegionVariableOrigin::Misc(DUMMY_SP))
     }
 
     fn next_ty_infer(&self) -> Ty<'tcx> {

compiler/rustc_infer/src/infer/mod.rs

@@ -400,7 +400,7 @@ pub enum RegionVariableOrigin {
     /// Region variables created for ill-categorized reasons.
     ///
     /// They mostly indicate places in need of refactoring.
-    MiscVariable(Span),
+    Misc(Span),
 
     /// Regions created by a `&P` or `[...]` pattern.
     PatternRegion(Span),
@@ -1526,7 +1526,7 @@ impl<'tcx> SubregionOrigin<'tcx> {
 impl RegionVariableOrigin {
     pub fn span(&self) -> Span {
         match *self {
-            RegionVariableOrigin::MiscVariable(a)
+            RegionVariableOrigin::Misc(a)
             | RegionVariableOrigin::PatternRegion(a)
             | RegionVariableOrigin::BorrowRegion(a)
             | RegionVariableOrigin::Autoref(a)

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

@@ -262,9 +262,7 @@ impl<'tcx> InferCtxt<'tcx> {
                         .type_of_opaque_hir_typeck(opaque_type_key.def_id)
                         .instantiate(self.tcx, opaque_type_key.args);
                     let actual = ty::fold_regions(tcx, actual, |re, _dbi| match re.kind() {
-                        ty::ReErased => {
+                        ty::ReErased => self.next_region_var(RegionVariableOrigin::Misc(span)),
-                            self.next_region_var(RegionVariableOrigin::MiscVariable(span))
-                        }
                         _ => re,
                     });
                     actual

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

@@ -580,7 +580,7 @@ impl<'tcx> RegionConstraintCollector<'_, 'tcx> {
         let a_universe = self.universe(a);
         let b_universe = self.universe(b);
         let c_universe = cmp::max(a_universe, b_universe);
-        let c = self.new_region_var(c_universe, RegionVariableOrigin::MiscVariable(origin.span()));
+        let c = self.new_region_var(c_universe, RegionVariableOrigin::Misc(origin.span()));
         self.combine_map(t).insert(vars, c);
         self.undo_log.push(AddCombination(t, vars));
         let new_r = ty::Region::new_var(tcx, c);

compiler/rustc_infer/src/infer/relate/generalize.rs

@@ -603,10 +603,9 @@ impl<'tcx> TypeRelation<TyCtxt<'tcx>> for Generalizer<'_, 'tcx> {
             }
         }
 
-        Ok(self.infcx.next_region_var_in_universe(
+        Ok(self
-            RegionVariableOrigin::MiscVariable(self.span),
+            .infcx
-            self.for_universe,
+            .next_region_var_in_universe(RegionVariableOrigin::Misc(self.span), self.for_universe))
-        ))
     }
 
     #[instrument(level = "debug", skip(self, c2), ret)]

compiler/rustc_trait_selection/src/error_reporting/infer/region.rs

@@ -1015,7 +1015,7 @@ impl<'a, 'tcx> TypeErrCtxt<'a, 'tcx> {
             s
         };
         let var_description = match var_origin {
-            RegionVariableOrigin::MiscVariable(_) => String::new(),
+            RegionVariableOrigin::Misc(_) => String::new(),
             RegionVariableOrigin::PatternRegion(_) => " for pattern".to_string(),
             RegionVariableOrigin::BorrowRegion(_) => " for borrow expression".to_string(),
             RegionVariableOrigin::Autoref(_) => " for autoref".to_string(),

compiler/rustc_trait_selection/src/solve/delegate.rs

@@ -154,7 +154,7 @@ impl<'tcx> rustc_next_trait_solver::delegate::SolverDelegate for SolverDelegate<
     ) -> ty::GenericArg<'tcx> {
         match arg.kind() {
             ty::GenericArgKind::Lifetime(_) => {
-                self.next_region_var(RegionVariableOrigin::MiscVariable(span)).into()
+                self.next_region_var(RegionVariableOrigin::Misc(span)).into()
             }
             ty::GenericArgKind::Type(_) => self.next_ty_var(span).into(),
             ty::GenericArgKind::Const(_) => self.next_const_var(span).into(),