Propagate the object lifetime default of GAT's own params

Notably, this excludes the self ty.

Author: fmease

compiler/rustc_hir_analysis/src/collect/resolve_bound_vars.rs

@@ -887,11 +887,37 @@ impl<'a, 'tcx> Visitor<'tcx> for BoundVarContext<'a, 'tcx> {
         }
     }
 
+    fn visit_qpath(&mut self, qpath: &'tcx hir::QPath<'tcx>, id: HirId, _: Span) {
+        match qpath {
+            hir::QPath::Resolved(maybe_qself, path) => {
+                if let Some(qself) = maybe_qself {
+                    // FIXME: Temporary -- actually resolve OLD and get ResolvedArg for OLD
+                    let scope = Scope::ObjectLifetimeDefault { lifetime: None, s: self.scope };
+                    self.with(scope, |this| this.visit_ty_unambig(qself));
+                }
+                self.visit_path(path, id)
+            }
+            hir::QPath::TypeRelative(qself, segment) => {
+                // Resolving object lifetime defaults for type-relative paths requires type-dependent
+                // resolution which we don't do here.
+                // FIXME: How feasible would it be to track type-dependent defs here in RBVs?
+                let scope = Scope::ObjectLifetimeDefault { lifetime: None, s: self.scope };
+                self.with(scope, |this| {
+                    this.visit_ty_unambig(qself);
+                    this.visit_path_segment(segment)
+                });
+            }
+            hir::QPath::LangItem(..) => {}
+        }
+    }
+
+    // FIXME: We need to overwrite `visit_qself` to properly handle qselves:
+    //        We need to intro a fresh Scope::ObjectLifetimeDefault { … } for them!
+
     fn visit_path(&mut self, path: &hir::Path<'tcx>, hir_id: HirId) {
-        for (i, segment) in path.segments.iter().enumerate() {
-            let depth = path.segments.len() - i - 1;
+        for (index, segment) in path.segments.iter().enumerate() {
             if let Some(args) = segment.args {
-                self.visit_segment_args(path.res, depth, args);
+                self.visit_segment_args(path, index, args);
             }
         }
         if let Res::Def(DefKind::TyParam | DefKind::ConstParam, param_def_id) = path.res {
@@ -1611,8 +1637,8 @@ impl<'a, 'tcx> BoundVarContext<'a, 'tcx> {
     #[instrument(level = "debug", skip(self))]
     fn visit_segment_args(
         &mut self,
-        res: Res,
-        depth: usize,
+        path: &hir::Path<'tcx>,
+        index: usize,
         generic_args: &'tcx hir::GenericArgs<'tcx>,
     ) {
         if let Some((inputs, output)) = generic_args.paren_sugar_inputs_output() {
@@ -1626,19 +1652,23 @@ impl<'a, 'tcx> BoundVarContext<'a, 'tcx> {
             }
         }
 
-        // Figure out if this is a type/trait segment,
-        // which requires object lifetime defaults.
-        let type_def_id = match res {
-            Res::Def(DefKind::AssocTy, def_id) if depth == 1 => Some(self.tcx.parent(def_id)),
-            Res::Def(DefKind::Variant, def_id) if depth == 0 => Some(self.tcx.parent(def_id)),
-            Res::Def(
-                DefKind::Struct
-                | DefKind::Union
-                | DefKind::Enum
-                | DefKind::TyAlias
-                | DefKind::Trait,
-                def_id,
-            ) if depth == 0 => Some(def_id),
+        // Figure out if this is a type/trait segment, which requires object lifetime defaults.
+        let depth = path.segments.len() - index - 1;
+        let type_def_id = match (path.res, depth) {
+            (Res::Def(DefKind::AssocTy, def_id), 1) => Some(self.tcx.parent(def_id)),
+            (Res::Def(DefKind::Variant, def_id), 0) => Some(self.tcx.parent(def_id)),
+            (
+                Res::Def(
+                    DefKind::Struct
+                    | DefKind::Union
+                    | DefKind::Enum
+                    | DefKind::TyAlias
+                    | DefKind::Trait
+                    | DefKind::AssocTy,
+                    def_id,
+                ),
+                0,
+            ) => Some(def_id),
             _ => None,
         };
 
@@ -1683,9 +1713,6 @@ impl<'a, 'tcx> BoundVarContext<'a, 'tcx> {
             let rbv = &self.rbv;
             let generics = self.tcx.generics_of(def_id);
 
-            // `type_def_id` points to an item, so there is nothing to inherit generics from.
-            debug_assert_eq!(generics.parent_count, 0);
-
             let set_to_region = |set: ObjectLifetimeDefault| match set {
                 ObjectLifetimeDefault::Empty => {
                     if in_body {
@@ -1696,12 +1723,31 @@ impl<'a, 'tcx> BoundVarContext<'a, 'tcx> {
                 }
                 ObjectLifetimeDefault::Static => Some(ResolvedArg::StaticLifetime),
                 ObjectLifetimeDefault::Param(param_def_id) => {
-                    // This index can be used with `generic_args` since `parent_count == 0`.
-                    let index = generics.param_def_id_to_index[&param_def_id] as usize;
-                    generic_args.args.get(index).and_then(|arg| match arg {
-                        GenericArg::Lifetime(lt) => rbv.defs.get(&lt.hir_id.local_id).copied(),
-                        _ => None,
-                    })
+                    fn param_to_depth_and_index(
+                        generics: &ty::Generics,
+                        tcx: TyCtxt<'_>,
+                        def_id: DefId,
+                    ) -> (usize, usize) {
+                        if let Some(&index) = generics.param_def_id_to_index.get(&def_id) {
+                            let has_self = generics.parent.is_none() && generics.has_self;
+                            (0, index as usize - generics.parent_count - has_self as usize)
+                        } else if let Some(parent) = generics.parent {
+                            let parent = tcx.generics_of(parent);
+                            let (index, depth) = param_to_depth_and_index(parent, tcx, def_id);
+                            (depth + 1, index)
+                        } else {
+                            unreachable!()
+                        }
+                    }
+
+                    let (depth, index) = param_to_depth_and_index(generics, self.tcx, param_def_id);
+                    path.segments[path.segments.len() - depth - 1]
+                        .args
+                        .and_then(|args| args.args.get(index))
+                        .and_then(|arg| match arg {
+                            GenericArg::Lifetime(lt) => rbv.defs.get(&lt.hir_id.local_id).copied(),
+                            _ => None,
+                        })
                 }
                 ObjectLifetimeDefault::Ambiguous => None,
             };

src/librustdoc/clean/mod.rs

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

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

@@ -0,0 +1,23 @@
+// FIXME: Explainer
+//@ check-pass
+//@ known-bug: unknown
+
+// FIXME: Temporary test.
+
+trait Outer { type Ty; }
+trait Inner {}
+
+impl<'a> Outer for dyn Inner + 'a { type Ty = &'a (); }
+
+fn f<'r>(x: &'r <dyn Inner + 'r as Outer>::Ty) { g(x) }
+// FIXME: `dyn Inner` currently defaults to `dyn Inner + 'r` because
+//        we have OLD(Param('r)) in scope which never gets shadowed by
+//        the projection since `resolve_bound_vars` doesn't properly
+//        handle QSelfs (it doesn't overwrite `visit_qself`)
+//        In this case, it should infer `'static`.
+fn g<'r>(x: &'r <dyn Inner as Outer>::Ty) {}
+
+// FIXME: Add test where the Self ty param is bounded (!) and can
+//        participate in OLD resolution!
+//            trait Outer<'a>: 'a {}
+//        This doesn't either rn for the same reason as above.

tests/ui/object-lifetime/object-lifetime-default-gat-resolved.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 defaults 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 defaults 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() {}

tests/ui/object-lifetime/object-lifetime-default-gat-type-relative.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() {}

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