Satisfy higher-ranked type outlives predicates with ones in the param-env

Author: compiler-errors

compiler/rustc_infer/src/infer/mod.rs

@@ -1049,6 +1049,45 @@ impl<'a, 'tcx> InferCtxt<'a, 'tcx> {
         })
     }
 
+    // Attempts to satisfy a type outlives predicate that is instantiated with
+    // a placeholder by using a higher-ranked type outlives caller bound.
+    pub fn type_outlives_predicate_from_param_env(
+        &self,
+        cause: &traits::ObligationCause<'tcx>,
+        param_env: ty::ParamEnv<'tcx>,
+        ty: Ty<'tcx>,
+        region: ty::Region<'tcx>,
+    ) -> Option<Vec<traits::PredicateObligation<'tcx>>> {
+        // Only attempt to satisfy placeholder-replaced higher-ranked outlives
+        if !region.is_placeholder() {
+            return None;
+        }
+
+        for caller_bound in param_env.caller_bounds() {
+            // Only use WC bounds that are themselves of the form `for<'a> TY: 'a`
+            if let ty::PredicateKind::TypeOutlives(bound_outlives) =
+                caller_bound.kind().skip_binder()
+                && bound_outlives.1.is_late_bound()
+            {
+                if let Ok(obligations) = self.commit_if_ok::<_, TypeError<'_>, _>(|_| {
+                    let ty::OutlivesPredicate(wc_ty, wc_region) = self.replace_bound_vars_with_fresh_vars(
+                        cause.span,
+                        LateBoundRegionConversionTime::HigherRankedType,
+                        caller_bound.kind().rebind(bound_outlives),
+                    );
+                    let t = self.at(cause, param_env).sub(wc_ty, ty)?;
+                    let mut r = self.at(cause, param_env).eq(wc_region, region)?;
+                    r.obligations.extend(t.into_obligations());
+                    Ok(r.obligations)
+                }) {
+                    return Some(obligations);
+                }
+            }
+        }
+
+        None
+    }
+
     /// Number of type variables created so far.
     pub fn num_ty_vars(&self) -> usize {
         self.inner.borrow_mut().type_variables().num_vars()

compiler/rustc_trait_selection/src/traits/fulfill.rs

@@ -432,13 +432,17 @@ impl<'a, 'b, 'tcx> FulfillProcessor<'a, 'b, 'tcx> {
                     }
                 }
 
-                ty::PredicateKind::TypeOutlives(ty::OutlivesPredicate(t_a, r_b)) => {
+                ty::PredicateKind::TypeOutlives(ty::OutlivesPredicate(t_a, r_a)) => {
                     if self.register_region_obligations {
-                        self.selcx.infcx().register_region_obligation_with_cause(
-                            t_a,
-                            r_b,
+                        if let Some(obligations) = infcx.type_outlives_predicate_from_param_env(
                             &obligation.cause,
-                        );
+                            obligation.param_env,
+                            t_a,
+                            r_a,
+                        ) {
+                            return ProcessResult::Changed(mk_pending(obligations));
+                        }
+                        infcx.register_region_obligation_with_cause(t_a, r_a, &obligation.cause);
                     }
                     ProcessResult::Changed(vec![])
                 }

src/test/ui/generic-associated-types/issue-86483.rs

@@ -2,13 +2,12 @@
 
 #![feature(generic_associated_types)]
 
-pub trait IceIce<T> //~ ERROR: the parameter type `T` may not live long enough
+pub trait IceIce<T>
 where
     for<'a> T: 'a,
 {
     type Ice<'v>: IntoIterator<Item = &'v T>;
     //~^ ERROR: the parameter type `T` may not live long enough
-    //~| ERROR: the parameter type `T` may not live long enough
 }
 
 fn main() {}

src/test/ui/generic-associated-types/issue-86483.stderr

@@ -1,42 +1,3 @@
-error[E0311]: the parameter type `T` may not live long enough
-  --> $DIR/issue-86483.rs:5:1
-   |
-LL | / pub trait IceIce<T>
-LL | | where
-LL | |     for<'a> T: 'a,
-LL | | {
-...  |
-LL | |
-LL | | }
-   | |_^
-   |
-   = note: ...so that the type `T` will meet its required lifetime bounds...
-note: ...that is required by this bound
-  --> $DIR/issue-86483.rs:7:16
-   |
-LL |     for<'a> T: 'a,
-   |                ^^
-help: consider adding an explicit lifetime bound...
-   |
-LL |     for<'a> T: 'a + 'a,
-   |                   ++++
-
-error[E0311]: the parameter type `T` may not live long enough
-  --> $DIR/issue-86483.rs:9:5
-   |
-LL |     type Ice<'v>: IntoIterator<Item = &'v T>;
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ...so that the type `T` will meet its required lifetime bounds...
-   |
-note: ...that is required by this bound
-  --> $DIR/issue-86483.rs:7:16
-   |
-LL |     for<'a> T: 'a,
-   |                ^^
-help: consider adding an explicit lifetime bound...
-   |
-LL |     for<'a> T: 'a + 'a,
-   |                   ++++
-
 error[E0309]: the parameter type `T` may not live long enough
   --> $DIR/issue-86483.rs:9:32
    |
@@ -45,6 +6,6 @@ LL |     type Ice<'v>: IntoIterator<Item = &'v T>;
    |                                |
    |                                ...so that the reference type `&'v T` does not outlive the data it points at
 
-error: aborting due to 3 previous errors
+error: aborting due to previous error
 
 For more information about this error, try `rustc --explain E0309`.

src/test/ui/generic-associated-types/issue-88360.rs

@@ -13,7 +13,7 @@ where
 {
     fn copy(&self) -> Self::Gat<'_> where T: Copy {
         *self.test()
-        //~^ mismatched types
+        //~^ ERROR mismatched types
     }
 }
 

src/test/ui/higher-rank-trait-bounds/issue-88586-hr-self-outlives-in-trait-def.rs

@@ -1,10 +1,9 @@
+// check-pass
+
 // Regression test for #88586: a higher-ranked outlives bound on Self in a trait
 // definition caused an ICE when debug_assertions were enabled.
-//
-// FIXME: The error output in the absence of the ICE is unhelpful; this should be improved.
 
 trait A where for<'a> Self: 'a
-//~^ ERROR the parameter type `Self` may not live long enough
 {
 }
 

src/test/ui/higher-rank-trait-bounds/issue-88586-hr-self-outlives-in-trait-def.stderr

@@ -0,0 +1,11 @@
+// check-pass
+
+fn test<T, F, U>(f: F) -> Box<dyn Fn(T) -> U + 'static>
+where
+    F: 'static + Fn(T) -> U,
+    for<'a> U: 'a, // < This is the problematic line -- remove it, and it passes.
+{
+    Box::new(move |t| f(t))
+}
+
+fn main() {}