Move the placeholder-to-region vid mapping out of MirTypckRegionConstraints

Author: amandasystems

compiler/rustc_borrowck/src/handle_placeholders.rs

@@ -344,7 +344,6 @@ pub(crate) fn compute_sccs_applying_placeholder_outlives_constraints<'tcx>(
         mut member_constraints,
         universe_causes,
         type_tests,
-        ..
     } = constraints;
 
     if let Some(guar) = universal_regions.tainted_by_errors() {

compiler/rustc_borrowck/src/type_check/constraint_conversion.rs

@@ -15,7 +15,7 @@ use tracing::{debug, instrument};
 
 use crate::constraints::OutlivesConstraint;
 use crate::region_infer::TypeTest;
-use crate::type_check::{Locations, MirTypeckRegionConstraints};
+use crate::type_check::{Locations, MirTypeckRegionConstraints, PlaceholderToRegion};
 use crate::universal_regions::UniversalRegions;
 use crate::{ClosureOutlivesSubject, ClosureRegionRequirements, ConstraintCategory};
 
@@ -40,6 +40,7 @@ pub(crate) struct ConstraintConversion<'a, 'tcx> {
     category: ConstraintCategory<'tcx>,
     from_closure: bool,
     constraints: &'a mut MirTypeckRegionConstraints<'tcx>,
+    placeholder_to_region: &'a mut PlaceholderToRegion<'tcx>,
 }
 
 impl<'a, 'tcx> ConstraintConversion<'a, 'tcx> {
@@ -53,6 +54,7 @@ impl<'a, 'tcx> ConstraintConversion<'a, 'tcx> {
         span: Span,
         category: ConstraintCategory<'tcx>,
         constraints: &'a mut MirTypeckRegionConstraints<'tcx>,
+        placeholder_to_region: &'a mut PlaceholderToRegion<'tcx>,
     ) -> Self {
         Self {
             infcx,
@@ -65,6 +67,7 @@ impl<'a, 'tcx> ConstraintConversion<'a, 'tcx> {
             category,
             constraints,
             from_closure: false,
+            placeholder_to_region,
         }
     }
 
@@ -206,7 +209,7 @@ impl<'a, 'tcx> ConstraintConversion<'a, 'tcx> {
         if value.has_placeholders() {
             fold_regions(self.infcx.tcx, value, |r, _| match r.kind() {
                 ty::RePlaceholder(placeholder) => {
-                    self.constraints.placeholder_region(self.infcx, placeholder)
+                    self.placeholder_to_region.placeholder_region(self.infcx, placeholder)
                 }
                 _ => r,
             })
@@ -227,7 +230,7 @@ impl<'a, 'tcx> ConstraintConversion<'a, 'tcx> {
 
     fn to_region_vid(&mut self, r: ty::Region<'tcx>) -> ty::RegionVid {
         if let ty::RePlaceholder(placeholder) = r.kind() {
-            self.constraints.placeholder_region(self.infcx, placeholder).as_var()
+            self.placeholder_to_region.placeholder_region(self.infcx, placeholder).as_var()
         } else {
             self.universal_regions.to_region_vid(r)
         }

compiler/rustc_borrowck/src/type_check/free_region_relations.rs

@@ -14,7 +14,9 @@ use rustc_trait_selection::traits::query::type_op::{self, TypeOp};
 use tracing::{debug, instrument};
 use type_op::TypeOpOutput;
 
-use crate::type_check::{Locations, MirTypeckRegionConstraints, constraint_conversion};
+use crate::type_check::{
+    Locations, MirTypeckRegionConstraints, PlaceholderToRegion, constraint_conversion,
+};
 use crate::universal_regions::UniversalRegions;
 
 #[derive(Debug)]
@@ -51,6 +53,7 @@ pub(crate) fn create<'tcx>(
     param_env: ty::ParamEnv<'tcx>,
     universal_regions: UniversalRegions<'tcx>,
     constraints: &mut MirTypeckRegionConstraints<'tcx>,
+    placeholder_to_region: &mut PlaceholderToRegion<'tcx>,
 ) -> CreateResult<'tcx> {
     UniversalRegionRelationsBuilder {
         infcx,
@@ -60,6 +63,7 @@ pub(crate) fn create<'tcx>(
         region_bound_pairs: Default::default(),
         outlives: Default::default(),
         inverse_outlives: Default::default(),
+        placeholder_to_region,
     }
     .create()
 }
@@ -181,6 +185,7 @@ struct UniversalRegionRelationsBuilder<'a, 'tcx> {
     param_env: ty::ParamEnv<'tcx>,
     universal_regions: UniversalRegions<'tcx>,
     constraints: &'a mut MirTypeckRegionConstraints<'tcx>,
+    placeholder_to_region: &'a mut PlaceholderToRegion<'tcx>,
 
     // outputs:
     outlives: TransitiveRelationBuilder<RegionVid>,
@@ -324,6 +329,7 @@ impl<'tcx> UniversalRegionRelationsBuilder<'_, 'tcx> {
                 span,
                 ConstraintCategory::Internal,
                 self.constraints,
+                self.placeholder_to_region,
             )
             .convert_all(c);
         }

compiler/rustc_borrowck/src/type_check/mod.rs

@@ -110,20 +110,31 @@ pub(crate) fn type_check<'tcx>(
     location_map: Rc<DenseLocationMap>,
 ) -> MirTypeckResults<'tcx> {
     let mut constraints = MirTypeckRegionConstraints {
-        placeholder_to_region: FxHashMap::default(),
         liveness_constraints: LivenessValues::with_specific_points(Rc::clone(&location_map)),
         outlives_constraints: OutlivesConstraintSet::default(),
         member_constraints: MemberConstraintSet::default(),
         type_tests: Vec::default(),
         universe_causes: FxIndexMap::default(),
     };
 
+    // FIXME: I strongly suspect this follows the case of being mutated for a while
+    // and then settling, but I don't know enough about the type inference parts to know
+    // when this happens and if this can be exploited to simplify some of the downstream
+    // code. -- @amandasystems.
+    let mut placeholder_to_region = Default::default();
+
     let CreateResult {
         universal_region_relations,
         region_bound_pairs,
         normalized_inputs_and_output,
         known_type_outlives_obligations,
-    } = free_region_relations::create(infcx, infcx.param_env, universal_regions, &mut constraints);
+    } = free_region_relations::create(
+        infcx,
+        infcx.param_env,
+        universal_regions,
+        &mut constraints,
+        &mut placeholder_to_region,
+    );
 
     let pre_obligations = infcx.take_registered_region_obligations();
     assert!(
@@ -155,6 +166,7 @@ pub(crate) fn type_check<'tcx>(
         borrow_set,
         constraints: &mut constraints,
         polonius_liveness,
+        placeholder_to_region,
     };
 
     typeck.check_user_type_annotations();
@@ -221,6 +233,7 @@ struct TypeChecker<'a, 'tcx> {
     constraints: &'a mut MirTypeckRegionConstraints<'tcx>,
     /// When using `-Zpolonius=next`, the liveness helper data used to create polonius constraints.
     polonius_liveness: Option<PoloniusLivenessContext>,
+    placeholder_to_region: PlaceholderToRegion<'tcx>,
 }
 
 /// Holder struct for passing results from MIR typeck to the rest of the non-lexical regions
@@ -232,14 +245,30 @@ pub(crate) struct MirTypeckResults<'tcx> {
     pub(crate) polonius_context: Option<PoloniusContext>,
 }
 
+/// For each placeholder we create a corresponding representative region vid.
+/// This map tracks those. This way, when we convert the same `ty::RePlaceholder(p)`
+/// twice, we can map to the same underlying `RegionVid`.
+#[derive(Default)]
+pub(crate) struct PlaceholderToRegion<'tcx>(FxHashMap<ty::PlaceholderRegion, ty::Region<'tcx>>);
+
+impl<'tcx> PlaceholderToRegion<'tcx> {
+    /// Creates a `Region` for a given `PlaceholderRegion`, or returns the
+    /// region that corresponds to a previously created one.
+    fn placeholder_region(
+        &mut self,
+        infcx: &InferCtxt<'tcx>,
+        placeholder: ty::PlaceholderRegion,
+    ) -> ty::Region<'tcx> {
+        *self.0.entry(placeholder).or_insert_with(|| {
+            let origin = NllRegionVariableOrigin::Placeholder(placeholder);
+            infcx.next_nll_region_var_in_universe(origin, placeholder.universe)
+        })
+    }
+}
+
 /// A collection of region constraints that must be satisfied for the
 /// program to be considered well-typed.
 pub(crate) struct MirTypeckRegionConstraints<'tcx> {
-    /// For each placeholder we create a corresponding representative region vid.
-    /// This map tracks those. This way, when we convert the same `ty::RePlaceholder(p)`
-    /// twice, we can map to the same underlying `RegionVid`.
-    placeholder_to_region: FxHashMap<ty::PlaceholderRegion, ty::Region<'tcx>>,
-
     /// In general, the type-checker is not responsible for enforcing
     /// liveness constraints; this job falls to the region inferencer,
     /// which performs a liveness analysis. However, in some limited
@@ -258,21 +287,6 @@ pub(crate) struct MirTypeckRegionConstraints<'tcx> {
     pub(crate) type_tests: Vec<TypeTest<'tcx>>,
 }
 
-impl<'tcx> MirTypeckRegionConstraints<'tcx> {
-    /// Creates a `Region` for a given `PlaceholderRegion`, or returns the
-    /// region that corresponds to a previously created one.
-    fn placeholder_region(
-        &mut self,
-        infcx: &InferCtxt<'tcx>,
-        placeholder: ty::PlaceholderRegion,
-    ) -> ty::Region<'tcx> {
-        *self.placeholder_to_region.entry(placeholder).or_insert_with(|| {
-            let origin = NllRegionVariableOrigin::Placeholder(placeholder);
-            infcx.next_nll_region_var_in_universe(origin, placeholder.universe)
-        })
-    }
-}
-
 /// The `Locations` type summarizes *where* region constraints are
 /// required to hold. Normally, this is at a particular point which
 /// created the obligation, but for constraints that the user gave, we
@@ -350,7 +364,7 @@ impl<'a, 'tcx> TypeChecker<'a, 'tcx> {
 
     fn to_region_vid(&mut self, r: ty::Region<'tcx>) -> RegionVid {
         if let ty::RePlaceholder(placeholder) = r.kind() {
-            self.constraints.placeholder_region(self.infcx, placeholder).as_var()
+            self.placeholder_to_region.placeholder_region(self.infcx, placeholder).as_var()
         } else {
             self.universal_regions.to_region_vid(r)
         }
@@ -398,6 +412,7 @@ impl<'a, 'tcx> TypeChecker<'a, 'tcx> {
             locations.span(self.body),
             category,
             self.constraints,
+            &mut self.placeholder_to_region,
         )
         .convert_all(data);
     }
@@ -2487,6 +2502,7 @@ impl<'a, 'tcx> TypeChecker<'a, 'tcx> {
                 self.body.span,             // irrelevant; will be overridden.
                 ConstraintCategory::Boring, // same as above.
                 self.constraints,
+                &mut self.placeholder_to_region,
             )
             .apply_closure_requirements(closure_requirements, def_id, args);
         }

compiler/rustc_borrowck/src/type_check/relate_tys.rs

@@ -258,8 +258,10 @@ impl<'a, 'b, 'tcx> NllTypeRelating<'a, 'b, 'tcx> {
 
     #[instrument(skip(self), level = "debug")]
     fn next_placeholder_region(&mut self, placeholder: ty::PlaceholderRegion) -> ty::Region<'tcx> {
-        let reg =
-            self.type_checker.constraints.placeholder_region(self.type_checker.infcx, placeholder);
+        let reg = self
+            .type_checker
+            .placeholder_to_region
+            .placeholder_region(self.type_checker.infcx, placeholder);
 
         let reg_info = match placeholder.bound.kind {
             ty::BoundRegionKind::Anon => sym::anon,