pass UniversalRegions to MIR type-checker instead of fields

No functional change.

Author: nikomatsakis

src/librustc_mir/borrow_check/nll/mod.rs

@@ -79,16 +79,12 @@ pub(in borrow_check) fn compute_regions<'cx, 'gcx, 'tcx>(
     // Run the MIR type-checker.
     let mir_node_id = infcx.tcx.hir.as_local_node_id(def_id).unwrap();
     let liveness = &LivenessResults::compute(mir);
-    let fr_fn_body = infcx.tcx.mk_region(ty::ReVar(universal_regions.fr_fn_body));
     let constraint_sets = &type_check::type_check(
         infcx,
         mir_node_id,
         param_env,
         mir,
-        &universal_regions.region_bound_pairs,
-        fr_fn_body,
-        universal_regions.input_tys,
-        universal_regions.output_ty,
+        &universal_regions,
         &liveness,
         flow_inits,
         move_data,

src/librustc_mir/borrow_check/nll/type_check/mod.rs

@@ -13,6 +13,7 @@
 
 use borrow_check::nll::region_infer::Cause;
 use borrow_check::nll::region_infer::ClosureRegionRequirementsExt;
+use borrow_check::nll::universal_regions::UniversalRegions;
 use dataflow::FlowAtLocation;
 use dataflow::MaybeInitializedLvals;
 use dataflow::move_paths::MoveData;
@@ -71,28 +72,32 @@ pub(crate) fn type_check<'gcx, 'tcx>(
     body_id: ast::NodeId,
     param_env: ty::ParamEnv<'gcx>,
     mir: &Mir<'tcx>,
-    region_bound_pairs: &[(ty::Region<'tcx>, GenericKind<'tcx>)],
-    implicit_region_bound: ty::Region<'tcx>,
-    input_tys: &[Ty<'tcx>],
-    output_ty: Ty<'tcx>,
+    universal_regions: &UniversalRegions<'tcx>,
     liveness: &LivenessResults,
     flow_inits: &mut FlowAtLocation<MaybeInitializedLvals<'_, 'gcx, 'tcx>>,
     move_data: &MoveData<'tcx>,
 ) -> MirTypeckRegionConstraints<'tcx> {
+    let implicit_region_bound = infcx.tcx.mk_region(ty::ReVar(universal_regions.fr_fn_body));
     type_check_internal(
         infcx,
         body_id,
         param_env,
         mir,
-        region_bound_pairs,
+        &universal_regions.region_bound_pairs,
         Some(implicit_region_bound),
         &mut |cx| {
             liveness::generate(cx, mir, liveness, flow_inits, move_data);
 
             // Equate the input and output tys given by the user with
             // the ones found in the MIR.
-            cx.equate_input_or_output(output_ty, mir.local_decls[RETURN_PLACE].ty);
-            for (&input_ty, local) in input_tys.iter().zip((1..).map(Local::new)) {
+            let &UniversalRegions {
+                unnormalized_output_ty,
+                unnormalized_input_tys,
+                ..
+            } = universal_regions;
+            cx.equate_input_or_output(unnormalized_output_ty, mir.local_decls[RETURN_PLACE].ty);
+            let arg_locals = (1..).map(Local::new);
+            for (&input_ty, local) in unnormalized_input_tys.iter().zip(arg_locals) {
                 cx.equate_input_or_output(input_ty, mir.local_decls[local].ty);
             }
         },

src/librustc_mir/borrow_check/nll/universal_regions.rs

@@ -70,16 +70,18 @@ pub struct UniversalRegions<'tcx> {
     pub defining_ty: DefiningTy<'tcx>,
 
     /// The return type of this function, with all regions replaced by
-    /// their universal `RegionVid` equivalents. This type is **NOT
-    /// NORMALIZED** (i.e., it contains unnormalized associated type
-    /// projections).
-    pub output_ty: Ty<'tcx>,
+    /// their universal `RegionVid` equivalents.
+    ///
+    /// NB. Associated types in this type have not been normalized,
+    /// as the name suggests. =)
+    pub unnormalized_output_ty: Ty<'tcx>,
 
     /// The fully liberated input types of this function, with all
     /// regions replaced by their universal `RegionVid` equivalents.
-    /// This type is **NOT NORMALIZED** (i.e., it contains
-    /// unnormalized associated type projections).
-    pub input_tys: &'tcx [Ty<'tcx>],
+    ///
+    /// NB. Associated types in these types have not been normalized,
+    /// as the name suggests. =)
+    pub unnormalized_input_tys: &'tcx [Ty<'tcx>],
 
     /// Each RBP `('a, GK)` indicates that `GK: 'a` can be assumed to
     /// be true. These encode relationships like `T: 'a` that are
@@ -479,7 +481,8 @@ impl<'cx, 'gcx, 'tcx> UniversalRegionsBuilder<'cx, 'gcx, 'tcx> {
             self.relations.relate_universal_regions(fr, fr_fn_body);
         }
 
-        let (output_ty, input_tys) = inputs_and_output.split_last().unwrap();
+        let (unnormalized_output_ty, unnormalized_input_tys) =
+            inputs_and_output.split_last().unwrap();
 
         // we should not have created any more variables
         assert_eq!(self.infcx.num_region_vars(), num_universals);
@@ -508,8 +511,8 @@ impl<'cx, 'gcx, 'tcx> UniversalRegionsBuilder<'cx, 'gcx, 'tcx> {
             first_local_index,
             num_universals,
             defining_ty,
-            output_ty,
-            input_tys,
+            unnormalized_output_ty,
+            unnormalized_input_tys,
             region_bound_pairs: self.region_bound_pairs,
             relations: self.relations,
         }