Auto merge of rust-lang#129543 - fmease:obj-lt-def-gat, r=<try>

Properly deduce object lifetime defaults in projections & trait refs

#### Object Lifetime Defaults (Primer, Refresher & Definitions)

You can read [this section](https://doc.rust-lang.org/reference/lifetime-elision.html#default-trait-object-lifetimes) in The Reference but it's not perfect IMO. Here's a small explainer by me that only mentions the parts relevant to this PR:

Basically, given `dyn Trait` (≠ `dyn Trait + '_`) we want to deduce its *object lifetime bound* from context (without relying on `rustc_infer`'s region inference as we might not be in a body[^1]). The "context" means the closest — what I call — *eligible generic container* `C<X0, …, Xn>` that wraps this trait object type. *(Eligible generic) container* is almost synonymous with type constructor but it also includes type aliases, traits & enum variants.

So if we have `C<…, dyn Trait, …>` (e.g., `&'r dyn Trait` or `Struct<'r, dyn Trait>`) or `C<…, N<…, dyn Trait, …>, …>` (e.g., `&'r (dyn Trait,)` or `Struct<'r, (dyn Trait,)>`) where `N` denotes a generic type that is **not** an eligible generic container, we use the explicit[^2] outlives-bounds on the corresp. type param of `C` to determine the object lifetime bound (the details[^3] aren't relevant here) (e.g., given `struct Struct<'a, T: 'a + ?Sized>(…);`, we elaborate `Struct<'r, dyn Trait>` to `Struct<'r, dyn Trait + 'r>`).

Lastly, I call object lifetime bounds used as the default for *constituent* trait object types of an eligible generic container `C` the *ambient object lifetime defaults* for / induced by `C` (these ambient defaults may be shadowed by inner containers).

---

#### Changes Made by This PR

1. Make associated type paths / projections *eligible generic containers*.
   * `<Y0 as TraitRef<X0, …, Xn>>::AssocTy<Y1, …, Ym>` now induces *ambient object lifetime defaults* for constituents Y0 to Ym (`TraitRef` is considered a separate container, see also list item **(2)**).
   * Similar case with type-relative ("shorthand") paths `Y0::AssocTy<Y1, …, Ym>`
   * Notably, for the self type Y0 of resolved projections we now look at the bounds on the `Self` type param of the relevant trait (e.g., given `trait Outer<'a>: 'a { type Proj; }` or `trait Outer<'a> where Self: 'a { type Proj; }` we elaborate `<dyn Inner as Outer<'r>>::Proj` to `<dyn Inner + 'r as Outer<'r>>::Proj`).
2. Fixes object lifetime defaults inside trait refs `TraitRef<X0, …, X1>` (this fell out from the previous changes). There used be completely broken due to a gnarly off-by-one error for not accounting for the implicit `Self` type param of traits which leads to cases like
   * `Outer<'r, dyn Inner>` (with `trait Outer<'a, T: 'a + ?Sized> {}`) getting rejected as "inderminate" (it tries to access a *lifetime* at index 1 instead 0) ([playground](https://play.rust-lang.org/?version=stable&mode=debug&edition=2024&gist=0069c89b2313f0f447ff8b6f7de9adfa))
   * `Outer<'r, 's, dyn Inner>` (with `trait Outer<'a, 'b: T: 'a + ?Sized> {}`) elaborating `dyn Inner` to `dyn Inner + 's` instead of `dyn Inner + 'r`(!) ([playground](https://play.rust-lang.org/?version=stable&mode=debug&edition=2024&gist=9c521165e0ac0d868a8087cd7ca861fe))

**These changes are theoretically breaking** because in certain cases they lead to different object lifetime bounds getting deduced compared to master which is obviously user observable. However, [the latest crater run](rust-lang#129543 (comment)) found 0 non-spurious regressions.

**Motivation**: Both object lifetime default RFCs never explicitly specify what constitutes an — what I call — *eligible generic container* but it only makes sense to include any type constructor or (generic) type alias that can bear outlives-bounds … like associated types. So it's only *consistent* to make this change.

Fixes rust-lang#115379.

r? ghost

[^1]: If we *are* in a body, we do however use to normal region inference as a fallback.
[^2]: Indeed, we don't consider implied bounds (inferred outlives-bounds).
[^3]: Like how we deal with 'ambiguities' or how we look at the bounds of inner TOT as a fallback.

Author: bors

compiler/rustc_hir_analysis/src/collect/resolve_bound_vars.rs

@@ -1481,7 +1481,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_metadata/src/rmeta/encoder.rs

@@ -714,20 +714,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 });
         }
     }
 

compiler/rustc_passes/src/check_attr.rs

@@ -1994,6 +1994,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

src/librustdoc/clean/mod.rs

@@ -31,7 +31,7 @@ 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;
-//~^ ERROR ambiguous associated type
+//~^ ERROR the lifetime bound for this object type cannot be deduced from context; please supply an explicit bound
 //~| WARN trait objects without an explicit `dyn` are deprecated
 //~| WARN this is accepted in the current edition
 

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

@@ -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:33: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:39:19
@@ -354,5 +345,5 @@ LL + trait P<F, T> where F: Fn() -> T {
 
 error: aborting due to 29 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.stderr

@@ -0,0 +1,13 @@
+// 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`.
+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-static.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-assoc-ty-self-ty.rs

@@ -0,0 +1,33 @@
+// 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>) {}
+}
+
+fn main() {}

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

@@ -0,0 +1,12 @@
+// Properly deduce the object lifetime default in type-relative generic associated type *paths*.
+// issue: <https://github.com/rust-lang/rust/issues/115379>
+//@ check-pass
+
+trait Outer { type Ty<'a, T: 'a + ?Sized>; }
+trait Inner {}
+
+fn f<'r, T: Outer>(x: T::Ty<'r, dyn Inner + 'r>) { g::<T>(x) }
+// Deduce `dyn Inner + 'r` from bound `'a` on ty param `T` of assoc ty `Ty`
+fn g<'r, T: Outer>(x: T::Ty<'r, dyn Inner>) {}
+
+fn main() {}

tests/ui/object-lifetime/object-lifetime-default-gat-type-relative.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-trait-ref.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.rs

@@ -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