WIP

Author: amandasystems

compiler/rustc_borrowck/src/diagnostics/region_errors.rs

@@ -120,9 +120,31 @@ pub(crate) enum RegionErrorKind<'tcx> {
         member_region: ty::Region<'tcx>,
     },
 
+    /// 'a outlives 'b, and both are placeholders.
+    PlaceholderOutlivesPlaceholder {
+        rvid_a: RegionVid,
+        rvid_b: RegionVid,
+        origin_a: ty::PlaceholderRegion,
+        origin_b: ty::PlaceholderRegion,
+    },
+
+    /// Indicates that a placeholder has a universe too large for one
+    /// of its member existentials, or, equivalently, that there is
+    /// a path through the outlives constraint graph from a placeholder
+    /// to an existential region that cannot name it.
+    PlaceholderOutlivesExistentialThatCannotNameIt {
+        /// the placeholder that transitively outlives an
+        /// existential that shouldn't leak into it
+        longer_fr: RegionVid,
+        /// The existential leaking into `longer_fr`.
+        existental_that_cannot_name_longer: RegionVid,
+        // `longer_fr`'s originating placeholder region.
+        placeholder: ty::PlaceholderRegion,
+    },
+
     /// Higher-ranked subtyping error. A placeholder outlives
     /// either a location or a universal region.
-    BoundUniversalRegionError {
+    PlaceholderOutlivesLocationOrUniversal {
         /// The placeholder free region.
         longer_fr: RegionVid,
         /// The region element that erroneously must be outlived by `longer_fr`.
@@ -389,7 +411,7 @@ impl<'infcx, 'tcx> MirBorrowckCtxt<'_, 'infcx, 'tcx> {
                     }
                 }
 
-                RegionErrorKind::BoundUniversalRegionError {
+                RegionErrorKind::PlaceholderOutlivesLocationOrUniversal {
                     longer_fr,
                     placeholder,
                     error_element,
@@ -412,6 +434,46 @@ impl<'infcx, 'tcx> MirBorrowckCtxt<'_, 'infcx, 'tcx> {
 
                     universe_info.report_erroneous_element(self, placeholder, error_element, cause);
                 }
+                RegionErrorKind::PlaceholderOutlivesPlaceholder {
+                    rvid_a,
+                    rvid_b,
+                    origin_a,
+                    origin_b,
+                } => {
+                    debug!(
+                        "Placeholder mismatch: {rvid_a:?} ({origin_a:?}) reaches {rvid_b:?} ({origin_b:?})"
+                    );
+
+                    let cause = self
+                        .regioncx
+                        .best_blame_constraint(
+                            rvid_a,
+                            NllRegionVariableOrigin::Placeholder(origin_a),
+                            rvid_b,
+                        )
+                        .0
+                        .cause;
+
+                    // FIXME We may be able to shorten the code path here, and immediately
+                    // report a `RegionResolutionError::UpperBoundUniverseConflict`, but
+                    // that's left for a future refactoring.
+                    self.regioncx.universe_info(origin_a.universe).report_erroneous_element(
+                        self,
+                        origin_a,
+                        Some(origin_b),
+                        cause,
+                    );
+                }
+
+                RegionErrorKind::PlaceholderOutlivesExistentialThatCannotNameIt {
+                    longer_fr,
+                    existental_that_cannot_name_longer,
+                    placeholder,
+                } => self.report_erroneous_rvid_reaches_placeholder(
+                    longer_fr,
+                    placeholder,
+                    existental_that_cannot_name_longer,
+                ),
 
                 RegionErrorKind::RegionError { fr_origin, longer_fr, shorter_fr, is_reported } => {
                     if is_reported {

compiler/rustc_borrowck/src/handle_placeholders.rs

@@ -181,6 +181,43 @@ impl RegionTracker {
 
         Some((max_u_rvid, max_u))
     }
+
+    /// Check for the second and final type of placeholder leak,
+    /// where a placeholder `'p` outlives (transitively) an existential `'e`
+    /// and `'e` cannot name `'p`. This is sort of a dual of `unnameable_placeholder`;
+    /// one of the members of this SCC cannot be named by the SCC.
+    ///
+    /// Returns *a* culprit (though there may be more than one).
+    fn reaches_existential_that_cannot_name_us(&self) -> Option<RegionVid> {
+        let Representative::Placeholder(_p) = self.representative else {
+            return None;
+        };
+
+        let (reachable_lowest_max_u, reachable_lowest_max_u_rvid) = self.max_nameable_universe;
+
+        (!self.reachable_placeholders.can_be_named_by(reachable_lowest_max_u))
+            .then_some(reachable_lowest_max_u_rvid)
+    }
+
+    /// Determine if this SCC reaches a placeholder that isn't `placeholder_rvid`,
+    /// returning it if that is the case. This prefers the placeholder with the
+    /// smallest region variable ID.
+    fn reaches_other_placeholder(&self, placeholder_rvid: RegionVid) -> Option<RegionVid> {
+        match self.reachable_placeholders {
+            PlaceholderReachability::NoPlaceholders => None,
+            PlaceholderReachability::Placeholders { min_placeholder, max_placeholder, .. }
+                if min_placeholder == max_placeholder =>
+            {
+                None
+            }
+            PlaceholderReachability::Placeholders { min_placeholder, max_placeholder, .. }
+                if min_placeholder == placeholder_rvid =>
+            {
+                Some(max_placeholder)
+            }
+            PlaceholderReachability::Placeholders { min_placeholder, .. } => Some(min_placeholder),
+        }
+    }
 }
 /// Pick the smallest universe index out of two, preferring
 /// the first argument if they are equal.
@@ -549,7 +586,7 @@ fn find_placeholder_mismatch_errors<'tcx>(
         if let Some(existental_that_cannot_name_rvid) =
             annotation.reaches_existential_that_cannot_name_us()
         {
-            errors_buffer.push(RegionErrorKind::PlaceholderReachesExistentialThatCannotNameIt {
+            errors_buffer.push(RegionErrorKind::PlaceholderOutlivesExistentialThatCannotNameIt {
                 longer_fr: rvid,
                 existental_that_cannot_name_longer: existental_that_cannot_name_rvid,
                 placeholder: origin_a,
@@ -572,7 +609,7 @@ fn find_placeholder_mismatch_errors<'tcx>(
             );
         };
 
-        errors_buffer.push(RegionErrorKind::PlaceholderMismatch {
+        errors_buffer.push(RegionErrorKind::PlaceholderOutlivesPlaceholder {
             rvid_a: rvid,
             rvid_b: other_placeholder,
             origin_a,

compiler/rustc_borrowck/src/region_infer/mod.rs

@@ -1549,7 +1549,7 @@ impl<'tcx> RegionInferenceContext<'tcx> {
         // else about it!
         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 {
+            errors_buffer.push(RegionErrorKind::PlaceholderOutlivesLocationOrUniversal {
                 longer_fr,
                 error_element,
                 placeholder,