fixup! Resolve self type alias in impl for RTN

compiler/rustc_hir_analysis/src/collect/resolve_bound_vars.rs

@@ -1927,6 +1927,7 @@ impl<'a, 'tcx> BoundVarContext<'a, 'tcx> {
                         // from the generics of the parameter's definition, since we want
                         // to be able to resolve an RTN path on a nested body (e.g. method
                         // inside an impl) using the where clauses on the method.
+                        // FIXME(return_type_notation): Think of some better way of doing this.
                         let Some(generics) = self.tcx.hir_owner_node(hir_id.owner).generics()
                         else {
                             return;
@@ -1965,9 +1966,14 @@ impl<'a, 'tcx> BoundVarContext<'a, 'tcx> {
                         };
                         (bound_vars, assoc_item.def_id, item_segment)
                     }
+                    // If we have a self type alias (in an impl), try to resolve an
+                    // associated item from one of the supertraits of the impl's trait.
                     Res::SelfTyAlias { alias_to: impl_def_id, is_trait_impl: true, .. } => {
-                        let hir::ItemKind::Impl(hir::Impl { of_trait: Some(trait_ref), .. }) =
-                            self.tcx.hir_node_by_def_id(impl_def_id.expect_local()).expect_item().kind
+                        let hir::ItemKind::Impl(hir::Impl { of_trait: Some(trait_ref), .. }) = self
+                            .tcx
+                            .hir_node_by_def_id(impl_def_id.expect_local())
+                            .expect_item()
+                            .kind
                         else {
                             return;
                         };

tests/ui/associated-type-bounds/return-type-notation/path-constrained-in-method.rs

@@ -0,0 +1,24 @@
+//@ check-pass
+
+#![feature(return_type_notation)]
+//~^ WARN the feature `return_type_notation` is incomplete
+
+trait Trait {
+    fn method() -> impl Sized;
+}
+
+fn is_send(_: impl Send) {}
+
+struct W<T>(T);
+
+impl<T> W<T> {
+    fn test()
+    where
+        T: Trait,
+        T::method(..): Send,
+    {
+        is_send(T::method());
+    }
+}
+
+fn main() {}

tests/ui/associated-type-bounds/return-type-notation/path-constrained-in-method.stderr

@@ -0,0 +1,11 @@
+warning: the feature `return_type_notation` is incomplete and may not be safe to use and/or cause compiler crashes
+  --> $DIR/path-constrained-in-method.rs:3:12
+   |
+LL | #![feature(return_type_notation)]
+   |            ^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: see issue #109417 </~https://github.com/rust-lang/rust/issues/109417> for more information
+   = note: `#[warn(incomplete_features)]` on by default
+
+warning: 1 warning emitted
+