WIP

Author: amandasystems

compiler/rustc_borrowck/src/diagnostics/region_errors.rs

@@ -120,7 +120,8 @@ pub(crate) enum RegionErrorKind<'tcx> {
         member_region: ty::Region<'tcx>,
     },
 
-    /// Higher-ranked subtyping error.
+    /// Higher-ranked subtyping error. A placeholder outlives
+    /// either a location or a universal region.
     BoundUniversalRegionError {
         /// The placeholder free region.
         longer_fr: RegionVid,

compiler/rustc_borrowck/src/handle_placeholders.rs

@@ -13,12 +13,12 @@ use rustc_infer::infer::RegionVariableOrigin;
 use rustc_middle::bug;
 use rustc_middle::mir::ConstraintCategory;
 use rustc_middle::ty::{RegionVid, UniverseIndex};
-use tracing::{debug, trace};
+use tracing::{debug, instrument, trace};
 
 use crate::constraints::graph::{ConstraintGraph, Normal, RegionGraph};
 use crate::constraints::{ConstraintSccIndex, OutlivesConstraintSet};
 use crate::consumers::OutlivesConstraint;
-use crate::diagnostics::UniverseInfo;
+use crate::diagnostics::{RegionErrorKind, RegionErrors, UniverseInfo};
 use crate::member_constraints::MemberConstraintSet;
 use crate::region_infer::values::{LivenessValues, PlaceholderIndices};
 use crate::region_infer::{ConstraintSccs, RegionDefinition, Representative, TypeTest};
@@ -293,6 +293,7 @@ pub(crate) fn compute_sccs_applying_placeholder_outlives_constraints<'tcx>(
     constraints: MirTypeckRegionConstraints<'tcx>,
     universal_region_relations: &Frozen<UniversalRegionRelations<'tcx>>,
     infcx: &BorrowckInferCtxt<'tcx>,
+    errors_buffer: &mut RegionErrors<'tcx>,
 ) -> LoweredConstraints<'tcx> {
     let universal_regions = &universal_region_relations.universal_regions;
     let (definitions, has_placeholders) = region_definitions(universal_regions, infcx);
@@ -359,6 +360,13 @@ pub(crate) fn compute_sccs_applying_placeholder_outlives_constraints<'tcx>(
         &definitions,
     );
 
+    find_placeholder_mismatch_errors(
+        &definitions,
+        &constraint_sccs,
+        &scc_annotations,
+        errors_buffer,
+    );
+
     let (constraint_sccs, scc_annotations) = if added_constraints {
         let mut annotations = SccAnnotations::init(&definitions);
 
@@ -510,3 +518,65 @@ fn find_region<'tcx>(
     // so if we don't find what we are looking for there's a bug somwehere.
     bug!("Should have found something!");
 }
+
+/// Identify errors where placeholders illegally reach other regions, and generate
+/// errors stored into `errors_buffer`.
+///
+/// There are two sources of such errors:
+/// 1. A placeholder reaches (possibly transitively) another placeholder.
+/// 2. A placeholder `p` reaches (possibly transitively) an existential `e`,
+///    where `e` has an allowed maximum universe smaller than `p`'s.
+///
+/// There are other potential placeholder errors, but those are detected after
+/// region inference, since it may apply type tests or member constraints that
+/// alter the contents of SCCs and thus can't be detected at this point.
+#[instrument(skip(definitions, sccs, annotations, errors_buffer), level = "debug")]
+fn find_placeholder_mismatch_errors<'tcx>(
+    definitions: &IndexVec<RegionVid, RegionDefinition<'tcx>>,
+    sccs: &Sccs<RegionVid, ConstraintSccIndex>,
+    annotations: &SccAnnotations<'_, '_, RegionTracker>,
+    errors_buffer: &mut RegionErrors<'tcx>,
+) {
+    use NllRegionVariableOrigin::Placeholder;
+    for (rvid, definition) in definitions.iter_enumerated() {
+        let Placeholder(origin_a) = definition.origin else {
+            continue;
+        };
+
+        let scc = sccs.scc(rvid);
+        let annotation = annotations.scc_to_annotation[scc];
+
+        if let Some(existental_that_cannot_name_rvid) =
+            annotation.reaches_existential_that_cannot_name_us()
+        {
+            errors_buffer.push(RegionErrorKind::PlaceholderReachesExistentialThatCannotNameIt {
+                longer_fr: rvid,
+                existental_that_cannot_name_longer: existental_that_cannot_name_rvid,
+                placeholder: origin_a,
+            })
+        }
+
+        let Some(other_placeholder) = annotation.reaches_other_placeholder(rvid) else {
+            trace!("{rvid:?} reaches no other placeholders");
+            continue;
+        };
+
+        debug!(
+            "Placeholder {rvid:?} of SCC {scc:?} reaches other placeholder {other_placeholder:?}"
+        );
+
+        // FIXME SURELY there is a neater way to do this?
+        let Placeholder(origin_b) = definitions[other_placeholder].origin else {
+            unreachable!(
+                "Region {rvid:?}, {other_placeholder:?} should be placeholders but aren't!"
+            );
+        };
+
+        errors_buffer.push(RegionErrorKind::PlaceholderMismatch {
+            rvid_a: rvid,
+            rvid_b: other_placeholder,
+            origin_a,
+            origin_b,
+        });
+    }
+}

compiler/rustc_borrowck/src/nll.rs

@@ -114,10 +114,13 @@ pub(crate) fn compute_regions<'tcx>(
         Rc::clone(&location_map),
     );
 
+    let mut placeholder_errors = RegionErrors::new(infcx.tcx);
+
     let lowered_constraints = compute_sccs_applying_placeholder_outlives_constraints(
         constraints,
         &universal_region_relations,
         infcx,
+        &mut placeholder_errors,
     );
 
     // If requested, emit legacy polonius facts.
@@ -167,9 +170,17 @@ pub(crate) fn compute_regions<'tcx>(
     });
 
     // Solve the region constraints.
-    let (closure_region_requirements, nll_errors) =
+    let (closure_region_requirements, region_inference_errors) =
         regioncx.solve(infcx, body, polonius_output.clone());
 
+    let nll_errors = if region_inference_errors.has_errors().is_some() {
+        debug!("Errors already reported, skipping these: {placeholder_errors:?}");
+        region_inference_errors
+    } else {
+        // Only flag the higher-kinded bounds errors if there are no borrowck errors.
+        placeholder_errors
+    };
+
     if let Some(guar) = nll_errors.has_errors() {
         // Suppress unhelpful extra errors in `infer_opaque_types`.
         infcx.set_tainted_by_errors(guar);

compiler/rustc_borrowck/src/region_infer/mod.rs

@@ -1531,14 +1531,23 @@ impl<'tcx> RegionInferenceContext<'tcx> {
         let longer_fr_scc = self.constraint_sccs.scc(longer_fr);
         debug!("check_bound_universal_region: longer_fr_scc={:?}", longer_fr_scc,);
 
+        // FIXME(amandasystems): This is an inlined version of elements_contained_in, without
+        // placeholders, which are handled separately. Later, when placeholders are removed
+        // from scc_values, this part will just be elements_contained_in():
+        let mut non_placeholder_regions_in = self
+            .scc_values
+            .locations_outlived_by(longer_fr_scc)
+            .map(RegionElement::Location)
+            .chain(
+                self.scc_values
+                    .universal_regions_outlived_by(longer_fr_scc)
+                    .map(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!
-        if let Some(error_element) = self
-            .scc_values
-            .elements_contained_in(longer_fr_scc)
-            .find(|e| *e != RegionElement::PlaceholderRegion(placeholder))
-        {
+        if let Some(error_element) = non_placeholder_regions_in.next() {
             // Stop after the first error, it gets too noisy otherwise, and does not provide more information.
             errors_buffer.push(RegionErrorKind::BoundUniversalRegionError {
                 longer_fr,