in opaque type handling lift region vars to static if they outlive placeholders

Author: BoxyUwU

compiler/rustc_borrowck/src/handle_placeholders.rs

@@ -344,7 +344,7 @@ pub(crate) fn compute_sccs_applying_placeholder_outlives_constraints<'tcx>(
     }
 }
 
-fn rewrite_placeholder_outlives<'tcx>(
+pub(crate) fn rewrite_placeholder_outlives<'tcx>(
     sccs: &Sccs<RegionVid, ConstraintSccIndex>,
     annotations: &SccAnnotations<'_, '_, RegionTracker>,
     fr_static: RegionVid,

compiler/rustc_borrowck/src/region_infer/opaque_types/member_constraints.rs

@@ -39,7 +39,7 @@ pub(super) fn apply_member_constraints<'tcx>(
     debug!(?member_constraints);
     for scc_a in rcx.constraint_sccs.all_sccs() {
         debug!(?scc_a);
-        // Start by  adding the region values required by outlives constraints. This
+        // Start by adding the region values required by outlives constraints. This
         // matches how we compute the final region values in `fn compute_regions`.
         //
         // We need to do this here to get a lower bound when applying member constraints.
@@ -64,6 +64,7 @@ fn apply_member_constraint<'tcx>(
     // If the member region lives in a higher universe, we currently choose
     // the most conservative option by leaving it unchanged.
     if !rcx.max_placeholder_universe_reached(member).is_root() {
+        debug!("member region reached non root universe, bailing");
         return;
     }
 

compiler/rustc_borrowck/src/region_infer/opaque_types/mod.rs

@@ -253,6 +253,10 @@ fn collect_defining_uses<'tcx>(
                 }
             } else {
                 errors.push(DeferredOpaqueTypeError::InvalidOpaqueTypeArgs(err));
+                debug!(
+                    "collect_defining_uses: InvalidOpaqueTypeArgs for {:?} := {:?}",
+                    non_nll_opaque_type_key, hidden_type
+                );
             }
             continue;
         }
@@ -286,26 +290,31 @@ fn compute_definition_site_hidden_types_from_defining_uses<'tcx>(
     let tcx = infcx.tcx;
     let mut decls_modulo_regions: FxIndexMap<OpaqueTypeKey<'tcx>, (OpaqueTypeKey<'tcx>, Span)> =
         FxIndexMap::default();
-    for &DefiningUse { opaque_type_key, ref arg_regions, hidden_type } in defining_uses {
+    for this_use @ &DefiningUse { opaque_type_key, ref arg_regions, hidden_type } in defining_uses {
         // After applying member constraints, we now map all regions in the hidden type
         // to the `arg_regions` of this defining use. In case a region in the hidden type
         // ended up not being equal to any such region, we error.
-        let hidden_type =
-            match hidden_type.try_fold_with(&mut ToArgRegionsFolder::new(rcx, arg_regions)) {
-                Ok(hidden_type) => hidden_type,
-                Err(r) => {
-                    errors.push(DeferredOpaqueTypeError::UnexpectedHiddenRegion {
-                        hidden_type,
-                        opaque_type_key,
-                        member_region: ty::Region::new_var(tcx, r),
-                    });
-                    let guar = tcx.dcx().span_delayed_bug(
-                        hidden_type.span,
-                        "opaque type with non-universal region args",
-                    );
-                    ty::OpaqueHiddenType::new_error(tcx, guar)
-                }
-            };
+        let hidden_type = match hidden_type
+            .try_fold_with(&mut ToArgRegionsFolder::new(rcx, arg_regions))
+        {
+            Ok(hidden_type) => hidden_type,
+            Err(r) => {
+                errors.push(DeferredOpaqueTypeError::UnexpectedHiddenRegion {
+                    hidden_type,
+                    opaque_type_key,
+                    member_region: ty::Region::new_var(tcx, r),
+                });
+                debug!(
+                    "compute_definition_site_hidden_types_from_defining_use: UnexpectedHiddenRegion for {:?}",
+                    this_use,
+                );
+                let guar = tcx.dcx().span_delayed_bug(
+                    hidden_type.span,
+                    "opaque type with non-universal region args",
+                );
+                ty::OpaqueHiddenType::new_error(tcx, guar)
+            }
+        };
 
         // Now that we mapped the member regions to their final value,
         // map the arguments of the opaque type key back to the parameters

compiler/rustc_borrowck/src/region_infer/opaque_types/region_ctxt.rs

@@ -11,7 +11,7 @@ use crate::constraints::ConstraintSccIndex;
 use crate::handle_placeholders::{SccAnnotations, region_definitions};
 use crate::region_infer::reverse_sccs::ReverseSccGraph;
 use crate::region_infer::values::RegionValues;
-use crate::region_infer::{ConstraintSccs, RegionDefinition, RegionTracker, Representative};
+use crate::region_infer::{OutlivesConstraintSet, ConstraintSccs, RegionDefinition, RegionTracker, Representative};
 use crate::type_check::MirTypeckRegionConstraints;
 use crate::type_check::free_region_relations::UniversalRegionRelations;
 use crate::universal_regions::UniversalRegions;
@@ -39,16 +39,36 @@ impl<'a, 'tcx> RegionCtxt<'a, 'tcx> {
         location_map: Rc<DenseLocationMap>,
         constraints: &MirTypeckRegionConstraints<'tcx>,
     ) -> RegionCtxt<'a, 'tcx> {
+        let mut outlives_constraints = constraints.outlives_constraints.clone();
         let universal_regions = &universal_region_relations.universal_regions;
         let (definitions, _has_placeholders) = region_definitions(infcx, universal_regions);
+
+        let compute_sccs =
+            |outlives_constraints: &OutlivesConstraintSet<'tcx>,
+             annotations: &mut SccAnnotations<'_, 'tcx, RegionTracker>| {
+                ConstraintSccs::new_with_annotation(
+                    &outlives_constraints
+                        .graph(definitions.len())
+                        .region_graph(outlives_constraints, universal_regions.fr_static),
+                    annotations,
+                )
+            };
+
         let mut scc_annotations = SccAnnotations::init(&definitions);
-        let constraint_sccs = ConstraintSccs::new_with_annotation(
-            &constraints
-                .outlives_constraints
-                .graph(definitions.len())
-                .region_graph(&constraints.outlives_constraints, universal_regions.fr_static),
-            &mut scc_annotations,
+        let mut constraint_sccs = compute_sccs(&outlives_constraints, &mut scc_annotations);
+        
+        let added_constraints = crate::handle_placeholders::rewrite_placeholder_outlives(
+            &constraint_sccs,
+            &scc_annotations,
+            universal_regions.fr_static,
+            &mut outlives_constraints,
         );
+        
+        if added_constraints {
+            scc_annotations = SccAnnotations::init(&definitions);
+            constraint_sccs = compute_sccs(&outlives_constraints, &mut scc_annotations);
+        }
+        
         let scc_annotations = scc_annotations.scc_to_annotation;
 
         // Unlike the `RegionInferenceContext`, we only care about free regions

tests/ui/impl-trait/member-constraints/placeholders_lift_to_static.rs

@@ -0,0 +1,19 @@
+//@ check-pass
+
+// We have some `RPIT` with an item bound of `for<'a> Outlives<'a>`. We
+// infer a hidden type of `&'?x i32` where `'?x` is required to outlive
+// some placeholder `'!a` due to the `for<'a> Outlives<'a>` item bound.
+//
+// We previously did not write constraints of the form `'?x: '!a` into
+// `'?x: 'static`. This caused member constraints to bail and not consider
+// `'?x` to be constrained to an arg region.
+
+pub trait Outlives<'a> {}
+impl<'a, T: 'a> Outlives<'a> for T {}
+
+pub fn foo() -> impl for<'a> Outlives<'a> {
+    let x: &'static i32 = &1;
+    x
+}
+
+fn main() {}