Rewrite handling of placeholder regions into outlives constraints

This commit prepares for Polonius by moving handling of leak check/universe errors out of the inference step by rewriting any universe error into an outlives-static constraint.

This variant is a work in progress.

Note that a few debug assertions no longer hold; a few extra eyes on those changes are appreciated!

Author: amandasystems

compiler/rustc_borrowck/src/constraints/mod.rs

@@ -1,12 +1,16 @@
+use rustc_data_structures::fx::FxHashSet;
 use rustc_data_structures::graph::scc::Sccs;
 use rustc_index::{IndexSlice, IndexVec};
+use rustc_infer::infer::NllRegionVariableOrigin;
 use rustc_middle::mir::ConstraintCategory;
 use rustc_middle::ty::{RegionVid, VarianceDiagInfo};
 use rustc_span::Span;
 use std::fmt;
 use std::ops::Index;
 
+use crate::region_infer::RegionDefinition;
 use crate::type_check::Locations;
+use crate::universal_regions::UniversalRegions;
 
 pub(crate) mod graph;
 
@@ -62,6 +66,68 @@ impl<'tcx> OutlivesConstraintSet<'tcx> {
     ) -> &IndexSlice<OutlivesConstraintIndex, OutlivesConstraint<'tcx>> {
         &self.outlives
     }
+    pub(crate) fn placeholders_to_static(
+        &self,
+        universal_regions: &UniversalRegions<'tcx>,
+        definitions: &IndexVec<RegionVid, RegionDefinition<'tcx>>,
+    ) -> Self {
+        let mut copy = self.clone();
+
+        let universe = |rvid: RegionVid| definitions[rvid].universe;
+
+        let is_placeholder = |rvid: RegionVid| {
+            matches!(definitions[rvid].origin, NllRegionVariableOrigin::Placeholder(_))
+        };
+
+        let outlives_static = |rvid: RegionVid| OutlivesConstraint {
+            sup: rvid,
+            sub: universal_regions.fr_static, // All the following values are made up ex nihil
+            category: ConstraintCategory::BoringNoLocation,
+            locations: Locations::All(rustc_span::DUMMY_SP),
+            span: rustc_span::DUMMY_SP,
+            variance_info: VarianceDiagInfo::None,
+            from_closure: false,
+        };
+
+        let outlived_regions = |longer: RegionVid| {
+            self.outlives().iter().filter_map(move |OutlivesConstraint { sub, sup, .. }| {
+                (*sup == longer).then_some(sub)
+            })
+        };
+
+        let should_be_static = definitions.indices().filter_map(|rvid| {
+            let mut queue: Vec<RegionVid> = outlived_regions(rvid).map(|&r| r).collect();
+            let mut seen: FxHashSet<_> = queue.iter().map(|&r| r).collect();
+            seen.insert(rvid);
+            debug!(?rvid);
+            debug!("rvid definition: {:?}", definitions[rvid]);
+            while let Some(outlived) = queue.pop() {
+                if is_placeholder(outlived) && universe(outlived) > universe(rvid) {
+                    debug!(
+                        "{rvid:?}: {outlived:?} => {rvid:?}: 'static, universe leak ({:?} > {:?})",
+                        universe(outlived),
+                        universe(rvid)
+                    );
+                    return Some(rvid);
+                } else {
+                    for &r in outlived_regions(outlived) {
+                        if seen.contains(&r) {
+                            continue;
+                        }
+                        seen.insert(r);
+                        queue.push(r);
+                    }
+                }
+            }
+            None
+        });
+
+        for rvid in should_be_static {
+            copy.push(outlives_static(rvid));
+        }
+
+        copy
+    }
 }
 
 impl<'tcx> Index<OutlivesConstraintIndex> for OutlivesConstraintSet<'tcx> {

compiler/rustc_borrowck/src/region_infer/mod.rs

@@ -121,6 +121,11 @@ pub struct RegionInferenceContext<'tcx> {
     /// Information about how the universally quantified regions in
     /// scope on this function relate to one another.
     universal_region_relations: Frozen<UniversalRegionRelations<'tcx>>,
+
+    /// Whether we are operating with polonius=next or not. False
+    /// means the regular NLL machinery is in use, true means use the
+    /// new Polonius constraint propagation.
+    polonius_next_enabled: bool,
 }
 
 /// Each time that `apply_member_constraint` is successful, it appends
@@ -322,7 +327,7 @@ impl<'tcx> RegionInferenceContext<'tcx> {
     /// The `outlives_constraints` and `type_tests` are an initial set
     /// of constraints produced by the MIR type check.
     pub(crate) fn new<'cx>(
-        _infcx: &BorrowckInferCtxt<'cx, 'tcx>,
+        infcx: &BorrowckInferCtxt<'cx, 'tcx>,
         var_infos: VarInfos,
         universal_regions: Rc<UniversalRegions<'tcx>>,
         placeholder_indices: Rc<PlaceholderIndices>,
@@ -345,13 +350,21 @@ impl<'tcx> RegionInferenceContext<'tcx> {
             .map(|info| RegionDefinition::new(info.universe, info.origin))
             .collect();
 
-        let constraints = Frozen::freeze(outlives_constraints);
+        let polonius_next_enabled = infcx.tcx.sess.opts.unstable_opts.polonius.is_next_enabled();
+
+        let constraints = if polonius_next_enabled {
+            Frozen::freeze(
+                outlives_constraints.placeholders_to_static(&universal_regions, &definitions),
+            )
+        } else {
+            Frozen::freeze(outlives_constraints)
+        };
         let constraint_graph = Frozen::freeze(constraints.graph(definitions.len()));
         let fr_static = universal_regions.fr_static;
         let constraint_sccs = Rc::new(constraints.compute_sccs(&constraint_graph, fr_static));
 
         if cfg!(debug_assertions) {
-            sccs_info(_infcx, constraint_sccs.clone());
+            sccs_info(infcx, constraint_sccs.clone());
         }
 
         let mut scc_values =
@@ -386,6 +399,7 @@ impl<'tcx> RegionInferenceContext<'tcx> {
             type_tests,
             universal_regions,
             universal_region_relations,
+            polonius_next_enabled,
         };
 
         result.init_free_and_bound_regions();
@@ -535,7 +549,7 @@ impl<'tcx> RegionInferenceContext<'tcx> {
         // This iterator has unstable order but we collect it all into an IndexVec
         for (external_name, variable) in self.universal_regions.named_universal_regions() {
             debug!(
-                "init_universal_regions: region {:?} has external name {:?}",
+                "init_free_and_bound_regions: region {:?} has external name {:?}",
                 variable, external_name
             );
             self.definitions[variable].external_name = Some(external_name);
@@ -561,8 +575,10 @@ impl<'tcx> RegionInferenceContext<'tcx> {
                     // its universe `ui` and its extensions. So we
                     // can't just add it into `scc` unless the
                     // universe of the scc can name this region.
+                    // This case is handled separately when Polonius
+                    // is enabled.
                     let scc_universe = self.scc_universes[scc];
-                    if scc_universe.can_name(placeholder.universe) {
+                    if self.polonius_next_enabled || scc_universe.can_name(placeholder.universe) {
                         self.scc_values.add_element(scc, placeholder);
                     } else {
                         debug!(
@@ -760,12 +776,11 @@ impl<'tcx> RegionInferenceContext<'tcx> {
         // Walk each SCC `B` such that `A: B`...
         for &scc_b in constraint_sccs.successors(scc_a) {
             debug!(?scc_b);
-
             // ...and add elements from `B` into `A`. One complication
             // arises because of universes: If `B` contains something
             // that `A` cannot name, then `A` can only contain `B` if
             // it outlives static.
-            if self.universe_compatible(scc_b, scc_a) {
+            if self.polonius_next_enabled || self.universe_compatible(scc_b, scc_a) {
                 // `A` can name everything that is in `B`, so just
                 // merge the bits.
                 self.scc_values.add_region(scc_a, scc_b);
@@ -828,7 +843,8 @@ impl<'tcx> RegionInferenceContext<'tcx> {
             return;
         }
         debug_assert!(
-            self.scc_values.placeholders_contained_in(scc).next().is_none(),
+            self.polonius_next_enabled
+                || self.scc_values.placeholders_contained_in(scc).next().is_none(),
             "scc {:?} in a member constraint has placeholder value: {:?}",
             scc,
             self.scc_values.region_value_str(scc),
@@ -1563,7 +1579,10 @@ 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_universes[longer_fr_scc] == ty::UniverseIndex::ROOT);
-        debug_assert!(self.scc_values.placeholders_contained_in(longer_fr_scc).next().is_none());
+        debug_assert!(
+            self.polonius_next_enabled
+                || self.scc_values.placeholders_contained_in(longer_fr_scc).next().is_none()
+        );
 
         // Only check all of the relations for the main representative of each
         // SCC, otherwise just check that we outlive said representative. This