Better documentation for min max universe

Author: amandasystems

compiler/rustc_borrowck/src/eliminate_placeholders.rs

@@ -125,8 +125,11 @@ impl PlaceholderReachability {
 /// the values of its elements. This annotates a single SCC.
 #[derive(Copy, Debug, Clone)]
 pub(crate) struct RegionTracker {
-    /// The smallest universe reachable (and its region)
-    min_universe: (UniverseIndex, RegionVid),
+    /// The smallest maximum universe reachable (and its region).
+    /// This determines the largest nameable universe from this
+    /// SCC. Earlier regions in the constraint graph are
+    /// preferred.
+    min_max_universe_reached: (UniverseIndex, RegionVid),
 
     /// Metadata about reachable placeholders
     reachable_placeholders: PlaceholderReachability,
@@ -149,27 +152,32 @@ impl RegionTracker {
             };
 
         Self {
-            min_universe: (definition.universe, rvid),
+            // The largest reachable universe from a rvid is its
+            // declared largest reachable one.
+            min_max_universe_reached: (definition.universe, rvid),
             reachable_placeholders,
             representative: Representative::new(rvid, definition),
         }
     }
 
-    /// The smallest-indexed universe reachable from and/or in this SCC.
-    pub(crate) fn min_universe(self) -> UniverseIndex {
-        self.min_universe.0
+    /// The largest universe that can be named from this SCC is the
+    /// smallest largest nameable universe of anything it reaches in
+    ///  the region constraint graph, or equivalently in logic terms:
+    /// `max_u(scc) = min(max_u(r) for r in scc: r )`.
+    pub(crate) fn max_nameable_universe(self) -> UniverseIndex {
+        self.min_max_universe_reached.0
     }
 
     /// Determine if the tracked universes of the two SCCs
     /// are compatible.
     pub(crate) fn universe_compatible_with(&self, other: Self) -> bool {
-        self.min_universe().can_name(other.min_universe())
-            || other.reachable_placeholders.can_be_named_by(self.min_universe())
+        self.max_nameable_universe().can_name(other.max_nameable_universe())
+            || other.reachable_placeholders.can_be_named_by(self.max_nameable_universe())
     }
 
     /// If this SCC reaches an universe that's too large, return it.
     fn reaches_too_large_universe(&self) -> Option<(RegionVid, UniverseIndex)> {
-        let min_u = self.min_universe();
+        let min_u = self.max_nameable_universe();
 
         let PlaceholderReachability::Placeholders { max_universe: (max_u, max_u_rvid), .. } =
             self.reachable_placeholders
@@ -185,28 +193,31 @@ impl RegionTracker {
     }
 }
 
+/// Pick the smallest universe index out of two, preferring
+/// the first argument if they are equal.
+#[inline(always)]
+fn pick_min_max_universe(a: RegionTracker, b: RegionTracker) -> (UniverseIndex, RegionVid) {
+    std::cmp::min_by_key(
+        a.min_max_universe_reached,
+        b.min_max_universe_reached,
+        |x: &(UniverseIndex, RegionVid)| x.0,
+    )
+}
+
 impl scc::Annotation for RegionTracker {
     fn merge_scc(self, other: Self) -> Self {
         trace!("{:?} << {:?}", self.representative, other.representative);
 
         Self {
             reachable_placeholders: self.reachable_placeholders.merge(other.reachable_placeholders),
-            min_universe: std::cmp::min_by_key(
-                self.min_universe,
-                other.min_universe,
-                |x: &(UniverseIndex, RegionVid)| x.0,
-            ),
+            min_max_universe_reached: pick_min_max_universe(self, other),
             representative: self.representative.merge_scc(other.representative),
         }
     }
 
     fn merge_reached(mut self, other: Self) -> Self {
         let already_has_placeholder_violation = self.reaches_too_large_universe().is_some();
-        self.min_universe = std::cmp::min_by_key(
-            self.min_universe,
-            other.min_universe,
-            |x: &(UniverseIndex, RegionVid)| x.0,
-        );
+        self.min_max_universe_reached = pick_min_max_universe(self, other);
         // This detail is subtle. We stop early here, because there may be multiple
         // illegally reached regions, but they are not equally good as blame candidates.
         // In general, the ones with the smallest indices of their RegionVids will
@@ -421,15 +432,15 @@ fn rewrite_outlives<'tcx>(
             continue;
         };
 
-        let min_u = annotation.min_universe();
+        let min_u = annotation.max_nameable_universe();
 
         debug!(
             "Universe {max_u:?} is too large for its SCC, represented by {:?}",
             annotation.representative
         );
         let blame_to = if annotation.representative.rvid() == max_u_rvid {
             // We originally had a large enough universe to fit all our reachable
-            // placeholders, but had it lowered because we also absorbed something
+            // placeholders, but had it lowered because we also reached something
             // small-universed. In this case, that's to blame!
             let small_universed_rvid = find_region(
                 outlives_constraints,

compiler/rustc_borrowck/src/region_infer/dump_mir.rs

@@ -46,7 +46,7 @@ impl<'tcx> RegionInferenceContext<'tcx> {
                 "| {r:rw$?} | {ui:4?} | {v}",
                 r = region,
                 rw = REGION_WIDTH,
-                ui = self.region_universe(region),
+                ui = self.max_nameable_universe(self.constraint_sccs.scc(region)),
                 v = self.region_value_str(region),
             )?;
         }

compiler/rustc_borrowck/src/region_infer/mod.rs

@@ -551,11 +551,6 @@ impl<'tcx> RegionInferenceContext<'tcx> {
         self.scc_values.placeholders_contained_in(scc)
     }
 
-    /// Returns access to the value of `r` for debugging purposes.
-    pub(crate) fn region_universe(&self, r: RegionVid) -> ty::UniverseIndex {
-        self.scc_universe(self.constraint_sccs.scc(r))
-    }
-
     /// Once region solving has completed, this function will return the member constraints that
     /// were applied to the value of a given SCC `scc`. See `AppliedMemberConstraint`.
     pub(crate) fn applied_member_constraints(
@@ -722,7 +717,7 @@ impl<'tcx> RegionInferenceContext<'tcx> {
 
         // If the member region lives in a higher universe, we currently choose
         // the most conservative option by leaving it unchanged.
-        if !self.scc_universe(scc).is_root() {
+        if !self.max_nameable_universe(scc).is_root() {
             return;
         }
 
@@ -902,7 +897,7 @@ impl<'tcx> RegionInferenceContext<'tcx> {
             "lower_bound = {:?} r_scc={:?} universe={:?}",
             lower_bound,
             r_scc,
-            self.scc_universe(r_scc)
+            self.max_nameable_universe(r_scc)
         );
         // If the type test requires that `T: 'a` where `'a` is a
         // placeholder from another universe, that effectively requires
@@ -1380,10 +1375,10 @@ impl<'tcx> RegionInferenceContext<'tcx> {
         }
     }
 
-    /// The minimum universe of any variable reachable from this
+    /// The minimum maximum universe of any variable reachable from this
     /// SCC, inside or outside of it.
-    fn scc_universe(&self, scc: ConstraintSccIndex) -> UniverseIndex {
-        self.scc_annotations[scc].min_universe()
+    fn max_nameable_universe(&self, scc: ConstraintSccIndex) -> UniverseIndex {
+        self.scc_annotations[scc].max_nameable_universe()
     }
 
     /// Checks the final value for the free region `fr` to see if it
@@ -1405,7 +1400,7 @@ impl<'tcx> RegionInferenceContext<'tcx> {
 
         // Because this free region must be in the ROOT universe, we
         // know it cannot contain any bound universes.
-        assert!(self.scc_universe(longer_fr_scc).is_root());
+        assert!(self.max_nameable_universe(longer_fr_scc).is_root());
 
         // Only check all of the relations for the main representative of each
         // SCC, otherwise just check that we outlive said representative. This
@@ -1754,7 +1749,7 @@ impl<'tcx> RegionInferenceContext<'tcx> {
     #[instrument(skip(self), level = "trace", ret)]
     pub(crate) fn find_sub_region_live_at(&self, fr1: RegionVid, location: Location) -> RegionVid {
         trace!(scc = ?self.constraint_sccs.scc(fr1));
-        trace!(universe = ?self.region_universe(fr1));
+        trace!(universe = ?self.max_nameable_universe(self.constraint_sccs.scc(fr1)));
         self.constraint_path_to(fr1, |r| {
             // Look for some `r` such that `fr1: r` and `r` is live at `location`
             trace!(?r, liveness_constraints=?self.liveness_constraints.pretty_print_live_points(r));

compiler/rustc_borrowck/src/region_infer/opaque_types.rs

@@ -191,7 +191,7 @@ impl<'tcx> RegionInferenceContext<'tcx> {
                 let scc = self.constraint_sccs.scc(vid);
 
                 // Special handling of higher-ranked regions.
-                if !self.scc_universe(scc).is_root() {
+                if !self.max_nameable_universe(scc).is_root() {
                     match self.scc_values.placeholders_contained_in(scc).enumerate().last() {
                         // If the region contains a single placeholder then they're equal.
                         Some((0, placeholder)) => {