Surface yet more trait obligations

Author: estebank

compiler/rustc_borrowck/src/diagnostics/region_errors.rs

@@ -614,6 +614,7 @@ impl<'a, 'tcx> MirBorrowckCtxt<'a, 'tcx> {
         outlived_fr: RegionVid,
     ) {
         let tcx = self.infcx.tcx;
+        debug!(?code);
         let ObligationCauseCode::MethodCallConstraint(ty, call_span) = code else {
             return;
         };
@@ -628,10 +629,12 @@ impl<'a, 'tcx> MirBorrowckCtxt<'a, 'tcx> {
         ) else {
             return;
         };
+        debug!(?instance);
         let def_id = instance.def_id();
         let mut parent = tcx.parent(def_id);
-        match tcx.def_kind(parent) {
-            hir::def::DefKind::Impl { .. } => {}
+        debug!(?def_id, ?parent);
+        let trait_preds = match tcx.def_kind(parent) {
+            hir::def::DefKind::Impl { .. } => &[],
             hir::def::DefKind::Trait => {
                 let Some(ty) = args.get(0).and_then(|arg| arg.as_type()) else {
                     return;
@@ -643,14 +646,18 @@ impl<'a, 'tcx> MirBorrowckCtxt<'a, 'tcx> {
                 if let [def_id] = impls[..] {
                     // The method we have is on the trait, but for `parent` we want to analyze the
                     // relevant impl instead.
+                    let preds = tcx.predicates_of(parent).predicates;
                     parent = def_id;
+                    preds
                 } else {
                     return;
-                };
+                }
             }
             _ => return,
-        }
+        };
+        debug!(?def_id, ?parent);
         let ty = tcx.type_of(parent).instantiate_identity();
+        debug!(?ty);
         if self.to_error_region(outlived_fr) != Some(tcx.lifetimes.re_static) {
             return;
         }
@@ -669,23 +676,17 @@ impl<'a, 'tcx> MirBorrowckCtxt<'a, 'tcx> {
         // ```
         let mut predicates: Vec<Span> = traits::elaborate(
             tcx,
-            tcx.predicates_of(def_id)
-                .predicates
-                .iter()
-                .map(|(p, sp)| (p.as_predicate(), *sp))
-                .chain(
-                    tcx.predicates_of(parent)
-                        .predicates
-                        .iter()
-                        .map(|(p, sp)| (p.as_predicate(), *sp)),
-                ),
+            tcx.predicates_of(def_id).predicates.iter().map(|(p, sp)| (p.as_predicate(), *sp)),
         )
+        .chain(traits::elaborate(
+            tcx,
+            tcx.predicates_of(parent).predicates.iter().map(|(p, sp)| (p.as_predicate(), *sp)),
+        ))
+        .chain(traits::elaborate(tcx, trait_preds.iter().map(|(p, sp)| (p.as_predicate(), *sp))))
         .filter_map(|(pred, pred_span)| {
             if let ty::PredicateKind::Clause(clause) = pred.kind().skip_binder()
                 && let ty::ClauseKind::TypeOutlives(ty::OutlivesPredicate(pred_ty, r)) = clause
-                // Look for `'static` bounds
                 && r.kind() == ty::ReStatic
-                // We only want bounds on `Self`
                 && (self.infcx.can_eq(self.param_env, ty, pred_ty)
                     || matches!(
                         pred_ty.kind(),
@@ -697,6 +698,7 @@ impl<'a, 'tcx> MirBorrowckCtxt<'a, 'tcx> {
             }
         })
         .collect();
+        debug!(?predicates);
 
         // Look at the receiver for `&'static self`, which introduces a `'static` obligation.
         // ```

tests/ui/lifetimes/static-impl-obligation.stderr

@@ -29,9 +29,11 @@ LL |         val.use_self()
    |         `val` escapes the function body here
    |         argument requires that `'a` must outlive `'static`
    |
-note: the `impl` on `dyn t::ObjectTrait` has a `'static` lifetime requirement
-  --> $DIR/static-impl-obligation.rs:216:47
+note: the `impl` on `dyn t::ObjectTrait` has `'static` lifetime requirements
+  --> $DIR/static-impl-obligation.rs:215:31
    |
+LL |     trait MyTrait where Self: 'static {
+   |                               ^^^^^^^
 LL |         fn use_self(&self) -> &() where Self: 'static { panic!() }
    |                                               ^^^^^^^
 
@@ -76,8 +78,10 @@ LL |         fn use_self(&'static self) -> &() { panic!() }
 LL |     impl MyTrait for dyn ObjectTrait {}
    |                          ^^^^^^^^^^^ this has an implicit `'static` lifetime requirement
 note: the `impl` on `(dyn v::ObjectTrait + 'static)` has `'static` lifetime requirements
-  --> $DIR/static-impl-obligation.rs:252:21
+  --> $DIR/static-impl-obligation.rs:251:31
    |
+LL |     trait MyTrait where Self: 'static {
+   |                               ^^^^^^^
 LL |         fn use_self(&'static self) -> &() { panic!() }
    |                     ^^^^^^^^^^^^^
 ...