rarw

Author: lcnr

compiler/rustc_borrowck/src/region_infer/mod.rs

@@ -164,13 +164,6 @@ pub struct RegionInferenceContext<'tcx> {
     /// compute the values of each region.
     constraint_sccs: ConstraintSccs,
 
-    /// 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
-    /// to outlive a given SCC. Computed lazily.
-    ///
-    /// TODO: this sohuld be removeable.
-    rev_scc_graph: Option<ReverseSccGraph>,
-
     /// Map universe indexes to information on why we created it.
     universe_causes: FxIndexMap<ty::UniverseIndex, UniverseInfo<'tcx>>,
 
@@ -425,7 +418,6 @@ impl<'tcx> RegionInferenceContext<'tcx> {
             constraints,
             constraint_graph,
             constraint_sccs,
-            rev_scc_graph: None,
             universe_causes,
             scc_values,
             type_tests,

compiler/rustc_borrowck/src/region_infer/opaque_types.rs

@@ -26,7 +26,7 @@ use crate::constraints::{ConstraintSccIndex, OutlivesConstraintSet};
 use crate::consumers::OutlivesConstraint;
 use crate::type_check::free_region_relations::UniversalRegionRelations;
 use crate::type_check::{Locations, MirTypeckRegionConstraints};
-use crate::universal_regions::UniversalRegions;
+use crate::universal_regions::{self, RegionClassification, UniversalRegions};
 use crate::{BorrowCheckRootCtxt, BorrowckInferCtxt};
 
 pub(crate) fn handle_opaque_type_uses<'tcx>(
@@ -77,11 +77,7 @@ pub(crate) fn handle_opaque_type_uses<'tcx>(
     'entry: for (&key, &hidden_type) in &opaque_types {
         let (key, hidden_type) =
             fold_regions(tcx, infcx.resolve_vars_if_possible((key, hidden_type)), |r, _| {
-                if let ty::RePlaceholder(placeholder) = r.kind() {
-                    constraints.get_placeholder_region(placeholder)
-                } else {
-                    ty::Region::new_var(tcx, universal_regions.to_region_vid(r))
-                }
+                Region::new_var(tcx, to_region_vid(&constraints, universal_regions, r))
             });
         // Check whether the arguments are fully universal.
         //
@@ -93,7 +89,12 @@ pub(crate) fn handle_opaque_type_uses<'tcx>(
             if let Some(region) = captured_arg.as_region() {
                 let scc = constraint_sccs.scc(region.as_var());
                 let vid = constraint_sccs.annotation(scc).representative;
-                if matches!(definitions[vid].origin, NllRegionVariableOrigin::FreeRegion) {
+                if matches!(definitions[vid].origin, NllRegionVariableOrigin::FreeRegion)
+                    && !matches!(
+                        universal_regions.region_classification(vid),
+                        Some(RegionClassification::External)
+                    )
+                {
                     arg_regions.push((vid, definitions[vid].external_name.unwrap()));
                 } else {
                     continue 'entry;
@@ -152,7 +153,7 @@ pub(crate) fn handle_opaque_type_uses<'tcx>(
             infcx,
             span: hidden_type.span,
             universal_regions,
-            outlives_constraints: &mut constraints.outlives_constraints,
+            constraints: &mut constraints,
         };
         TypeRelation::relate(&mut relation, hidden_type.ty, expected).unwrap();
 
@@ -171,6 +172,18 @@ pub(crate) fn handle_opaque_type_uses<'tcx>(
     constraints
 }
 
+fn to_region_vid<'tcx>(
+    constraints: &MirTypeckRegionConstraints<'tcx>,
+    universal_regions: &UniversalRegions<'tcx>,
+    r: Region<'tcx>,
+) -> RegionVid {
+    if let ty::RePlaceholder(placeholder) = r.kind() {
+        constraints.get_placeholder_region(placeholder).as_var()
+    } else {
+        universal_regions.to_region_vid(r)
+    }
+}
+
 struct OpaqueHiddenTypeFolder<'a, 'tcx> {
     infcx: &'a BorrowckInferCtxt<'tcx>,
     arg_regions: &'a [(RegionVid, Region<'tcx>)],
@@ -334,7 +347,7 @@ struct EquateRegions<'a, 'tcx> {
     infcx: &'a BorrowckInferCtxt<'tcx>,
     span: Span,
     universal_regions: &'a UniversalRegions<'tcx>,
-    outlives_constraints: &'a mut OutlivesConstraintSet<'tcx>,
+    constraints: &'a mut MirTypeckRegionConstraints<'tcx>,
 }
 
 impl<'tcx> TypeRelation<TyCtxt<'tcx>> for EquateRegions<'_, 'tcx> {
@@ -366,10 +379,10 @@ impl<'tcx> TypeRelation<TyCtxt<'tcx>> for EquateRegions<'_, 'tcx> {
             return Ok(a);
         }
 
-        let a_vid = self.universal_regions.to_region_vid(a);
-        let b_vid = self.universal_regions.to_region_vid(b);
+        let a_vid = to_region_vid(self.constraints, self.universal_regions, a);
+        let b_vid = to_region_vid(self.constraints, self.universal_regions, b);
         let locations = Locations::All(self.span);
-        self.outlives_constraints.push(OutlivesConstraint {
+        self.constraints.outlives_constraints.push(OutlivesConstraint {
             sup: a_vid,
             sub: b_vid,
             locations,
@@ -378,7 +391,7 @@ impl<'tcx> TypeRelation<TyCtxt<'tcx>> for EquateRegions<'_, 'tcx> {
             variance_info: ty::VarianceDiagInfo::None,
             from_closure: false,
         });
-        self.outlives_constraints.push(OutlivesConstraint {
+        self.constraints.outlives_constraints.push(OutlivesConstraint {
             sup: b_vid,
             sub: a_vid,
             locations,
@@ -457,10 +470,9 @@ impl<'tcx> RegionInferenceContext<'tcx> {
                 // region which cannot be mapped back to a universal.
                 // FIXME: We could probably compute the LUB if there is one.
                 let scc = self.constraint_sccs.scc(vid);
-                let upper_bounds: Vec<_> = self
-                    .rev_scc_graph
-                    .as_ref()
-                    .unwrap()
+                let rev_scc_graph =
+                    &ReverseSccGraph::compute(&self.constraint_sccs, self.universal_regions());
+                let upper_bounds: Vec<_> = rev_scc_graph
                     .upper_bounds(scc)
                     .filter_map(|vid| self.definitions[vid].external_name)
                     .filter(|r| !r.is_static())

compiler/rustc_borrowck/src/region_infer/reverse_sccs.rs

@@ -56,15 +56,3 @@ impl ReverseSccGraph {
             .filter(move |r| duplicates.insert(*r))
     }
 }
-
-impl RegionInferenceContext<'_> {
-    /// Compute the reverse SCC-based constraint graph (lazily).
-    pub(super) fn compute_reverse_scc_graph(&mut self) {
-        if self.rev_scc_graph.is_some() {
-            return;
-        } else {
-            self.rev_scc_graph =
-                Some(ReverseSccGraph::compute(&self.constraint_sccs, self.universal_regions()))
-        }
-    }
-}