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

[WIP] Properly deduce object lifetime defaults in projections & trait refs

FIXME: Proper explainer (several things fall out of this PR)

Fixes rust-lang#115379.

r? ghost

Author: bors

Diff for: compiler/rustc_hir_analysis/src/collect/resolve_bound_vars.rs

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

Diff for: compiler/rustc_metadata/src/rmeta/encoder.rs

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

Diff for: compiler/rustc_passes/src/check_attr.rs

@@ -1994,6 +1994,8 @@ impl<'tcx> ContainerTy<'_, 'tcx> {
         match self {
             Self::Ref(region) => ObjectLifetimeDefault::Arg(region),
             Self::Regular { ty: container, args, arg: index } => {
+                // FIXME: Update this to handle AssocTys.
+
                 let (DefKind::Struct
                 | DefKind::Union
                 | DefKind::Enum

Diff for: src/librustdoc/clean/mod.rs

@@ -0,0 +1,12 @@
+// FIXME: Explainer.
+//@ check-pass
+
+trait Outer { type Ty; }
+trait Inner {}
+
+impl<'a> Outer for dyn Inner + 'a { type Ty = &'a (); }
+
+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() {}

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

@@ -0,0 +1,14 @@
+// FIXME: Explainer
+//@ check-pass
+
+// FIXME: Test both bound and where-clause form
+// trait Outer<'a> where Self: 'a { type Ty; }
+trait Outer<'a>: '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) }
+fn g<'r>(x: <dyn Inner as Outer<'r>>::Ty) {}
+
+fn main() {}

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

@@ -0,0 +1,31 @@
+// Properly deduce the object lifetime default in generic associated type (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) }
+    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) }
+    fn g<'r>(_: <() as Outer<'r>>::Ty<dyn Inner>) {}
+}
+
+fn main() {}

Diff for: tests/ui/object-lifetime/object-lifetime-default-gat-resolved.rs

@@ -0,0 +1,9 @@
+// FIXME: Explainer
+
+trait Outer { type Ty<'a, T: 'a + ?Sized>; }
+trait Inner {}
+
+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() {}

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

@@ -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:6: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`.

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

@@ -0,0 +1,16 @@
+// FIXME: Explainer (used to fail: "inderminate" due to an off by one :^))
+//@ check-pass
+
+trait Inner {}
+trait Outer<'a, T: 'a + ?Sized> {}
+
+fn bound0<'r, T>() where T: Outer<'r, dyn Inner + 'r> { bound1::<'r, T>() }
+fn bound1<'r, T>() where T: Outer<'r, dyn Inner> {}
+
+fn dyn0<'r>(x: Box<dyn Outer<'r, dyn Inner + 'r>>) { dyn1(x) }
+fn dyn1<'r>(_: Box<dyn Outer<'r, dyn Inner>>) {}
+
+fn impl0<'r>(x: impl Outer<'r, dyn Inner + 'r>) { impl1(x) }
+fn impl1<'r>(_: impl Outer<'r, dyn Inner>) {}
+
+fn main() {}

Diff for: 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]

Diff for: 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,