Avoid handling placeholders for MIR bodies without them

Author: amandasystems

compiler/rustc_borrowck/src/constraints/mod.rs

@@ -2,14 +2,15 @@ use std::fmt;
 use std::ops::Index;
 
 use rustc_data_structures::fx::FxHashSet;
+use rustc_data_structures::graph::scc;
 use rustc_index::{IndexSlice, IndexVec};
 use rustc_infer::infer::NllRegionVariableOrigin;
 use rustc_middle::mir::ConstraintCategory;
 use rustc_middle::ty::{RegionVid, TyCtxt, VarianceDiagInfo};
 use rustc_span::Span;
 use tracing::{debug, instrument};
 
-use crate::region_infer::{ConstraintSccs, RegionDefinition, RegionTracker};
+use crate::region_infer::{PlaceholderTracking, RegionDefinition, RegionTracker};
 use crate::type_check::Locations;
 use crate::universal_regions::UniversalRegions;
 
@@ -59,16 +60,15 @@ impl<'tcx> OutlivesConstraintSet<'tcx> {
     /// Computes cycles (SCCs) in the graph of regions. In particular,
     /// find all regions R1, R2 such that R1: R2 and R2: R1 and group
     /// them into an SCC, and find the relationships between SCCs.
-    pub(crate) fn compute_sccs(
+    pub(crate) fn compute_sccs<A: scc::Annotation, F: Fn(RegionVid) -> A>(
         &self,
         static_region: RegionVid,
         definitions: &IndexVec<RegionVid, RegionDefinition<'tcx>>,
-    ) -> ConstraintSccs {
+        annotate_region: F,
+    ) -> scc::Sccs<RegionVid, ConstraintSccIndex, A> {
         let constraint_graph = self.graph(definitions.len());
         let region_graph = &constraint_graph.region_graph(self, static_region);
-        ConstraintSccs::new_with_annotation(&region_graph, |r| {
-            RegionTracker::new(r, &definitions[r])
-        })
+        scc::Sccs::new_with_annotation(&region_graph, annotate_region)
     }
 
     /// There is a placeholder violation; add a requirement
@@ -131,9 +131,11 @@ impl<'tcx> OutlivesConstraintSet<'tcx> {
         &mut self,
         universal_regions: &UniversalRegions<'tcx>,
         definitions: &IndexVec<RegionVid, RegionDefinition<'tcx>>,
-    ) -> ConstraintSccs {
+    ) -> scc::Sccs<RegionVid, ConstraintSccIndex, PlaceholderTracking> {
         let fr_static = universal_regions.fr_static;
-        let sccs = self.compute_sccs(fr_static, definitions);
+        let new_tracker = |r| PlaceholderTracking::On(RegionTracker::new(r, &definitions[r]));
+
+        let sccs = self.compute_sccs(fr_static, definitions, new_tracker);
 
         // Is this SCC already outliving static directly or transitively?
         let mut outlives_static = FxHashSet::default();
@@ -200,7 +202,7 @@ impl<'tcx> OutlivesConstraintSet<'tcx> {
         if !outlives_static.is_empty() {
             debug!("The following SCCs had :'static constraints added: {:?}", outlives_static);
             // We changed the constraint set and so must recompute SCCs.
-            self.compute_sccs(fr_static, definitions)
+            self.compute_sccs(fr_static, definitions, new_tracker)
         } else {
             // If we didn't add any back-edges; no more work needs doing
             sccs

compiler/rustc_borrowck/src/region_infer/mod.rs

@@ -46,13 +46,89 @@ mod reverse_sccs;
 
 pub(crate) mod values;
 
-pub(crate) type ConstraintSccs = Sccs<RegionVid, ConstraintSccIndex, RegionTracker>;
+pub(crate) type ConstraintSccs = Sccs<RegionVid, ConstraintSccIndex, PlaceholderTracking>;
+
+#[derive(Copy, Clone, Debug)]
+pub enum PlaceholderTracking {
+    Off(Representative),
+    On(RegionTracker),
+}
+
+impl scc::Annotation for PlaceholderTracking {
+    fn merge_scc(self, other: Self) -> Self {
+        use PlaceholderTracking::*;
+
+        match (self, other) {
+            (Off(this), Off(that)) => Off(this.merge_scc(that)),
+            (On(this), On(that)) => On(this.merge_scc(that)),
+            _ => unreachable!(),
+        }
+    }
+
+    fn merge_reached(self, other: Self) -> Self {
+        use PlaceholderTracking::*;
+
+        match (self, other) {
+            (Off(this), Off(that)) => Off(this.merge_reached(that)),
+            (On(this), On(that)) => On(this.merge_reached(that)),
+            _ => unreachable!(),
+        }
+    }
+}
+
+impl PlaceholderTracking {
+    pub(crate) fn representative_rvid(&self) -> RegionVid {
+        match self {
+            PlaceholderTracking::Off(r) => r.rvid(),
+            PlaceholderTracking::On(region_tracker) => region_tracker.representative_rvid(),
+        }
+    }
+
+    pub(crate) fn reaches_other_placeholder(&self, other: RegionVid) -> Option<RegionVid> {
+        match self {
+            PlaceholderTracking::Off(_) => None,
+            PlaceholderTracking::On(region_tracker) => {
+                region_tracker.reaches_other_placeholder(other)
+            }
+        }
+    }
+
+    pub(crate) fn universe_violation(&self) -> Option<RegionVid> {
+        match self {
+            PlaceholderTracking::Off(_) => None,
+            PlaceholderTracking::On(region_tracker) => region_tracker.universe_violation(),
+        }
+    }
+
+    fn min_universe(&self) -> UniverseIndex {
+        match self {
+            PlaceholderTracking::Off(_) => UniverseIndex::ROOT, // Not technically correct?
+            PlaceholderTracking::On(region_tracker) => region_tracker.min_universe(),
+        }
+    }
+
+    fn universe_compatible_with(&self, other: PlaceholderTracking) -> bool {
+        use PlaceholderTracking::*;
+        match (self, other) {
+            (Off(_), Off(_)) => true, // Not technically correct?
+            (On(this), On(that)) => this.universe_compatible_with(that),
+            _ => unreachable!(),
+        }
+    }
+
+    fn placeholder_representative(&self) -> Option<RegionVid> {
+        match self {
+            PlaceholderTracking::Off(_) => None,
+            PlaceholderTracking::On(region_tracker) => region_tracker.placeholder_representative(),
+        }
+    }
+}
 
 /// The representative region variable for an SCC, tagged by its origin.
 /// We prefer placeholders over existentially quantified variables, otherwise
 /// it's the one with the smallest Region Variable ID.
 #[derive(Copy, Debug, Clone, PartialEq, PartialOrd, Eq, Ord)]
-enum Representative {
+pub enum Representative {
     FreeRegion(RegionVid),
     Placeholder(RegionVid),
     Existential(RegionVid),
@@ -66,6 +142,14 @@ impl Representative {
             Representative::Existential(region_vid) => *region_vid,
         }
     }
+
+    fn new(r: RegionVid, definitions: &IndexVec<RegionVid, RegionDefinition<'_>>) -> Self {
+        match definitions[r].origin {
+            NllRegionVariableOrigin::FreeRegion => Representative::FreeRegion(r),
+            NllRegionVariableOrigin::Placeholder(_) => Representative::Placeholder(r),
+            NllRegionVariableOrigin::Existential { .. } => Representative::Existential(r),
+        }
+    }
 }
 
 impl scc::Annotation for Representative {
@@ -457,7 +541,10 @@ pub(crate) enum ExtraConstraintInfo {
 }
 
 #[instrument(skip(infcx, sccs), level = "debug")]
-fn sccs_info<'tcx>(infcx: &BorrowckInferCtxt<'tcx>, sccs: &ConstraintSccs) {
+fn sccs_info<'tcx, A: scc::Annotation>(
+    infcx: &BorrowckInferCtxt<'tcx>,
+    sccs: &scc::Sccs<RegionVid, ConstraintSccIndex, A>,
+) {
     use crate::renumber::RegionCtxt;
 
     let var_to_origin = infcx.reg_var_to_origin.borrow();
@@ -544,27 +631,39 @@ impl<'tcx> RegionInferenceContext<'tcx> {
         debug!("type tests: {:#?}", type_tests);
 
         // Create a RegionDefinition for each inference variable.
-        let definitions = {
-            let mut definitions: IndexVec<_, _> = var_infos
-                .iter()
-                .map(|info| RegionDefinition::new(info.universe, info.origin))
-                .collect();
+        let (definitions, has_placeholders) = {
+            let mut definitions = IndexVec::with_capacity(var_infos.len());
+            let mut has_placeholders = false;
+
+            for info in var_infos.iter() {
+                let definition = RegionDefinition::new(info.universe, info.origin);
+                has_placeholders |=
+                    matches!(definition.origin, NllRegionVariableOrigin::Placeholder(_));
+                definitions.push(definition);
+            }
 
             // Add external names from universal regions in fun function definitions.
             for (external_name, variable) in universal_regions.named_universal_regions() {
                 debug!("region {:?} has external name {:?}", variable, external_name);
                 definitions[variable].external_name = Some(external_name);
             }
-            definitions
+            (definitions, has_placeholders)
         };
 
-        let constraint_sccs =
-            outlives_constraints.add_outlives_static(&universal_regions, &definitions);
+        let constraint_sccs = if has_placeholders {
+            debug!("Placeholders present; activating placeholder handling logic!");
+            outlives_constraints.add_outlives_static(&universal_regions, &definitions)
+        } else {
+            debug!("No placeholders in MIR body; disabling their validation.");
+            outlives_constraints.compute_sccs(universal_regions.fr_static, &definitions, |r| {
+                PlaceholderTracking::Off(Representative::new(r, &definitions))
+            })
+        };
         let constraints = Frozen::freeze(outlives_constraints);
         let constraint_graph = Frozen::freeze(constraints.graph(definitions.len()));
 
         if cfg!(debug_assertions) {
-            sccs_info(infcx, &constraint_sccs);
+            sccs_info(infcx, &constraint_sccs)
         }
 
         let mut scc_values = RegionValues::new(elements, universal_regions.len());

compiler/rustc_borrowck/src/region_infer/opaque_types.rs

@@ -216,14 +216,6 @@ impl<'tcx> RegionInferenceContext<'tcx> {
                     let higher_ranked_region = if let Some(representative) =
                         self.placeholder_representative(scc)
                     {
-                        // FIXME: remove this assertion once the tests pass!
-                        assert!(
-                            self.constraint_sccs
-                                .annotation(scc)
-                                .placeholder_representative()
-                                .is_some_and(|representative| representative == vid)
-                        );
-
                         ty::Region::new_placeholder(tcx, representative)
                     } else {
                         debug!(