Remove feature gate and fix performance nit

Author: amandasystems

compiler/rustc_borrowck/src/constraints/mod.rs

@@ -67,12 +67,10 @@ impl<'tcx> OutlivesConstraintSet<'tcx> {
         &self.outlives
     }
     pub(crate) fn placeholders_to_static(
-        &self,
+        &mut 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| {
@@ -95,7 +93,8 @@ impl<'tcx> OutlivesConstraintSet<'tcx> {
             })
         };
 
-        let should_be_static = definitions.indices().filter_map(|rvid| {
+        // Start a search to find reachable regions from here that have incompatible universes
+        let should_be_static:Vec<_> = 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);
@@ -120,13 +119,11 @@ impl<'tcx> OutlivesConstraintSet<'tcx> {
                 }
             }
             None
-        });
+        }).collect();
 
         for rvid in should_be_static {
-            copy.push(outlives_static(rvid));
+            self.push(outlives_static(rvid));
         }
-
-        copy
     }
 }
 

compiler/rustc_borrowck/src/region_infer/mod.rs

@@ -71,7 +71,7 @@ pub struct RegionInferenceContext<'tcx> {
     /// The SCC computed from `constraints` and the constraint
     /// graph. We have an edge from SCC A to SCC B if `A: B`. Used to
     /// compute the values of each region.
-    constraint_sccs: Rc<Sccs<RegionVid, ConstraintSccIndex>>,
+    constraint_sccs: Sccs<RegionVid, ConstraintSccIndex>,
 
     /// Reverse of the SCC constraint graph --  i.e., an edge `A -> B` exists if
     /// `B: A`. This is used to compute the universal regions that are required
@@ -121,11 +121,6 @@ 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
@@ -256,7 +251,7 @@ pub enum ExtraConstraintInfo {
 #[instrument(skip(infcx, sccs), level = "debug")]
 fn sccs_info<'cx, 'tcx>(
     infcx: &'cx BorrowckInferCtxt<'cx, 'tcx>,
-    sccs: Rc<Sccs<RegionVid, ConstraintSccIndex>>,
+    sccs: &Sccs<RegionVid, ConstraintSccIndex>,
 ) {
     use crate::renumber::RegionCtxt;
 
@@ -332,7 +327,7 @@ impl<'tcx> RegionInferenceContext<'tcx> {
         universal_regions: Rc<UniversalRegions<'tcx>>,
         placeholder_indices: Rc<PlaceholderIndices>,
         universal_region_relations: Frozen<UniversalRegionRelations<'tcx>>,
-        outlives_constraints: OutlivesConstraintSet<'tcx>,
+        mut outlives_constraints: OutlivesConstraintSet<'tcx>,
         member_constraints_in: MemberConstraintSet<'tcx, RegionVid>,
         universe_causes: FxIndexMap<ty::UniverseIndex, UniverseInfo<'tcx>>,
         type_tests: Vec<TypeTest<'tcx>>,
@@ -350,21 +345,15 @@ impl<'tcx> RegionInferenceContext<'tcx> {
             .map(|info| RegionDefinition::new(info.universe, info.origin))
             .collect();
 
-        let polonius_next_enabled = infcx.tcx.sess.opts.unstable_opts.polonius.is_next_enabled();
+        outlives_constraints.placeholders_to_static(&universal_regions, &definitions);
 
-        let constraints = if polonius_next_enabled {
-            Frozen::freeze(
-                outlives_constraints.placeholders_to_static(&universal_regions, &definitions),
-            )
-        } else {
-            Frozen::freeze(outlives_constraints)
-        };
+        let constraints = 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));
+        let constraint_sccs = constraints.compute_sccs(&constraint_graph, fr_static);
 
         if cfg!(debug_assertions) {
-            sccs_info(infcx, constraint_sccs.clone());
+            sccs_info(infcx, &constraint_sccs);
         }
 
         let mut scc_values =
@@ -399,7 +388,6 @@ impl<'tcx> RegionInferenceContext<'tcx> {
             type_tests,
             universal_regions,
             universal_region_relations,
-            polonius_next_enabled,
         };
 
         result.init_free_and_bound_regions();
@@ -571,23 +559,7 @@ impl<'tcx> RegionInferenceContext<'tcx> {
                 }
 
                 NllRegionVariableOrigin::Placeholder(placeholder) => {
-                    // Each placeholder region is only visible from
-                    // 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 self.polonius_next_enabled || scc_universe.can_name(placeholder.universe) {
-                        self.scc_values.add_element(scc, placeholder);
-                    } else {
-                        debug!(
-                            "init_free_and_bound_regions: placeholder {:?} is \
-                             not compatible with universe {:?} of its SCC {:?}",
-                            placeholder, scc_universe, scc,
-                        );
-                        self.add_incompatible_universe(scc);
-                    }
+                    self.scc_values.add_element(scc, placeholder);
                 }
 
                 NllRegionVariableOrigin::Existential { .. } => {
@@ -755,8 +727,7 @@ impl<'tcx> RegionInferenceContext<'tcx> {
         // SCC. For each SCC, we visit its successors and compute
         // their values, then we union all those values to get our
         // own.
-        let constraint_sccs = self.constraint_sccs.clone();
-        for scc in constraint_sccs.all_sccs() {
+        for scc in self.constraint_sccs.all_sccs() {
             self.compute_value_for_scc(scc);
         }
 
@@ -771,22 +742,10 @@ impl<'tcx> RegionInferenceContext<'tcx> {
     /// (which is assured by iterating over SCCs in dependency order).
     #[instrument(skip(self), level = "debug")]
     fn compute_value_for_scc(&mut self, scc_a: ConstraintSccIndex) {
-        let constraint_sccs = self.constraint_sccs.clone();
-
         // Walk each SCC `B` such that `A: B`...
-        for &scc_b in constraint_sccs.successors(scc_a) {
+        for &scc_b in self.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.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);
-            } else {
-                self.add_incompatible_universe(scc_a);
-            }
+            self.scc_values.add_region(scc_a, scc_b);
         }
 
         // Now take member constraints into account.
@@ -842,13 +801,6 @@ impl<'tcx> RegionInferenceContext<'tcx> {
         if self.scc_universes[scc] != ty::UniverseIndex::ROOT {
             return;
         }
-        debug_assert!(
-            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),
-        );
 
         // The existing value for `scc` is a lower-bound. This will
         // consist of some set `{P} + {LB}` of points `{P}` and
@@ -933,21 +885,6 @@ impl<'tcx> RegionInferenceContext<'tcx> {
         self.scc_values.placeholders_contained_in(scc_b).all(|p| universe_a.can_name(p.universe))
     }
 
-    /// Extend `scc` so that it can outlive some placeholder region
-    /// from a universe it can't name; at present, the only way for
-    /// this to be true is if `scc` outlives `'static`. This is
-    /// actually stricter than necessary: ideally, we'd support bounds
-    /// like `for<'a: 'b>` that might then allow us to approximate
-    /// `'a` with `'b` and not `'static`. But it will have to do for
-    /// now.
-    fn add_incompatible_universe(&mut self, scc: ConstraintSccIndex) {
-        debug!("add_incompatible_universe(scc={:?})", scc);
-
-        let fr_static = self.universal_regions.fr_static;
-        self.scc_values.add_all_points(scc);
-        self.scc_values.add_element(scc, fr_static);
-    }
-
     /// Once regions have been propagated, this method is used to see
     /// whether the "type tests" produced by typeck were satisfied;
     /// type tests encode type-outlives relationships like `T:
@@ -1579,10 +1516,6 @@ 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.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
@@ -2267,7 +2200,7 @@ impl<'tcx> RegionInferenceContext<'tcx> {
 
     /// Access to the SCC constraint graph.
     pub(crate) fn constraint_sccs(&self) -> &Sccs<RegionVid, ConstraintSccIndex> {
-        self.constraint_sccs.as_ref()
+        &self.constraint_sccs
     }
 
     /// Access to the region graph, built from the outlives constraints.