Fix nits

Author: amandasystems

compiler/rustc_borrowck/src/diagnostics/find_use.rs

@@ -15,7 +15,7 @@ pub(crate) fn find<'tcx>(
     region_vid: RegionVid,
     start_point: Location,
 ) -> Option<Cause> {
-    let mut uf = UseFinder { body, tcx, region_vid, start_point, scc_values: &scc_values };
+    let mut uf = UseFinder { body, tcx, region_vid, start_point, scc_values };
 
     uf.find()
 }

compiler/rustc_borrowck/src/diagnostics/opaque_types.rs

@@ -208,8 +208,8 @@ impl<'infcx, 'tcx> MirBorrowckCtxt<'_, 'infcx, 'tcx> {
 struct FindOpaqueRegion<'a, 'tcx> {
     tcx: TyCtxt<'tcx>,
     constraint_search: ConstraintSearch<'a, 'tcx>,
-    borrow_region: ty::RegionVid,
     universal_regions: &'a UniversalRegions<'tcx>,
+    borrow_region: ty::RegionVid,
 }
 
 impl<'tcx> TypeVisitor<TyCtxt<'tcx>> for FindOpaqueRegion<'_, 'tcx> {

compiler/rustc_borrowck/src/diagnostics/region_name.rs

@@ -248,7 +248,7 @@ impl<'tcx> MirBorrowckCtxt<'_, '_, 'tcx> {
             self.next_region_name.try_borrow().unwrap()
         );
 
-        //FIXME! assert!(self.regioncx.universal_regions().is_universal_region(fr));
+        assert!(self.universal_regions().is_universal_region(fr));
 
         match self.region_names.borrow_mut().entry(fr) {
             IndexEntry::Occupied(precomputed_name) => Some(*precomputed_name.get()),
@@ -385,13 +385,12 @@ impl<'tcx> MirBorrowckCtxt<'_, '_, 'tcx> {
         &self,
         fr: RegionVid,
     ) -> Option<RegionName> {
-        let implicit_inputs = self.universal_regions().defining_ty.implicit_inputs();
-        let argument_index =
-            self.universal_regions().get_argument_index_for_region(self.infcx.tcx, fr)?;
+        let universals = self.universal_regions();
+        let implicit_inputs = universals.defining_ty.implicit_inputs();
+        let argument_index = universals.get_argument_index_for_region(self.infcx.tcx, fr)?;
 
-        let arg_ty =
-            self.universal_regions().unnormalized_input_tys[implicit_inputs + argument_index];
-        let (_, span) = self.universal_regions().get_argument_name_and_span_for_region(
+        let arg_ty = universals.unnormalized_input_tys[implicit_inputs + argument_index];
+        let (_, span) = universals.get_argument_name_and_span_for_region(
             self.body,
             self.local_names(),
             argument_index,
@@ -644,13 +643,10 @@ impl<'tcx> MirBorrowckCtxt<'_, '_, 'tcx> {
     /// ```
     #[instrument(level = "trace", skip(self))]
     fn give_name_if_anonymous_region_appears_in_upvars(&self, fr: RegionVid) -> Option<RegionName> {
-        let upvar_index =
-            self.universal_regions().get_upvar_index_for_region(self.infcx.tcx, fr)?;
-        let (upvar_name, upvar_span) = self.universal_regions().get_upvar_name_and_span_for_region(
-            self.infcx.tcx,
-            self.upvars,
-            upvar_index,
-        );
+        let universals = self.universal_regions();
+        let upvar_index = universals.get_upvar_index_for_region(self.infcx.tcx, fr)?;
+        let (upvar_name, upvar_span) =
+            universals.get_upvar_name_and_span_for_region(self.infcx.tcx, self.upvars, upvar_index);
         let region_name = self.synthesize_region_name();
 
         Some(RegionName {

compiler/rustc_borrowck/src/nll.rs

@@ -97,16 +97,12 @@ pub(crate) fn compute_closure_requirements_modulo_opaques<'tcx>(
     body: &Body<'tcx>,
     location_map: Rc<DenseLocationMap>,
     universal_region_relations: Rc<Frozen<UniversalRegionRelations<'tcx>>>,
-    constraints: &MirTypeckRegionConstraints<'tcx>,
+    constraints: &mut MirTypeckRegionConstraints<'tcx>,
 ) -> Option<ClosureRegionRequirements<'tcx>> {
-    // These clones can more or less be avoided,
-    // since they are probably idempotent.
-    let mut liveness_constraints = constraints.liveness_constraints.clone();
-    let mut outlives_constraints = constraints.outlives_constraints.clone();
     let LoweredConstraints { constraint_sccs, definitions, scc_annotations } =
         compute_sccs_applying_placeholder_outlives_constraints(
-            &mut liveness_constraints,
-            &mut outlives_constraints,
+            &mut constraints.liveness_constraints,
+            &mut constraints.outlives_constraints,
             &universal_region_relations,
             infcx,
         );
@@ -117,9 +113,9 @@ pub(crate) fn compute_closure_requirements_modulo_opaques<'tcx>(
             constraint_sccs,
             &definitions,
             scc_annotations,
-            &outlives_constraints,
+            &constraints.outlives_constraints,
             &constraints.type_tests,
-            &mut liveness_constraints,
+            &mut constraints.liveness_constraints,
             universal_region_relations,
             body,
             None,
@@ -332,8 +328,9 @@ pub(crate) fn emit_nll_mir<'tcx>(
                 universal_region_relations,
                 outlives_constraints,
                 liveness_constraints,
+                scc_values,
             }
-            .dump_mir(scc_values, out)?;
+            .dump_mir(out)?;
             writeln!(out, "|")?;
 
             if let Some(closure_region_requirements) = closure_region_requirements {

compiler/rustc_borrowck/src/region_infer/dump_mir.rs

@@ -28,15 +28,12 @@ pub(crate) struct MirDumper<'a, 'tcx> {
     pub(crate) universal_region_relations: &'a UniversalRegionRelations<'tcx>,
     pub(crate) outlives_constraints: &'a OutlivesConstraintSet<'tcx>,
     pub(crate) liveness_constraints: &'a LivenessValues,
+    pub(crate) scc_values: &'a InferredRegions<'tcx>,
 }
 
 impl<'a, 'tcx> MirDumper<'a, 'tcx> {
     /// Write out our state into the `.mir` files.
-    pub(crate) fn dump_mir(
-        &self,
-        scc_values: &InferredRegions<'tcx>,
-        out: &mut dyn Write,
-    ) -> io::Result<()> {
+    pub(crate) fn dump_mir(&self, out: &mut dyn Write) -> io::Result<()> {
         writeln!(out, "| Free Region Mapping")?;
 
         for region in self.regions() {
@@ -64,8 +61,8 @@ impl<'a, 'tcx> MirDumper<'a, 'tcx> {
                 "| {r:rw$?} | {ui:4?} | {v}",
                 r = region,
                 rw = REGION_WIDTH,
-                ui = scc_values.max_nameable_universe(region),
-                v = scc_values.region_value_str(region),
+                ui = self.scc_values.max_nameable_universe(region),
+                v = self.scc_values.region_value_str(region),
             )?;
         }
 

compiler/rustc_borrowck/src/region_infer/mod.rs

@@ -718,16 +718,9 @@ impl<'a, 'tcx> RegionInferenceContext<'a, 'tcx> {
     /// unsatisfiable constraints. If this is a closure, returns the
     /// region requirements to propagate to our creator, if any.
     #[instrument(
-        skip(
-            infcx,
-            body,
-            polonius_output,
-            location_map,
-            placeholder_indices,
-            constraint_sccs,
-            liveness_constraints
-        ),
-        level = "debug"
+        skip_all,
+        level = "debug",
+        fields(definitions, type_tests, universal_region_relations)
     )]
     pub(super) fn infer_regions(
         infcx: &BorrowckInferCtxt<'tcx>,
@@ -746,19 +739,17 @@ impl<'a, 'tcx> RegionInferenceContext<'a, 'tcx> {
         let num_external_vids =
             universal_region_relations.universal_regions.num_global_and_external_regions();
 
-        let regioncx = {
-            if cfg!(debug_assertions) {
-                sccs_info(infcx, &constraint_sccs);
-            }
+        if cfg!(debug_assertions) {
+            sccs_info(infcx, &constraint_sccs);
+        }
 
-            Self {
-                definitions,
-                liveness_constraints,
-                constraints: outlives_constraints,
-                constraint_sccs,
-                scc_annotations,
-                universal_region_relations,
-            }
+        let regioncx = Self {
+            definitions,
+            liveness_constraints,
+            constraints: outlives_constraints,
+            constraint_sccs,
+            scc_annotations,
+            universal_region_relations,
         };
 
         let mir_def_id = body.source.def_id();

compiler/rustc_borrowck/src/root_cx.rs

@@ -193,7 +193,7 @@ impl<'tcx> BorrowCheckRootCtxt<'tcx> {
             // and write its result into `propagated_borrowck_results`.
             if depends_on_opaques {
                 if def_id != self.root_def_id {
-                    let req = Self::compute_closure_requirements_modulo_opaques(&input);
+                    let req = Self::compute_closure_requirements_modulo_opaques(&mut input);
                     closure_requirements_modulo_opaques.insert(def_id, req);
                 }
                 self.collect_region_constraints_results.insert(def_id, input);
@@ -206,14 +206,14 @@ impl<'tcx> BorrowCheckRootCtxt<'tcx> {
     }
 
     fn compute_closure_requirements_modulo_opaques(
-        input: &CollectRegionConstraintsResult<'tcx>,
+        input: &mut CollectRegionConstraintsResult<'tcx>,
     ) -> Option<ClosureRegionRequirements<'tcx>> {
         compute_closure_requirements_modulo_opaques(
             &input.infcx,
             &input.body_owned,
             Rc::clone(&input.location_map),
             Rc::clone(&input.universal_region_relations),
-            &input.constraints,
+            &mut input.constraints,
         )
     }