Only annotate region graph SCCs with their representative for functions without placeholders

Author: amandasystems

compiler/rustc_borrowck/src/handle_placeholders.rs

@@ -24,12 +24,59 @@ use crate::type_check::{Locations, MirTypeckRegionConstraints};
 use crate::universal_regions::UniversalRegions;
 use crate::{BorrowckInferCtxt, NllRegionVariableOrigin};
 
+pub(crate) trait RegionSccs {
+    fn representative(&self, scc: ConstraintSccIndex) -> RegionVid;
+    fn reachable_placeholders(&self, _scc: ConstraintSccIndex) -> Option<PlaceholderReachability> {
+        None
+    }
+    /// The largest universe this SCC can name. It's the smallest
+    /// largest nameable universe of any reachable region, or
+    /// `max_nameable(r) = min (max_nameable(r') for r' reachable from r)`
+    fn max_nameable_universe(&self, _scc: ConstraintSccIndex) -> UniverseIndex {
+        UniverseIndex::ROOT
+    }
+    fn max_placeholder_universe_reached(&self, _scc: ConstraintSccIndex) -> UniverseIndex {
+        UniverseIndex::ROOT
+    }
+}
+
+impl RegionSccs for IndexVec<ConstraintSccIndex, RegionTracker> {
+    fn representative(&self, scc: ConstraintSccIndex) -> RegionVid {
+        self[scc].representative.rvid()
+    }
+
+    fn reachable_placeholders(&self, scc: ConstraintSccIndex) -> Option<PlaceholderReachability> {
+        self[scc].reachable_placeholders
+    }
+
+    fn max_nameable_universe(&self, scc: ConstraintSccIndex) -> UniverseIndex {
+        // Note that this is stricter than it might need to be!
+        self[scc].min_max_nameable_universe
+    }
+
+    fn max_placeholder_universe_reached(&self, scc: ConstraintSccIndex) -> UniverseIndex {
+        self[scc].reachable_placeholders.map(|p| p.max_universe.u).unwrap_or(UniverseIndex::ROOT)
+    }
+}
+
+impl RegionSccs for IndexVec<ConstraintSccIndex, Representative> {
+    fn representative(&self, scc: ConstraintSccIndex) -> RegionVid {
+        self[scc].rvid()
+    }
+}
+
+impl FromRegionDefinition for Representative {
+    fn new(rvid: RegionVid, definition: &RegionDefinition<'_>) -> Self {
+        Representative::new(rvid, definition)
+    }
+}
+
 /// A set of outlives constraints after rewriting to remove
 /// higher-kinded constraints.
 pub(crate) struct LoweredConstraints<'tcx> {
     pub(crate) constraint_sccs: Sccs<RegionVid, ConstraintSccIndex>,
     pub(crate) definitions: Frozen<IndexVec<RegionVid, RegionDefinition<'tcx>>>,
-    pub(crate) scc_annotations: IndexVec<ConstraintSccIndex, RegionTracker>,
+    pub(crate) scc_annotations: Box<dyn RegionSccs>,
     pub(crate) outlives_constraints: Frozen<OutlivesConstraintSet<'tcx>>,
     pub(crate) type_tests: Vec<TypeTest<'tcx>>,
     pub(crate) liveness_constraints: LivenessValues,
@@ -42,23 +89,28 @@ impl<'d, 'tcx, A: scc::Annotation> SccAnnotations<'d, 'tcx, A> {
     }
 }
 
+trait FromRegionDefinition {
+    fn new(rvid: RegionVid, definition: &RegionDefinition<'_>) -> Self;
+}
+
 /// A Visitor for SCC annotation construction.
 pub(crate) struct SccAnnotations<'d, 'tcx, A: scc::Annotation> {
     pub(crate) scc_to_annotation: IndexVec<ConstraintSccIndex, A>,
     definitions: &'d IndexVec<RegionVid, RegionDefinition<'tcx>>,
 }
-
-impl scc::Annotations<RegionVid> for SccAnnotations<'_, '_, RegionTracker> {
-    fn new(&self, element: RegionVid) -> RegionTracker {
-        RegionTracker::new(element, &self.definitions[element])
+impl<A: scc::Annotation + FromRegionDefinition> scc::Annotations<RegionVid>
+    for SccAnnotations<'_, '_, A>
+{
+    fn new(&self, element: RegionVid) -> A {
+        A::new(element, &self.definitions[element])
     }
 
-    fn annotate_scc(&mut self, scc: ConstraintSccIndex, annotation: RegionTracker) {
+    fn annotate_scc(&mut self, scc: ConstraintSccIndex, annotation: A) {
         let idx = self.scc_to_annotation.push(annotation);
         assert!(idx == scc);
     }
 
-    type Ann = RegionTracker;
+    type Ann = A;
     type SccIdx = ConstraintSccIndex;
 }
 
@@ -127,8 +179,8 @@ pub(crate) struct RegionTracker {
     pub(crate) representative: Representative,
 }
 
-impl RegionTracker {
-    pub(crate) fn new(rvid: RegionVid, definition: &RegionDefinition<'_>) -> Self {
+impl FromRegionDefinition for RegionTracker {
+    fn new(rvid: RegionVid, definition: &RegionDefinition<'_>) -> Self {
         use NllRegionVariableOrigin::*;
 
         let min_max_nameable_universe = definition.universe;
@@ -163,24 +215,12 @@ impl RegionTracker {
             },
         }
     }
-
-    /// The largest universe this SCC can name. It's the smallest
-    /// largest nameable universe of any reachable region, or
-    /// `max_nameable(r) = min (max_nameable(r') for r' reachable from r)`
-    pub(crate) fn max_nameable_universe(self) -> UniverseIndex {
-        // Note that this is stricter than it might need to be!
-        self.min_max_nameable_universe
-    }
-
-    pub(crate) fn max_placeholder_universe_reached(self) -> UniverseIndex {
-        self.reachable_placeholders.map(|p| p.max_universe.u).unwrap_or(UniverseIndex::ROOT)
-    }
 }
 
 impl scc::Annotation for RegionTracker {
     fn update_scc(&mut self, other: &Self) {
         trace!("{:?} << {:?}", self.representative, other.representative);
-        self.representative = self.representative.min(other.representative);
+        self.representative.update_scc(&other.representative);
         self.is_placeholder = self.is_placeholder.max(other.is_placeholder);
         self.update_reachable(other); // SCC membership implies reachability.
     }
@@ -291,26 +331,32 @@ pub(crate) fn compute_sccs_applying_placeholder_outlives_constraints<'tcx>(
             )
         };
 
-    let mut scc_annotations = SccAnnotations::init(&definitions);
-    let constraint_sccs = compute_sccs(&outlives_constraints, &mut scc_annotations);
-
-    // This code structure is a bit convoluted because it allows for a planned
-    // future change where the early return here has a different type of annotation
-    // that does much less work.
     if !has_placeholders {
         debug!("No placeholder regions found; skipping rewriting logic!");
 
+        // We skip the extra logic and only record representatives.
+        let mut scc_annotations: SccAnnotations<'_, '_, Representative> =
+            SccAnnotations::init(&definitions);
+        let constraint_sccs = ConstraintSccs::new_with_annotation(
+            &outlives_constraints
+                .graph(definitions.len())
+                .region_graph(&outlives_constraints, fr_static),
+            &mut scc_annotations,
+        );
+
         return LoweredConstraints {
             type_tests,
             constraint_sccs,
-            scc_annotations: scc_annotations.scc_to_annotation,
+            scc_annotations: Box::new(scc_annotations.scc_to_annotation),
             definitions,
             outlives_constraints: Frozen::freeze(outlives_constraints),
             liveness_constraints,
             universe_causes,
         };
     }
     debug!("Placeholders present; activating placeholder handling logic!");
+    let mut scc_annotations = SccAnnotations::init(&definitions);
+    let constraint_sccs = compute_sccs(&outlives_constraints, &mut scc_annotations);
 
     let added_constraints = rewrite_placeholder_outlives(
         &constraint_sccs,
@@ -338,7 +384,7 @@ pub(crate) fn compute_sccs_applying_placeholder_outlives_constraints<'tcx>(
     LoweredConstraints {
         constraint_sccs,
         definitions,
-        scc_annotations,
+        scc_annotations: Box::new(scc_annotations),
         outlives_constraints: Frozen::freeze(outlives_constraints),
         type_tests,
         liveness_constraints,

compiler/rustc_borrowck/src/region_infer/mod.rs

@@ -3,7 +3,7 @@ use std::rc::Rc;
 
 use rustc_data_structures::frozen::Frozen;
 use rustc_data_structures::fx::{FxIndexMap, FxIndexSet};
-use rustc_data_structures::graph::scc::Sccs;
+use rustc_data_structures::graph::scc::{self, Sccs};
 use rustc_errors::Diag;
 use rustc_hir::def_id::CRATE_DEF_ID;
 use rustc_index::IndexVec;
@@ -26,7 +26,7 @@ use crate::constraints::graph::NormalConstraintGraph;
 use crate::constraints::{ConstraintSccIndex, OutlivesConstraint, OutlivesConstraintSet};
 use crate::dataflow::BorrowIndex;
 use crate::diagnostics::{RegionErrorKind, RegionErrors, UniverseInfo};
-use crate::handle_placeholders::{LoweredConstraints, RegionTracker};
+use crate::handle_placeholders::{LoweredConstraints, RegionSccs, RegionTracker};
 use crate::polonius::LiveLoans;
 use crate::polonius::legacy::PoloniusOutput;
 use crate::region_infer::values::{LivenessValues, RegionElement, RegionValues, ToElementIndex};
@@ -74,6 +74,14 @@ impl Representative {
     }
 }
 
+impl scc::Annotation for Representative {
+    fn update_scc(&mut self, other: &Self) {
+        *self = (*self).min(*other);
+    }
+
+    fn update_reachable(&mut self, _other: &Self) {}
+}
+
 pub(crate) type ConstraintSccs = Sccs<RegionVid, ConstraintSccIndex>;
 
 pub struct RegionInferenceContext<'tcx> {
@@ -102,7 +110,7 @@ pub struct RegionInferenceContext<'tcx> {
     /// compute the values of each region.
     constraint_sccs: ConstraintSccs,
 
-    scc_annotations: IndexVec<ConstraintSccIndex, RegionTracker>,
+    scc_annotations: Box<dyn RegionSccs>,
 
     /// Map universe indexes to information on why we created it.
     universe_causes: FxIndexMap<ty::UniverseIndex, UniverseInfo<'tcx>>,
@@ -499,9 +507,9 @@ impl<'tcx> RegionInferenceContext<'tcx> {
         scc_a: ConstraintSccIndex,
         scc_b: ConstraintSccIndex,
     ) -> bool {
-        self.scc_annotations[scc_a]
-            .max_nameable_universe()
-            .can_name(self.scc_annotations[scc_b].max_placeholder_universe_reached())
+        self.scc_annotations
+            .max_nameable_universe(scc_a)
+            .can_name(self.scc_annotations.max_placeholder_universe_reached(scc_b))
     }
 
     /// Once regions have been propagated, this method is used to see
@@ -613,7 +621,7 @@ impl<'tcx> RegionInferenceContext<'tcx> {
         //
         // It doesn't matter *what* universe because the promoted `T` will
         // always be in the root universe.
-        if !self.scc_annotations[r_scc].max_placeholder_universe_reached().is_root() {
+        if !self.scc_annotations.max_placeholder_universe_reached(r_scc).is_root() {
             debug!("encountered placeholder in higher universe, requiring 'static");
             let static_r = self.universal_regions().fr_static;
             propagated_outlives_requirements.push(ClosureOutlivesRequirement {
@@ -1091,7 +1099,7 @@ impl<'tcx> RegionInferenceContext<'tcx> {
 
     /// The largest universe of any region nameable from this SCC.
     fn max_nameable_universe(&self, scc: ConstraintSccIndex) -> UniverseIndex {
-        self.scc_annotations[scc].max_nameable_universe()
+        self.scc_annotations.max_nameable_universe(scc)
     }
 
     /// Checks the final value for the free region `fr` to see if it
@@ -1452,7 +1460,7 @@ impl<'tcx> RegionInferenceContext<'tcx> {
         scc: ConstraintSccIndex,
     ) -> Option<ty::PlaceholderRegion> {
         if let NllRegionVariableOrigin::Placeholder(p) =
-            self.definitions[self.scc_annotations[scc].representative.rvid()].origin
+            self.definitions[self.scc_annotations.representative(scc)].origin
         {
             Some(p)
         } else {
@@ -1465,7 +1473,7 @@ impl<'tcx> RegionInferenceContext<'tcx> {
         &self,
         scc: ConstraintSccIndex,
     ) -> Option<ty::PlaceholderRegion> {
-        let ps = self.scc_annotations[scc].reachable_placeholders?;
+        let ps = self.scc_annotations.reachable_placeholders(scc)?;
 
         if let NllRegionVariableOrigin::Placeholder(p) = self.definitions[ps.min_placeholder].origin
             && ps.min_placeholder == ps.max_placeholder
@@ -1775,7 +1783,7 @@ impl<'tcx> RegionInferenceContext<'tcx> {
     /// they *must* be equal (though not having the same repr does not
     /// mean they are unequal).
     fn scc_representative(&self, scc: ConstraintSccIndex) -> RegionVid {
-        self.scc_annotations[scc].representative.rvid()
+        self.scc_annotations.representative(scc)
     }
 
     pub(crate) fn liveness_constraints(&self) -> &LivenessValues {

compiler/rustc_borrowck/src/region_infer/opaque_types/region_ctxt.rs

@@ -9,7 +9,7 @@ use rustc_mir_dataflow::points::DenseLocationMap;
 use crate::BorrowckInferCtxt;
 use crate::constraints::ConstraintSccIndex;
 use crate::diagnostics::RegionErrors;
-use crate::handle_placeholders::{SccAnnotations, region_definitions};
+use crate::handle_placeholders::{RegionSccs, SccAnnotations, region_definitions};
 use crate::region_infer::reverse_sccs::ReverseSccGraph;
 use crate::region_infer::values::RegionValues;
 use crate::region_infer::{
@@ -110,7 +110,7 @@ impl<'a, 'tcx> RegionCtxt<'a, 'tcx> {
         &self,
         scc: ConstraintSccIndex,
     ) -> UniverseIndex {
-        self.scc_annotations[scc].max_placeholder_universe_reached()
+        self.scc_annotations.max_placeholder_universe_reached(scc)
     }
 
     pub(super) fn universal_regions(&self) -> &UniversalRegions<'tcx> {