Don't require lifetime super-bounds on traits apply to trait objects of that trait

compiler/rustc_trait_selection/src/traits/select/confirmation.rs

@@ -439,26 +439,29 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
 
         let upcast_trait_ref = upcast_trait_ref.unwrap();
 
-        // Check supertraits hold
+        // Check supertraits hold. This is so that their associated type bounds
+        // will be checked in the code below.
         for super_trait in tcx
             .super_predicates_of(trait_predicate.def_id())
             .instantiate(tcx, trait_predicate.trait_ref.substs)
             .predicates
             .into_iter()
         {
-            let normalized_super_trait = normalize_with_depth_to(
+            if let ty::PredicateAtom::Trait(..) = super_trait.skip_binders() {
-                self,
+                let normalized_super_trait = normalize_with_depth_to(
-                obligation.param_env,
+                    self,
-                obligation.cause.clone(),
+                    obligation.param_env,
-                obligation.recursion_depth + 1,
+                    obligation.cause.clone(),
-                &super_trait,
+                    obligation.recursion_depth + 1,
-                &mut nested,
+                    &super_trait,
-            );
+                    &mut nested,
-            nested.push(Obligation::new(
+                );
-                obligation.cause.clone(),
+                nested.push(Obligation::new(
-                obligation.param_env.clone(),
+                    obligation.cause.clone(),
-                normalized_super_trait,
+                    obligation.param_env.clone(),
-            ));
+                    normalized_super_trait,
+                ));
+            }
         }
 
         let assoc_types: Vec<_> = tcx

src/test/ui/traits/trait-object-supertrait-lifetime-bound.rs

@@ -0,0 +1,16 @@
+// check-pass
+
+use std::any::Any;
+
+trait A<T>: Any {
+    fn m(&self) {}
+}
+
+impl<S, T: 'static> A<S> for T {}
+
+fn call_obj<'a>() {
+    let obj: &dyn A<&'a ()> = &();
+    obj.m();
+}
+
+fn main() {}