Preliminary attempt at removing placeholders out of the borrow checker.

This version is maximally naive, and currently unsound.

Author: amandasystems

compiler/rustc_borrowck/src/diagnostics/bound_region_errors.rs

@@ -180,20 +180,7 @@ trait TypeOpInfo<'tcx> {
             ty::Placeholder { universe: adjusted_universe.into(), bound: placeholder.bound },
         );
 
-        let error_region = if let RegionElement::PlaceholderRegion(error_placeholder) =
-            error_element
-        {
-            let adjusted_universe =
-                error_placeholder.universe.as_u32().checked_sub(base_universe.as_u32());
-            adjusted_universe.map(|adjusted| {
-                ty::Region::new_placeholder(
-                    tcx,
-                    ty::Placeholder { universe: adjusted.into(), bound: error_placeholder.bound },
-                )
-            })
-        } else {
-            None
-        };
+        let error_region = None;
 
         debug!(?placeholder_region);
 

compiler/rustc_borrowck/src/diagnostics/region_errors.rs

@@ -203,35 +203,20 @@ impl<'infcx, 'tcx> MirBorrowckCtxt<'_, '_, 'infcx, 'tcx> {
     fn suggest_static_lifetime_for_gat_from_hrtb(
         &self,
         diag: &mut Diag<'_>,
-        lower_bound: RegionVid,
+        _lower_bound: RegionVid,
     ) {
         let mut suggestions = vec![];
         let hir = self.infcx.tcx.hir();
 
         // find generic associated types in the given region 'lower_bound'
-        let gat_id_and_generics = self
-            .regioncx
-            .placeholders_contained_in(lower_bound)
-            .map(|placeholder| {
-                if let Some(id) = placeholder.bound.kind.get_id()
-                    && let Some(placeholder_id) = id.as_local()
-                    && let gat_hir_id = self.infcx.tcx.local_def_id_to_hir_id(placeholder_id)
-                    && let Some(generics_impl) = self
-                        .infcx
-                        .tcx
-                        .parent_hir_node(self.infcx.tcx.parent_hir_id(gat_hir_id))
-                        .generics()
-                {
-                    Some((gat_hir_id, generics_impl))
-                } else {
-                    None
-                }
-            })
-            .collect::<Vec<_>>();
-        debug!(?gat_id_and_generics);
+        // FIXME: this should find one of the special-case blamable
+        // new constraints instead!
+        //let gat_id_and_generics = vec![];
+        //debug!(?gat_id_and_generics);
 
         // find higher-ranked trait bounds bounded to the generic associated types
-        let mut hrtb_bounds = vec![];
+        let hrtb_bounds = vec![];
+        /*
         gat_id_and_generics.iter().flatten().for_each(|(gat_hir_id, generics)| {
             for pred in generics.predicates {
                 let BoundPredicate(WhereBoundPredicate { bound_generic_params, bounds, .. }) = pred
@@ -250,6 +235,7 @@ impl<'infcx, 'tcx> MirBorrowckCtxt<'_, '_, 'infcx, 'tcx> {
             }
         });
         debug!(?hrtb_bounds);
+        */
 
         hrtb_bounds.iter().for_each(|bound| {
             let Trait(PolyTraitRef { trait_ref, span: trait_span, .. }, _) = bound else {

compiler/rustc_borrowck/src/region_infer/mod.rs

@@ -115,6 +115,12 @@ impl RegionTracker {
         }
     }
 
+    /// If the representative is a placeholder, return it,
+    /// otherwise return None.
+    fn placeholder_representative(&self) -> Option<RegionVid> {
+        if self.representative_is_placeholder { Some(self.representative) } else { None }
+    }
+
     /// The smallest-indexed universe reachable from and/or in this SCC.
     fn min_universe(self) -> UniverseIndex {
         self.min_reachable_universe
@@ -428,8 +434,7 @@ impl<'tcx> RegionInferenceContext<'tcx> {
             sccs_info(infcx, &constraint_sccs);
         }
 
-        let mut scc_values =
-            RegionValues::new(elements, universal_regions.len(), &placeholder_indices);
+        let mut scc_values = RegionValues::new(elements, universal_regions.len());
 
         for region in liveness_constraints.regions() {
             let scc = constraint_sccs.scc(region);
@@ -540,10 +545,9 @@ impl<'tcx> RegionInferenceContext<'tcx> {
                     self.scc_values.add_element(scc, variable);
                 }
 
-                NllRegionVariableOrigin::Placeholder(placeholder) => {
-                    self.scc_values.add_element(scc, placeholder);
+                NllRegionVariableOrigin::Placeholder { .. } => {
+                    // Placeholders are already handled by rewriting constraints.
                 }
-
                 NllRegionVariableOrigin::Existential { .. } => {
                     // For existential, regions, nothing to do.
                 }
@@ -602,14 +606,6 @@ impl<'tcx> RegionInferenceContext<'tcx> {
         self.scc_values.region_value_str(scc)
     }
 
-    pub(crate) fn placeholders_contained_in<'a>(
-        &'a self,
-        r: RegionVid,
-    ) -> impl Iterator<Item = ty::PlaceholderRegion> + 'a {
-        let scc = self.constraint_sccs.scc(r);
-        self.scc_values.placeholders_contained_in(scc)
-    }
-
     /// Returns access to the value of `r` for debugging purposes.
     pub(crate) fn region_universe(&self, r: RegionVid) -> ty::UniverseIndex {
         self.scc_universe(self.constraint_sccs.scc(r))
@@ -982,7 +978,8 @@ impl<'tcx> RegionInferenceContext<'tcx> {
         //
         // It doesn't matter *what* universe because the promoted `T` will
         // always be in the root universe.
-        if let Some(p) = self.scc_values.placeholders_contained_in(r_scc).next() {
+
+        if let Some(p) = self.constraint_sccs.annotation(r_scc).placeholder_representative() {
             debug!("encountered placeholder in higher universe: {:?}, requiring 'static", p);
             let static_r = self.universal_regions.fr_static;
             propagated_outlives_requirements.push(ClosureOutlivesRequirement {
@@ -1648,14 +1645,6 @@ impl<'tcx> RegionInferenceContext<'tcx> {
         for error_element in self.scc_values.elements_contained_in(longer_fr_scc) {
             match error_element {
                 RegionElement::Location(_) | RegionElement::RootUniversalRegion(_) => {}
-                // If we have some bound universal region `'a`, then the only
-                // elements it can contain is itself -- we don't know anything
-                // else about it!
-                RegionElement::PlaceholderRegion(placeholder1) => {
-                    if placeholder == placeholder1 {
-                        continue;
-                    }
-                }
             }
 
             errors_buffer.push(RegionErrorKind::BoundUniversalRegionError {
@@ -1922,14 +1911,6 @@ impl<'tcx> RegionInferenceContext<'tcx> {
         match *element {
             RegionElement::Location(l) => self.find_sub_region_live_at(longer_fr, l),
             RegionElement::RootUniversalRegion(r) => r,
-            RegionElement::PlaceholderRegion(error_placeholder) => self
-                .definitions
-                .iter_enumerated()
-                .find_map(|(r, definition)| match definition.origin {
-                    NllRegionVariableOrigin::Placeholder(p) if p == error_placeholder => Some(r),
-                    _ => None,
-                })
-                .unwrap(),
         }
     }
 

compiler/rustc_borrowck/src/region_infer/opaque_types.rs

@@ -212,14 +212,14 @@ impl<'tcx> RegionInferenceContext<'tcx> {
 
                 // Special handling of higher-ranked regions.
                 if !self.scc_universe(scc).is_root() {
-                    match self.scc_values.placeholders_contained_in(scc).enumerate().last() {
-                        // If the region contains a single placeholder then they're equal.
-                        Some((0, placeholder)) => {
-                            return ty::Region::new_placeholder(tcx, placeholder);
-                        }
-
+                    let annotation = self.constraint_sccs.annotation(scc);
+                    if annotation.representative_is_placeholder && vid == annotation.representative
+                    {
+                        // FIXME: somehow construct the right type out of the representative!
+                        return region;
+                    } else {
                         // Fallback: this will produce a cryptic error message.
-                        _ => return region,
+                        return region;
                     }
                 }
 

compiler/rustc_borrowck/src/region_infer/values.rs

@@ -27,10 +27,6 @@ pub(crate) enum RegionElement {
     /// A universally quantified region from the root universe (e.g.,
     /// a lifetime parameter).
     RootUniversalRegion(RegionVid),
-
-    /// A placeholder (e.g., instantiated from a `for<'a> fn(&'a u32)`
-    /// type).
-    PlaceholderRegion(ty::PlaceholderRegion),
 }
 
 /// Records the CFG locations where each region is live. When we initially compute liveness, we use
@@ -226,21 +222,6 @@ impl PlaceholderIndices {
         let (index, _) = self.indices.insert_full(placeholder);
         index.into()
     }
-
-    pub(crate) fn lookup_index(&self, placeholder: ty::PlaceholderRegion) -> PlaceholderIndex {
-        self.indices.get_index_of(&placeholder).unwrap().into()
-    }
-
-    pub(crate) fn lookup_placeholder(
-        &self,
-        placeholder: PlaceholderIndex,
-    ) -> ty::PlaceholderRegion {
-        self.indices[placeholder.index()]
-    }
-
-    pub(crate) fn len(&self) -> usize {
-        self.indices.len()
-    }
 }
 
 /// Stores the full values for a set of regions (in contrast to
@@ -264,31 +245,19 @@ impl PlaceholderIndices {
 #[derive(Clone)]
 pub(crate) struct RegionValues<N: Idx> {
     elements: Rc<DenseLocationMap>,
-    placeholder_indices: Rc<PlaceholderIndices>,
     points: SparseIntervalMatrix<N, PointIndex>,
     free_regions: SparseBitMatrix<N, RegionVid>,
-
-    /// Placeholders represent bound regions -- so something like `'a`
-    /// in `for<'a> fn(&'a u32)`.
-    placeholders: SparseBitMatrix<N, PlaceholderIndex>,
 }
 
 impl<N: Idx> RegionValues<N> {
     /// Creates a new set of "region values" that tracks causal information.
     /// Each of the regions in num_region_variables will be initialized with an
     /// empty set of points and no causal information.
-    pub(crate) fn new(
-        elements: &Rc<DenseLocationMap>,
-        num_universal_regions: usize,
-        placeholder_indices: &Rc<PlaceholderIndices>,
-    ) -> Self {
-        let num_placeholders = placeholder_indices.len();
+    pub(crate) fn new(elements: &Rc<DenseLocationMap>, num_universal_regions: usize) -> Self {
         Self {
             elements: elements.clone(),
             points: SparseIntervalMatrix::new(elements.num_points()),
-            placeholder_indices: placeholder_indices.clone(),
             free_regions: SparseBitMatrix::new(num_universal_regions),
-            placeholders: SparseBitMatrix::new(num_placeholders),
         }
     }
 
@@ -307,9 +276,7 @@ impl<N: Idx> RegionValues<N> {
     /// Adds all elements in `r_from` to `r_to` (because e.g., `r_to:
     /// r_from`).
     pub(crate) fn add_region(&mut self, r_to: N, r_from: N) -> bool {
-        self.points.union_rows(r_from, r_to)
-            | self.free_regions.union_rows(r_from, r_to)
-            | self.placeholders.union_rows(r_from, r_to)
+        self.points.union_rows(r_from, r_to) | self.free_regions.union_rows(r_from, r_to)
     }
 
     /// Returns `true` if the region `r` contains the given element.
@@ -378,18 +345,6 @@ impl<N: Idx> RegionValues<N> {
         self.free_regions.row(r).into_iter().flat_map(|set| set.iter())
     }
 
-    /// Returns all the elements contained in a given region's value.
-    pub(crate) fn placeholders_contained_in<'a>(
-        &'a self,
-        r: N,
-    ) -> impl Iterator<Item = ty::PlaceholderRegion> + 'a {
-        self.placeholders
-            .row(r)
-            .into_iter()
-            .flat_map(|set| set.iter())
-            .map(move |p| self.placeholder_indices.lookup_placeholder(p))
-    }
-
     /// Returns all the elements contained in a given region's value.
     pub(crate) fn elements_contained_in<'a>(
         &'a self,
@@ -400,10 +355,7 @@ impl<N: Idx> RegionValues<N> {
         let free_regions_iter =
             self.universal_regions_outlived_by(r).map(RegionElement::RootUniversalRegion);
 
-        let placeholder_universes_iter =
-            self.placeholders_contained_in(r).map(RegionElement::PlaceholderRegion);
-
-        points_iter.chain(free_regions_iter).chain(placeholder_universes_iter)
+        points_iter.chain(free_regions_iter)
     }
 
     /// Returns a "pretty" string value of the region. Meant for debugging.
@@ -440,18 +392,6 @@ impl ToElementIndex for RegionVid {
     }
 }
 
-impl ToElementIndex for ty::PlaceholderRegion {
-    fn add_to_row<N: Idx>(self, values: &mut RegionValues<N>, row: N) -> bool {
-        let index = values.placeholder_indices.lookup_index(self);
-        values.placeholders.insert(row, index)
-    }
-
-    fn contained_in_row<N: Idx>(self, values: &RegionValues<N>, row: N) -> bool {
-        let index = values.placeholder_indices.lookup_index(self);
-        values.placeholders.contains(row, index)
-    }
-}
-
 /// For debugging purposes, returns a pretty-printed string of the given points.
 pub(crate) fn pretty_print_points(
     elements: &DenseLocationMap,
@@ -511,17 +451,6 @@ fn pretty_print_region_elements(elements: impl IntoIterator<Item = RegionElement
                 push_sep(&mut result);
                 result.push_str(&format!("{fr:?}"));
             }
-
-            RegionElement::PlaceholderRegion(placeholder) => {
-                if let Some((location1, location2)) = open_location {
-                    push_sep(&mut result);
-                    push_location_range(&mut result, location1, location2);
-                    open_location = None;
-                }
-
-                push_sep(&mut result);
-                result.push_str(&format!("{placeholder:?}"));
-            }
         }
     }