stop calling DenseLocationMap "elements"

"Elements" are `RegionElement`s. The dense location mapping was removed
from the element containers a while ago but didn't rename its use-sites.
Most of the old naming only used the mapping, and are better named
`location_map`.

Author: lqd

compiler/rustc_borrowck/src/nll.rs

@@ -94,7 +94,7 @@ pub(crate) fn compute_regions<'a, 'tcx>(
     let mut all_facts =
         (polonius_input || AllFacts::enabled(infcx.tcx)).then_some(AllFacts::default());
 
-    let elements = Rc::new(DenseLocationMap::new(body));
+    let location_map = Rc::new(DenseLocationMap::new(body));
 
     // Run the MIR type-checker.
     let MirTypeckResults {
@@ -112,7 +112,7 @@ pub(crate) fn compute_regions<'a, 'tcx>(
         &mut all_facts,
         flow_inits,
         move_data,
-        Rc::clone(&elements),
+        Rc::clone(&location_map),
     );
 
     // Create the region inference context, taking ownership of the
@@ -137,7 +137,7 @@ pub(crate) fn compute_regions<'a, 'tcx>(
         var_infos,
         constraints,
         universal_region_relations,
-        elements,
+        location_map,
     );
 
     // If requested for `-Zpolonius=next`, convert NLL constraints to localized outlives

compiler/rustc_borrowck/src/region_infer/mod.rs

@@ -396,7 +396,7 @@ impl<'tcx> RegionInferenceContext<'tcx> {
         var_infos: VarInfos,
         constraints: MirTypeckRegionConstraints<'tcx>,
         universal_region_relations: Frozen<UniversalRegionRelations<'tcx>>,
-        elements: Rc<DenseLocationMap>,
+        location_map: Rc<DenseLocationMap>,
     ) -> Self {
         let universal_regions = &universal_region_relations.universal_regions;
         let MirTypeckRegionConstraints {
@@ -440,7 +440,7 @@ impl<'tcx> RegionInferenceContext<'tcx> {
         }
 
         let mut scc_values =
-            RegionValues::new(elements, universal_regions.len(), placeholder_indices);
+            RegionValues::new(location_map, universal_regions.len(), placeholder_indices);
 
         for region in liveness_constraints.regions() {
             let scc = constraint_sccs.scc(region);

compiler/rustc_borrowck/src/region_infer/values.rs

@@ -38,7 +38,7 @@ pub(crate) enum RegionElement {
 /// an interval matrix storing liveness ranges for each region-vid.
 pub(crate) struct LivenessValues {
     /// The map from locations to points.
-    elements: Rc<DenseLocationMap>,
+    location_map: Rc<DenseLocationMap>,
 
     /// Which regions are live. This is exclusive with the fine-grained tracking in `points`, and
     /// currently only used for validating promoteds (which don't care about more precise tracking).
@@ -77,11 +77,11 @@ impl LiveLoans {
 
 impl LivenessValues {
     /// Create an empty map of regions to locations where they're live.
-    pub(crate) fn with_specific_points(elements: Rc<DenseLocationMap>) -> Self {
+    pub(crate) fn with_specific_points(location_map: Rc<DenseLocationMap>) -> Self {
         LivenessValues {
             live_regions: None,
-            points: Some(SparseIntervalMatrix::new(elements.num_points())),
-            elements,
+            points: Some(SparseIntervalMatrix::new(location_map.num_points())),
+            location_map,
             loans: None,
         }
     }
@@ -90,11 +90,11 @@ impl LivenessValues {
     ///
     /// Unlike `with_specific_points`, does not track exact locations where something is live, only
     /// which regions are live.
-    pub(crate) fn without_specific_points(elements: Rc<DenseLocationMap>) -> Self {
+    pub(crate) fn without_specific_points(location_map: Rc<DenseLocationMap>) -> Self {
         LivenessValues {
             live_regions: Some(Default::default()),
             points: None,
-            elements,
+            location_map,
             loans: None,
         }
     }
@@ -122,11 +122,11 @@ impl LivenessValues {
 
     /// Records `region` as being live at the given `location`.
     pub(crate) fn add_location(&mut self, region: RegionVid, location: Location) {
-        let point = self.elements.point_from_location(location);
+        let point = self.location_map.point_from_location(location);
         debug!("LivenessValues::add_location(region={:?}, location={:?})", region, location);
         if let Some(points) = &mut self.points {
             points.insert(region, point);
-        } else if self.elements.point_in_range(point) {
+        } else if self.location_map.point_in_range(point) {
             self.live_regions.as_mut().unwrap().insert(region);
         }
 
@@ -143,7 +143,7 @@ impl LivenessValues {
         debug!("LivenessValues::add_points(region={:?}, points={:?})", region, points);
         if let Some(this) = &mut self.points {
             this.union_row(region, points);
-        } else if points.iter().any(|point| self.elements.point_in_range(point)) {
+        } else if points.iter().any(|point| self.location_map.point_in_range(point)) {
             self.live_regions.as_mut().unwrap().insert(region);
         }
 
@@ -170,7 +170,7 @@ impl LivenessValues {
 
     /// Returns whether `region` is marked live at the given `location`.
     pub(crate) fn is_live_at(&self, region: RegionVid, location: Location) -> bool {
-        let point = self.elements.point_from_location(location);
+        let point = self.location_map.point_from_location(location);
         if let Some(points) = &self.points {
             points.row(region).is_some_and(|r| r.contains(point))
         } else {
@@ -191,25 +191,26 @@ impl LivenessValues {
             .row(region)
             .into_iter()
             .flat_map(|set| set.iter())
-            .take_while(|&p| self.elements.point_in_range(p))
+            .take_while(|&p| self.location_map.point_in_range(p))
     }
 
     /// For debugging purposes, returns a pretty-printed string of the points where the `region` is
     /// live.
     pub(crate) fn pretty_print_live_points(&self, region: RegionVid) -> String {
         pretty_print_region_elements(
-            self.live_points(region).map(|p| RegionElement::Location(self.elements.to_location(p))),
+            self.live_points(region)
+                .map(|p| RegionElement::Location(self.location_map.to_location(p))),
         )
     }
 
     #[inline]
     pub(crate) fn point_from_location(&self, location: Location) -> PointIndex {
-        self.elements.point_from_location(location)
+        self.location_map.point_from_location(location)
     }
 
     #[inline]
     pub(crate) fn location_from_point(&self, point: PointIndex) -> Location {
-        self.elements.to_location(point)
+        self.location_map.to_location(point)
     }
 
     /// When using `-Zpolonius=next`, returns whether the `loan_idx` is live at the given `point`.
@@ -272,7 +273,7 @@ impl PlaceholderIndices {
 /// because (since it is returned) it must live for at least `'a`. But
 /// it would also contain various points from within the function.
 pub(crate) struct RegionValues<N: Idx> {
-    elements: Rc<DenseLocationMap>,
+    location_map: Rc<DenseLocationMap>,
     placeholder_indices: PlaceholderIndices,
     points: SparseIntervalMatrix<N, PointIndex>,
     free_regions: SparseBitMatrix<N, RegionVid>,
@@ -287,14 +288,14 @@ impl<N: Idx> RegionValues<N> {
     /// Each of the regions in num_region_variables will be initialized with an
     /// empty set of points and no causal information.
     pub(crate) fn new(
-        elements: Rc<DenseLocationMap>,
+        location_map: Rc<DenseLocationMap>,
         num_universal_regions: usize,
         placeholder_indices: PlaceholderIndices,
     ) -> Self {
-        let num_points = elements.num_points();
+        let num_points = location_map.num_points();
         let num_placeholders = placeholder_indices.len();
         Self {
-            elements,
+            location_map,
             points: SparseIntervalMatrix::new(num_points),
             placeholder_indices,
             free_regions: SparseBitMatrix::new(num_universal_regions),
@@ -336,7 +337,7 @@ impl<N: Idx> RegionValues<N> {
         end: usize,
     ) -> Option<usize> {
         let row = self.points.row(r)?;
-        let block = self.elements.entry_point(block);
+        let block = self.location_map.entry_point(block);
         let start = block.plus(start);
         let end = block.plus(end);
         let first_unset = row.first_unset_in(start..=end)?;
@@ -375,8 +376,8 @@ impl<N: Idx> RegionValues<N> {
     pub(crate) fn locations_outlived_by<'a>(&'a self, r: N) -> impl Iterator<Item = Location> + 'a {
         self.points.row(r).into_iter().flat_map(move |set| {
             set.iter()
-                .take_while(move |&p| self.elements.point_in_range(p))
-                .map(move |p| self.elements.to_location(p))
+                .take_while(move |&p| self.location_map.point_in_range(p))
+                .map(move |p| self.location_map.to_location(p))
         })
     }
 
@@ -430,12 +431,12 @@ pub(crate) trait ToElementIndex: Debug + Copy {
 
 impl ToElementIndex for Location {
     fn add_to_row<N: Idx>(self, values: &mut RegionValues<N>, row: N) -> bool {
-        let index = values.elements.point_from_location(self);
+        let index = values.location_map.point_from_location(self);
         values.points.insert(row, index)
     }
 
     fn contained_in_row<N: Idx>(self, values: &RegionValues<N>, row: N) -> bool {
-        let index = values.elements.point_from_location(self);
+        let index = values.location_map.point_from_location(self);
         values.points.contains(row, index)
     }
 }
@@ -464,14 +465,14 @@ impl ToElementIndex for ty::PlaceholderRegion {
 
 /// For debugging purposes, returns a pretty-printed string of the given points.
 pub(crate) fn pretty_print_points(
-    elements: &DenseLocationMap,
+    location_map: &DenseLocationMap,
     points: impl IntoIterator<Item = PointIndex>,
 ) -> String {
     pretty_print_region_elements(
         points
             .into_iter()
-            .take_while(|&p| elements.point_in_range(p))
-            .map(|p| elements.to_location(p))
+            .take_while(|&p| location_map.point_in_range(p))
+            .map(|p| location_map.to_location(p))
             .map(RegionElement::Location),
     )
 }

compiler/rustc_borrowck/src/type_check/liveness/local_use_map.rs

@@ -82,7 +82,7 @@ impl<'a> Iterator for AppearancesIter<'a> {
 impl LocalUseMap {
     pub(crate) fn build(
         live_locals: &[Local],
-        elements: &DenseLocationMap,
+        location_map: &DenseLocationMap,
         body: &Body<'_>,
     ) -> Self {
         let nones = IndexVec::from_elem(None, &body.local_decls);
@@ -101,7 +101,7 @@ impl LocalUseMap {
             IndexVec::from_elem(false, &body.local_decls);
         live_locals.iter().for_each(|&local| locals_with_use_data[local] = true);
 
-        LocalUseMapBuild { local_use_map: &mut local_use_map, elements, locals_with_use_data }
+        LocalUseMapBuild { local_use_map: &mut local_use_map, location_map, locals_with_use_data }
             .visit_body(body);
 
         local_use_map
@@ -125,7 +125,7 @@ impl LocalUseMap {
 
 struct LocalUseMapBuild<'me> {
     local_use_map: &'me mut LocalUseMap,
-    elements: &'me DenseLocationMap,
+    location_map: &'me DenseLocationMap,
 
     // Vector used in `visit_local` to signal which `Local`s do we need
     // def/use/drop information on, constructed from `live_locals` (that
@@ -147,7 +147,7 @@ impl Visitor<'_> for LocalUseMapBuild<'_> {
                 DefUse::Use => &mut self.local_use_map.first_use_at[local],
                 DefUse::Drop => &mut self.local_use_map.first_drop_at[local],
             };
-            let point_index = self.elements.point_from_location(location);
+            let point_index = self.location_map.point_from_location(location);
             let appearance_index = self
                 .local_use_map
                 .appearances

compiler/rustc_borrowck/src/type_check/liveness/mod.rs

@@ -32,7 +32,7 @@ mod trace;
 pub(super) fn generate<'a, 'tcx>(
     typeck: &mut TypeChecker<'_, 'tcx>,
     body: &Body<'tcx>,
-    elements: &DenseLocationMap,
+    location_map: &DenseLocationMap,
     flow_inits: ResultsCursor<'a, 'tcx, MaybeInitializedPlaces<'a, 'tcx>>,
     move_data: &MoveData<'tcx>,
 ) {
@@ -49,7 +49,7 @@ pub(super) fn generate<'a, 'tcx>(
     trace::trace(
         typeck,
         body,
-        elements,
+        location_map,
         flow_inits,
         move_data,
         relevant_live_locals,