Properly deduce object lifetime defaults in projections & trait refs

compiler/rustc_attr_parsing/src/attributes/rustc_internal.rs

@@ -46,7 +46,14 @@ impl<S: Stage> SingleAttributeParser<S> for RustcObjectLifetimeDefaultParser {
     const PATH: &[rustc_span::Symbol] = &[sym::rustc_object_lifetime_default];
     const ATTRIBUTE_ORDER: AttributeOrder = AttributeOrder::KeepInnermost;
     const ON_DUPLICATE: OnDuplicate<S> = OnDuplicate::Error;
-    const ALLOWED_TARGETS: AllowedTargets = AllowedTargets::AllowList(&[Allow(Target::Struct)]);
+    const ALLOWED_TARGETS: AllowedTargets = AllowedTargets::AllowList(&[
+        Allow(Target::Struct),
+        Allow(Target::Enum),
+        Allow(Target::Union),
+        Allow(Target::Trait),
+        Allow(Target::TyAlias),
+        Allow(Target::AssocTy),
+    ]);
     const TEMPLATE: AttributeTemplate = template!(Word);
 
     fn convert(cx: &mut AcceptContext<'_, '_, S>, args: &ArgParser<'_>) -> Option<AttributeKind> {

compiler/rustc_metadata/src/rmeta/encoder.rs

@@ -1534,7 +1534,7 @@ impl<'a, 'tcx> EncodeContext<'a, 'tcx> {
             if let Some(name) = tcx.intrinsic(def_id) {
                 record!(self.tables.intrinsic[def_id] <- name);
             }
-            if let DefKind::TyParam = def_kind {
+            if let DefKind::TyParam | DefKind::Trait = def_kind {
                 let default = self.tcx.object_lifetime_default(def_id);
                 record!(self.tables.object_lifetime_default[def_id] <- default);
             }

compiler/rustc_passes/src/check_attr.rs

@@ -649,20 +649,18 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
     /// Debugging aid for `object_lifetime_default` query.
     fn check_object_lifetime_default(&self, hir_id: HirId) {
         let tcx = self.tcx;
-        if let Some(owner_id) = hir_id.as_owner()
-            && let Some(generics) = tcx.hir_get_generics(owner_id.def_id)
-        {
-            for p in generics.params {
-                let hir::GenericParamKind::Type { .. } = p.kind else { continue };
-                let default = tcx.object_lifetime_default(p.def_id);
-                let repr = match default {
-                    ObjectLifetimeDefault::Empty => "BaseDefault".to_owned(),
-                    ObjectLifetimeDefault::Static => "'static".to_owned(),
-                    ObjectLifetimeDefault::Param(def_id) => tcx.item_name(def_id).to_string(),
-                    ObjectLifetimeDefault::Ambiguous => "Ambiguous".to_owned(),
-                };
-                tcx.dcx().emit_err(errors::ObjectLifetimeErr { span: p.span, repr });
-            }
+        let Some(owner_id) = hir_id.as_owner() else { return };
+        for param in &tcx.generics_of(owner_id.def_id).own_params {
+            let ty::GenericParamDefKind::Type { .. } = param.kind else { continue };
+            let default = tcx.object_lifetime_default(param.def_id);
+            let repr = match default {
+                ObjectLifetimeDefault::Empty => "Empty".to_owned(),
+                ObjectLifetimeDefault::Static => "'static".to_owned(),
+                ObjectLifetimeDefault::Param(def_id) => tcx.item_name(def_id).to_string(),
+                ObjectLifetimeDefault::Ambiguous => "Ambiguous".to_owned(),
+            };
+            tcx.dcx()
+                .emit_err(errors::ObjectLifetimeErr { span: tcx.def_span(param.def_id), repr });
         }
     }
     /// Checks if `#[collapse_debuginfo]` is applied to a macro.

src/librustdoc/clean/mod.rs

@@ -1968,6 +1968,9 @@ impl<'tcx> ContainerTy<'_, 'tcx> {
         match self {
             Self::Ref(region) => ObjectLifetimeDefault::Arg(region),
             Self::Regular { ty: container, args, arg: index } => {
+                // FIXME(fmease): rustc now also computes ambient object lifetime defaults for
+                //                `AssocTy`s. Re-elide these, too!
+
                 let (DefKind::Struct
                 | DefKind::Union
                 | DefKind::Enum

tests/ui/deriving/issue-89188-gat-hrtb.rs

@@ -1,4 +1,5 @@
-//@ check-pass
+// FIXME(fmease): I've regressed this one since we now reject TypeRelative paths as too complex.
+//@ known-bug: unknown
 
 trait CallWithShim: Sized {
     type Shim<'s>

tests/ui/deriving/issue-89188-gat-hrtb.stderr

@@ -0,0 +1,25 @@
+error[E0228]: the lifetime bound for this object type cannot be deduced from context; please supply an explicit bound
+  --> $DIR/issue-89188-gat-hrtb.rs:27:56
+   |
+LL |         &'s mut T::Shim<dyn for<'t> Fn(&'s mut T::Shim<dyn for<'u> Trait<'s, 't, 'u>>)>,
+   |                                                        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error[E0228]: the lifetime bound for this object type cannot be deduced from context; please supply an explicit bound
+  --> $DIR/issue-89188-gat-hrtb.rs:27:56
+   |
+LL |         &'s mut T::Shim<dyn for<'t> Fn(&'s mut T::Shim<dyn for<'u> Trait<'s, 't, 'u>>)>,
+   |                                                        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
+
+error[E0228]: the lifetime bound for this object type cannot be deduced from context; please supply an explicit bound
+  --> $DIR/issue-89188-gat-hrtb.rs:27:56
+   |
+LL |         &'s mut T::Shim<dyn for<'t> Fn(&'s mut T::Shim<dyn for<'u> Trait<'s, 't, 'u>>)>,
+   |                                                        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
+
+error: aborting due to 3 previous errors
+
+For more information about this error, try `rustc --explain E0228`.

tests/ui/did_you_mean/bad-assoc-ty.edition2015.stderr

@@ -193,20 +193,11 @@ help: if this is a dyn-compatible trait, use `dyn`
 LL | type H = <dyn Fn(u8) -> (u8)>::Output;
    |          ++++               +
 
-error[E0223]: ambiguous associated type
+error[E0228]: the lifetime bound for this object type cannot be deduced from context; please supply an explicit bound
   --> $DIR/bad-assoc-ty.rs:37:10
    |
 LL | type H = Fn(u8) -> (u8)::Output;
-   |          ^^^^^^^^^^^^^^^^^^^^^^
-   |
-help: use fully-qualified syntax
-   |
-LL - type H = Fn(u8) -> (u8)::Output;
-LL + type H = <(dyn Fn(u8) -> u8 + 'static) as BitOr>::Output;
-   |
-LL - type H = Fn(u8) -> (u8)::Output;
-LL + type H = <(dyn Fn(u8) -> u8 + 'static) as IntoFuture>::Output;
-   |
+   |          ^^^^^^^^^^^^^^
 
 error[E0223]: ambiguous associated type
   --> $DIR/bad-assoc-ty.rs:44:19
@@ -310,5 +301,5 @@ LL |     fn foo<F>(_: F) where F: Fn() -> _ {}
 
 error: aborting due to 30 previous errors; 1 warning emitted
 
-Some errors have detailed explanations: E0121, E0223, E0740.
+Some errors have detailed explanations: E0121, E0223, E0228, E0740.
 For more information about an error, try `rustc --explain E0121`.

tests/ui/did_you_mean/bad-assoc-ty.rs

@@ -35,10 +35,10 @@ type G = dyn 'static + (Send)::AssocTy;
 // This is actually a legal path with fn-like generic arguments in the middle!
 // Recovery should not apply in this context.
 type H = Fn(u8) -> (u8)::Output;
-//[edition2015]~^ ERROR ambiguous associated type
+//[edition2021]~^ ERROR expected a type, found a trait
+//[edition2015]~^^ ERROR the lifetime bound for this object type cannot be deduced from context; please supply an explicit bound
 //[edition2015]~| WARN trait objects without an explicit `dyn` are deprecated
 //[edition2015]~| WARN this is accepted in the current edition
-//[edition2021]~^^^^ ERROR expected a type, found a trait
 
 macro_rules! ty {
     ($ty: ty) => ($ty::AssocTy);

tests/ui/object-lifetime/object-lifetime-default-assoc-ty-self-ty-static.rs

@@ -0,0 +1,17 @@
+// Check that we correctly deduce object lifetime defaults inside self types of qualified paths.
+//@ check-pass
+
+trait Outer { type Ty; }
+trait Inner {}
+
+impl<'a> Outer for dyn Inner + 'a { type Ty = &'a (); }
+
+// We deduce `dyn Inner + 'static` from absence of any bounds on self ty param of trait `Outer`.
+//
+// Prior to PR rust-lang/rust#129543, assoc tys weren't considered *eligible generic containers* and
+// thus we'd use the *ambient object lifetime default* induced by the reference type ctor `&`,
+// namely `'r`. Now however, the assoc ty shadows/overwrites that ambient default to `'static`.
+fn f<'r>(x: &'r <dyn Inner as Outer>::Ty) { g(x) }
+fn g<'r>(x: &'r <dyn Inner + 'static as Outer>::Ty) {}
+
+fn main() {}

tests/ui/object-lifetime/object-lifetime-default-assoc-ty-self-ty.rs

@@ -0,0 +1,15 @@
+// Check that we correctly deduce object lifetime defaults inside self types of qualified paths.
+//@ check-pass
+//@ revisions: bound clause
+
+#[cfg(bound)] trait Outer<'a>: 'a { type Ty; }
+#[cfg(clause)] trait Outer<'a> where Self: 'a { type Ty; }
+trait Inner {}
+
+impl<'a> Outer<'a> for dyn Inner + 'a { type Ty = &'a (); }
+
+fn f<'r>(x: <dyn Inner + 'r as Outer<'r>>::Ty) { g(x) }
+// We deduce `dyn Inner + 'r` from bound `'a` on self ty param of trait `Outer`.
+fn g<'r>(x: <dyn Inner as Outer<'r>>::Ty) {}
+
+fn main() {}

tests/ui/object-lifetime/object-lifetime-default-gat-resolved.rs

@@ -0,0 +1,57 @@
+// Check that we correctly deduce object lifetime defaults inside resolved GAT *paths*.
+// issue: <https://github.com/rust-lang/rust/issues/115379>
+//@ check-pass
+
+mod own { // the object lifetime default comes from the own generics
+    trait Outer {
+        type Ty<'a, T: ?Sized + 'a>;
+    }
+    impl Outer for () {
+        type Ty<'a, T: ?Sized + 'a> = &'a T;
+    }
+    trait Inner {}
+
+    fn f<'r>(x: <() as Outer>::Ty<'r, dyn Inner + 'r>) { g(x) }
+    // We deduce `dyn Inner + 'r` from bound `'a` on ty param `T` of assoc ty `Ty`.
+    fn g<'r>(_: <() as Outer>::Ty<'r, dyn Inner>) {}
+}
+
+mod parent { // the object lifetime default comes from the parent generics
+    trait Outer<'a> {
+        type Ty<T: ?Sized + 'a>;
+    }
+    impl<'a> Outer<'a> for () {
+        type Ty<T: ?Sized + 'a> = &'a T;
+    }
+    trait Inner {}
+
+    fn f<'r>(x: <() as Outer<'r>>::Ty<dyn Inner + 'r>) { g(x) }
+    // We deduce `dyn Inner + 'r` from bound `'a` on ty param `T` of assoc ty `Ty`.
+    fn g<'r>(_: <() as Outer<'r>>::Ty<dyn Inner>) {}
+}
+
+mod complex {
+    // We need to perform several delicate index calculations to map between the middle::ty and
+    // the HIR representation of generic args. This is a smoke test.
+
+    trait Outer<'_pad0, 'a, '_pad1, _Pad0> {
+        type Ty<'_pad2, 'b, '_pad3, _Pad1, T: ?Sized + 'a, _Pad2, U: ?Sized + 'b>;
+    }
+    impl<'a, _Pad0> Outer<'_, 'a, '_, _Pad0> for () {
+        type Ty<'_pad2, 'b, '_pad3, _Pad1, T: ?Sized + 'a, _Pad2, U: ?Sized + 'b> = (&'a T, &'b U);
+    }
+    trait Inner {}
+
+    fn f<'r, 's>(
+        x: <() as Outer<'static, 'r, 'static, ()>>::
+            Ty<'static, 's, 'static, (), dyn Inner + 'r, (), dyn Inner + 's>,
+    ) {
+        g(x)
+    }
+    fn g<'r, 's>(
+        _: <() as Outer<'static, 'r, 'static, ()>>::
+            Ty<'static, 's, 'static, (), dyn Inner, (), dyn Inner>,
+    ) {}
+}
+
+fn main() {}

tests/ui/object-lifetime/object-lifetime-default-gat-type-relative.rs

@@ -0,0 +1,10 @@
+trait Outer { type Ty<'a, T: 'a + ?Sized>; }
+trait Inner {}
+
+// FIXME: Ideally, we would deduce `dyn Inner + 'r` from bound `'a` on ty param `T` of assoc ty `Ty`
+//        but for that we'd need to somehow obtain the resolution of the type-relative path `T::Ty`
+//        from HIR ty lowering (it resolves to `<T as Outer>::Ty`).
+fn f<'r, T: Outer>(x: T::Ty<'r, dyn Inner>) {}
+//~^ ERROR lifetime bound for this object type cannot be deduced from context
+
+fn main() {}

tests/ui/object-lifetime/object-lifetime-default-gat-type-relative.stderr

@@ -0,0 +1,9 @@
+error[E0228]: the lifetime bound for this object type cannot be deduced from context; please supply an explicit bound
+  --> $DIR/object-lifetime-default-gat-type-relative.rs:7:33
+   |
+LL | fn f<'r, T: Outer>(x: T::Ty<'r, dyn Inner>) {}
+   |                                 ^^^^^^^^^
+
+error: aborting due to 1 previous error
+
+For more information about this error, try `rustc --explain E0228`.

tests/ui/object-lifetime/object-lifetime-default-trait-ref.rs

@@ -0,0 +1,26 @@
+// Check that we correctly deduce object lifetime defaults inside *trait refs*!
+// For the longest time these examples used to get rejected as "inderminate" due to an off-by-one.
+//@ check-pass
+
+trait Inner {}
+trait Outer<'a, T: 'a + ?Sized> { type Project where Self: Sized; }
+
+fn bound0<'r, T>() where T: Outer<'r, dyn Inner + 'r> { bound1::<'r, T>() }
+// We deduce `dyn Inner + 'r` from bound `'a` on ty param `T` of trait `Outer`.
+fn bound1<'r, T>() where T: Outer<'r, dyn Inner> {}
+
+fn dyn0<'r>(x: Box<dyn Outer<'r, dyn Inner + 'r>>) { dyn1(x) }
+// We deduce `dyn Inner + 'r` from bound `'a` on ty param `T` of trait `Outer`.
+fn dyn1<'r>(_: Box<dyn Outer<'r, dyn Inner>>) {}
+
+fn impl0<'r>(x: impl Outer<'r, dyn Inner + 'r>) { impl1(x) }
+// We deduce `dyn Inner + 'r` from bound `'a` on ty param `T` of trait `Outer`.
+fn impl1<'r>(_: impl Outer<'r, dyn Inner>) {} // deduce `dyn Inner + 'r`
+
+fn proj<'r>(x: <() as Outer<'r, dyn Inner + 'r>>::Project) { proj1(x) }
+// We deduce `dyn Inner + 'r` from bound `'a` on ty param `T` of trait `Outer`.
+fn proj1<'r>(_: <() as Outer<'r, dyn Inner>>::Project) {}
+
+impl<'a, T: 'a + ?Sized> Outer<'a, T> for () { type Project = &'a T; }
+
+fn main() {}

tests/ui/object-lifetime/object-lifetime-default.rs

@@ -2,13 +2,13 @@
 
 #[rustc_object_lifetime_default]
 struct A<
-    T, //~ ERROR BaseDefault
+    T, //~ ERROR Empty
 >(T);
 
 #[rustc_object_lifetime_default]
 struct B<
     'a,
-    T, //~ ERROR BaseDefault
+    T, //~ ERROR Empty
 >(&'a (), T);
 
 #[rustc_object_lifetime_default]
@@ -47,4 +47,12 @@ struct G<
     U: 'a + 'b, //~ ERROR Ambiguous
 >(&'a T, &'b U);
 
+// Check that we also dump the default for the implicit `Self` type param of traits.
+#[rustc_object_lifetime_default]
+trait H< //~ ERROR 'a
+    'a,
+    'b,
+    T: 'b, //~ ERROR 'b
+>: 'a {}
+
 fn main() {}

tests/ui/object-lifetime/object-lifetime-default.stderr

@@ -1,10 +1,10 @@
-error: BaseDefault
+error: Empty
   --> $DIR/object-lifetime-default.rs:5:5
    |
 LL |     T,
    |     ^
 
-error: BaseDefault
+error: Empty
   --> $DIR/object-lifetime-default.rs:11:5
    |
 LL |     T,
@@ -52,5 +52,21 @@ error: Ambiguous
 LL |     U: 'a + 'b,
    |     ^
 
-error: aborting due to 9 previous errors
+error: 'a
+  --> $DIR/object-lifetime-default.rs:52:1
+   |
+LL | / trait H<
+LL | |     'a,
+LL | |     'b,
+LL | |     T: 'b,
+LL | | >: 'a {}
+   | |_____^
+
+error: 'b
+  --> $DIR/object-lifetime-default.rs:55:5
+   |
+LL |     T: 'b,
+   |     ^
+
+error: aborting due to 11 previous errors