Refactor region constraint search into its own module

Region constraint search is now used in multiple places. This
PR moves it into `rustc_borrowck::constraints::graph`, since
it uses the Region graph for searching.

Use blame constraint in outlives static edges

Author: amandasystems

compiler/rustc_borrowck/src/eliminate_placeholders.rs

@@ -153,7 +153,7 @@ impl RegionTracker {
 
         Self {
             // The largest reachable universe from a rvid is its
-            // declared largest reachable one.
+            // declared one.
             min_max_universe_reached: (definition.universe, rvid),
             reachable_placeholders,
             representative: Representative::new(rvid, definition),
@@ -175,17 +175,15 @@ impl RegionTracker {
             || 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.max_nameable_universe();
-
+    /// If this SCC reaches a placeholder it can't name, return it.
+    fn unnameable_placeholder(&self) -> Option<(RegionVid, UniverseIndex)> {
         let PlaceholderReachability::Placeholders { max_universe: (max_u, max_u_rvid), .. } =
             self.reachable_placeholders
         else {
             return None;
         };
 
-        if min_u.can_name(max_u) {
+        if self.max_nameable_universe().can_name(max_u) {
             return None;
         }
 
@@ -216,7 +214,7 @@ impl scc::Annotation for RegionTracker {
     }
 
     fn merge_reached(mut self, other: Self) -> Self {
-        let already_has_placeholder_violation = self.reaches_too_large_universe().is_some();
+        let already_has_unnameable_placeholder = self.unnameable_placeholder().is_some();
         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.
@@ -227,8 +225,8 @@ impl scc::Annotation for RegionTracker {
         // FIXME: a potential optimisation if this is slow is to reimplement
         // this check as a boolean fuse, since it will idempotently turn
         // true once triggered and never go false again.
-        if already_has_placeholder_violation {
-            debug!("SCC already has a placeholder violation; no use looking for more!");
+        if already_has_unnameable_placeholder {
+            debug!("SCC already has an unnameable placeholder; no use looking for more!");
             self
         } else {
             self.reachable_placeholders =
@@ -426,40 +424,48 @@ fn rewrite_placeholder_outlives<'tcx>(
 
         let annotation = &annotations[scc];
 
-        // Figure out if there is a universe violation in this SCC.
-        // This can happen in two cases: either one of our placeholders
-        // had its universe lowered from reaching a region with a lower universe,
-        // (in which case we blame the lower universe's region), or because we reached
-        // a larger universe (in which case we blame the larger universe's region).
-        let Some((max_u_rvid, max_u)) = annotation.reaches_too_large_universe() else {
+        let Some((max_u_rvid, max_u)) = annotation.unnameable_placeholder() else {
             continue;
         };
 
-        let min_u = annotation.max_nameable_universe();
-
         debug!(
-            "Universe {max_u:?} is too large for its SCC, represented by {:?}",
+            "Placeholder universe {max_u:?} is too large for its SCC, represented by {:?}",
             annotation.representative
         );
+
+        // We only add one `r: 'static` constraint per SCC, where `r` is the SCC representative.
+        // That constraint is annotated with some outlives relation `tries: unnameable` where
+        // `unnameable` is unnameable from `tries` and there is a path in the constraint
+        // graph between them.
+        //
+        // We prefer the representative as `tries` in all cases but one: where the problem
+        // is that the SCC has had its universe lowered to accomodate some other region and
+        // no longer can name its representative. In that case, we blame `r: low_u`, where `low_u`
+        // cannot name `r` so that any explanation always starts with the SCC 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 reached something
-            // small-universed. In this case, that's to blame!
+            // The SCC's representative is not nameable from some region
+            // that ends up in the SCC.
             let small_universed_rvid = find_region(
                 outlives_constraints,
                 constraint_graph.get_or_init(|| outlives_constraints.graph(definitions.len())),
                 definitions,
                 max_u_rvid,
-                |r: RegionVid| definitions[r].universe == min_u,
+                |r: RegionVid| definitions[r].universe == annotation.max_nameable_universe(),
                 fr_static,
             );
-            debug!("{small_universed_rvid:?} lowered our universe to {min_u:?}");
+            debug!(
+                "{small_universed_rvid:?} lowered our universe to {:?}",
+                annotation.max_nameable_universe()
+            );
             small_universed_rvid
         } else {
-            // The problem is that we, who have a small universe, reach a large one.
+            // `max_u_rvid` is not nameable by the SCC's representative.
             max_u_rvid
         };
 
+        // FIXME: if we can extract a useful blame span here, future error
+        // reporting and constraint search can be simplified. That does however
+
         outlives_static.insert(scc);
         outlives_constraints.push(OutlivesConstraint {
             sup: annotation.representative.rvid(),