Provide more detail on lifetime failure of trait object in field type

```
error[E0478]: lifetime bound not satisfied
   --> tests/ui/lifetimes/point-at-lifetime-obligation-from-trait-in-trait-object.rs:4:21
    |
4   |     broken: Box<dyn Any + 'a>
    |                     ^^^   ^^
    |
note: lifetime parameter instantiated with the lifetime `'a` as defined here
   --> tests/ui/lifetimes/point-at-lifetime-obligation-from-trait-in-trait-object.rs:3:18
    |
3   | struct Something<'a> {
    |                  ^^
    = note: but lifetime parameter must outlive the static lifetime
note: unmet `'static` obligations introduced here
   --> rust/library/core/src/any.rs:115:16
    |
115 | pub trait Any: 'static {
    |                ^^^^^^^
```

Fix #83325.

Author: estebank

compiler/rustc_infer/src/infer/error_reporting/mod.rs

@@ -53,12 +53,13 @@ use crate::errors::{self, ObligationCauseFailureCode, TypeErrorAdditionalDiags};
 use crate::infer;
 use crate::infer::error_reporting::nice_region_error::find_anon_type::find_anon_type;
 use crate::infer::ExpectedFound;
+use crate::traits::util::elaborate;
 use crate::traits::{
     IfExpressionCause, MatchExpressionArmCause, ObligationCause, ObligationCauseCode,
     PredicateObligation,
 };
 
-use rustc_data_structures::fx::{FxIndexMap, FxIndexSet};
+use rustc_data_structures::fx::{FxHashSet, FxIndexMap, FxIndexSet};
 use rustc_errors::{
     codes::*, pluralize, struct_span_code_err, Applicability, Diag, DiagCtxt, DiagStyledString,
     ErrorGuaranteed, IntoDiagnosticArg, MultiSpan,
@@ -458,11 +459,32 @@ impl<'tcx> TypeErrCtxt<'_, 'tcx> {
                     // the error. If all of these fails, we fall back to a rather
                     // general bit of code that displays the error information
                     RegionResolutionError::ConcreteFailure(origin, sub, sup) => {
+                        let extra_info = self.find_trait_object_relate_failure_reason(
+                            generic_param_scope,
+                            &origin,
+                            sub,
+                            sup,
+                        );
                         let mut err = if sub.is_placeholder() || sup.is_placeholder() {
                             self.report_placeholder_failure(origin, sub, sup)
                         } else {
                             self.report_concrete_failure(origin, sub, sup)
                         };
+                        if let Some((primary_spans, relevant_bindings)) = extra_info {
+                            if primary_spans.has_primary_spans() {
+                                // We shorten the span from the whole field type to only the traits
+                                // and lifetime bound that failed.
+                                err.span(primary_spans);
+                            }
+                            if relevant_bindings.has_primary_spans() {
+                                // Point at all the trait obligations for the lifetime that
+                                // couldn't be met.
+                                err.span_note(
+                                    relevant_bindings,
+                                    format!("unmet `{sub}` obligations introduced here"),
+                                );
+                            }
+                        }
                         if let hir::def::DefKind::Impl { .. } =
                             self.tcx.def_kind(generic_param_scope)
                             && let Some(def_id) =
@@ -471,28 +493,36 @@ impl<'tcx> TypeErrCtxt<'_, 'tcx> {
                             // Collect all the `Span`s corresponding to the predicates introducing
                             // the `sub` lifetime that couldn't be met (sometimes `'static`) on
                             // both the `trait` and the `impl`.
-                            let spans: Vec<Span> = self
-                                .tcx
-                                .predicates_of(def_id)
-                                .predicates
-                                .iter()
-                                .chain(
-                                    self.tcx.predicates_of(generic_param_scope).predicates.iter(),
-                                )
-                                .filter_map(|(pred, span)| {
-                                    if let Some(ty::ClauseKind::TypeOutlives(
-                                        ty::OutlivesPredicate(pred_ty, r),
-                                    )) = pred.kind().no_bound_vars()
-                                        && r == sub
-                                        && let ty::Param(param) = pred_ty.kind()
-                                        && param.name == kw::SelfUpper
-                                    {
-                                        Some(*span)
-                                    } else {
-                                        None
-                                    }
-                                })
-                                .collect();
+                            let spans: Vec<Span> = elaborate(
+                                self.tcx,
+                                self.tcx
+                                    .predicates_of(def_id)
+                                    .predicates
+                                    .iter()
+                                    .map(|(p, sp)| (p.as_predicate(), *sp)),
+                            )
+                            .chain(elaborate(
+                                self.tcx,
+                                self.tcx
+                                    .predicates_of(generic_param_scope)
+                                    .predicates
+                                    .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
+                                    && r.kind() == ty::ReStatic
+                                {
+                                    Some(pred_span)
+                                } else {
+                                    None
+                                }
+                            })
+                            .collect();
 
                             if !spans.is_empty() {
                                 let spans_len = spans.len();
@@ -2666,6 +2696,102 @@ impl<'tcx> TypeErrCtxt<'_, 'tcx> {
         if sub_region.is_error() | sup_region.is_error() { err.delay_as_bug() } else { err.emit() }
     }
 
+    /// If a field on a struct has a trait object with lifetime requirement that can't be satisfied
+    /// by one of the traits in the trait object, shorten the span from the whole field type to only
+    /// the relevant traits and the lifetime. We also collect the spans for the places where the
+    /// traits' obligations were introduced.
+    fn find_trait_object_relate_failure_reason(
+        &self,
+        generic_param_scope: LocalDefId,
+        origin: &SubregionOrigin<'tcx>,
+        sub: ty::Region<'tcx>,
+        sup: ty::Region<'tcx>,
+    ) -> Option<(MultiSpan, MultiSpan)> {
+        let infer::RelateRegionParamBound(span) = origin else {
+            return None;
+        };
+        let Some(hir::Node::Item(hir::Item { kind: hir::ItemKind::Struct(item, _), .. })) =
+            self.tcx.hir().get_if_local(generic_param_scope.into())
+        else {
+            return None;
+        };
+        /// Collect all `hir::Ty<'_>` `Span`s for trait objects with the sup lifetime.
+        pub struct HirTraitObjectVisitor<'tcx>(
+            pub Vec<&'tcx hir::PolyTraitRef<'tcx>>,
+            pub ty::Region<'tcx>,
+            pub FxHashSet<Span>,
+        );
+        impl<'tcx> Visitor<'tcx> for HirTraitObjectVisitor<'tcx> {
+            fn visit_ty(&mut self, t: &'tcx hir::Ty<'tcx>) {
+                // Find all the trait objects that have the lifetime that was found.
+                if let hir::TyKind::TraitObject(poly_trait_refs, lt, _) = t.kind
+                    && match (lt.res, self.1.kind()) {
+                        (
+                            hir::LifetimeName::ImplicitObjectLifetimeDefault
+                            | hir::LifetimeName::Static,
+                            ty::RegionKind::ReStatic,
+                        ) => true,
+                        (hir::LifetimeName::Param(a), ty::RegionKind::ReEarlyParam(b)) => {
+                            a.to_def_id() == b.def_id
+                        }
+                        _ => false,
+                    }
+                {
+                    for ptr in poly_trait_refs {
+                        // We'll filter the traits later, after collection.
+                        self.0.push(ptr);
+                    }
+                    // We want to keep a span to the lifetime bound on the trait object.
+                    self.2.insert(lt.ident.span);
+                }
+                hir::intravisit::walk_ty(self, t);
+            }
+        }
+        let mut visitor = HirTraitObjectVisitor(vec![], sup, Default::default());
+        for field in item.fields() {
+            if field.ty.span == *span {
+                // `span` points at the type of a field, we only want to look for trait objects in
+                // the field that failed.
+                visitor.visit_ty(field.ty);
+            }
+        }
+
+        // The display of these spans will not change regardless or sorting.
+        #[allow(rustc::potential_query_instability)]
+        let mut primary_spans: Vec<Span> = visitor.2.into_iter().collect();
+        let mut relevant_bindings: Vec<Span> = vec![];
+        for ptr in visitor.0 {
+            if let Some(def_id) = ptr.trait_ref.trait_def_id() {
+                // Find the bounds on the trait with the lifetime that couldn't be met.
+                let bindings: Vec<Span> = elaborate(
+                    self.tcx,
+                    self.tcx
+                        .predicates_of(def_id)
+                        .predicates
+                        .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
+                        && r == sub
+                    {
+                        Some(pred_span)
+                    } else {
+                        None
+                    }
+                })
+                .collect();
+                if !bindings.is_empty() {
+                    primary_spans.push(ptr.span);
+                    relevant_bindings.extend(bindings);
+                }
+            }
+        }
+        Some((primary_spans.into(), relevant_bindings.into()))
+    }
+
     /// Determine whether an error associated with the given span and definition
     /// should be treated as being caused by the implicit `From` conversion
     /// within `?` desugaring.

tests/ui/error-codes/E0478.stderr

@@ -1,8 +1,8 @@
 error[E0478]: lifetime bound not satisfied
-  --> $DIR/E0478.rs:4:12
+  --> $DIR/E0478.rs:4:37
    |
 LL |     child: Box<dyn Wedding<'kiss> + 'SnowWhite>,
-   |            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |                                     ^^^^^^^^^^
    |
 note: lifetime parameter instantiated with the lifetime `'SnowWhite` as defined here
   --> $DIR/E0478.rs:3:22

tests/ui/lifetimes/point-at-lifetime-obligation-from-trait-in-trait-object.rs

@@ -0,0 +1,6 @@
+use std::any::Any;
+
+struct Something<'a> {
+    broken: Box<dyn Any + 'a> //~ ERROR lifetime bound not satisfied
+}
+fn main() {}

tests/ui/lifetimes/point-at-lifetime-obligation-from-trait-in-trait-object.stderr

@@ -0,0 +1,18 @@
+error[E0478]: lifetime bound not satisfied
+  --> $DIR/point-at-lifetime-obligation-from-trait-in-trait-object.rs:4:21
+   |
+LL |     broken: Box<dyn Any + 'a>
+   |                     ^^^   ^^
+   |
+note: lifetime parameter instantiated with the lifetime `'a` as defined here
+  --> $DIR/point-at-lifetime-obligation-from-trait-in-trait-object.rs:3:18
+   |
+LL | struct Something<'a> {
+   |                  ^^
+   = note: but lifetime parameter must outlive the static lifetime
+note: unmet `'static` obligations introduced here
+  --> $SRC_DIR/core/src/any.rs:LL:COL
+
+error: aborting due to 1 previous error
+
+For more information about this error, try `rustc --explain E0478`.

tests/ui/regions/region-bounds-on-objects-and-type-parameters.stderr

@@ -5,10 +5,10 @@ LL |     z: Box<dyn Is<'a>+'b+'c>,
    |                          ^^
 
 error[E0478]: lifetime bound not satisfied
-  --> $DIR/region-bounds-on-objects-and-type-parameters.rs:21:8
+  --> $DIR/region-bounds-on-objects-and-type-parameters.rs:21:23
    |
 LL |     z: Box<dyn Is<'a>+'b+'c>,
-   |        ^^^^^^^^^^^^^^^^^^^^^
+   |                       ^^
    |
 note: lifetime parameter instantiated with the lifetime `'b` as defined here
   --> $DIR/region-bounds-on-objects-and-type-parameters.rs:11:15

tests/ui/regions/regions-wf-trait-object.stderr

@@ -1,8 +1,8 @@
 error[E0478]: lifetime bound not satisfied
-  --> $DIR/regions-wf-trait-object.rs:7:8
+  --> $DIR/regions-wf-trait-object.rs:7:29
    |
 LL |     x: Box<dyn TheTrait<'a>+'b>
-   |        ^^^^^^^^^^^^^^^^^^^^^^^^
+   |                             ^^
    |
 note: lifetime parameter instantiated with the lifetime `'b` as defined here
   --> $DIR/regions-wf-trait-object.rs:6:15