Mention associated type with same name as trait in E0782

```
error[E0782]: trait objects must include the `dyn` keyword
  --> $DIR/issue-116434-2021.rs:5:17
   |
LL |     type Clone;
   |     ---------- you might have meant to use this associated type
LL |     fn foo() -> Clone;
   |                 ^^^^^
   |
help: `Clone` is not object safe, use `impl Clone` to return an opaque type, as long as you return a single underlying type
   |
LL |     fn foo() -> impl Clone;
   |                 ++++
help: there is an associated type with the same name
   |
LL |     fn foo() -> Self::Clone;
   |                 ++++++
```

Author: estebank

compiler/rustc_hir_analysis/src/hir_ty_lowering/lint.rs

@@ -4,6 +4,7 @@ use rustc_hir as hir;
 use rustc_hir::def::{DefKind, Res};
 use rustc_infer::traits::error_reporting::suggest_path_on_bare_trait;
 use rustc_lint_defs::{builtin::BARE_TRAIT_OBJECTS, Applicability};
+use rustc_middle::ty;
 use rustc_span::Span;
 use rustc_trait_selection::traits::error_reporting::suggestions::NextTypeParamName;
 
@@ -87,6 +88,7 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
             // Check if the impl trait that we are considering is an impl of a local trait.
             self.maybe_suggest_blanket_trait_impl(self_ty, &mut diag);
             self.maybe_suggest_assoc_ty_bound(self_ty, &mut diag);
+            self.maybe_suggest_assoc_type(&poly_trait_ref.trait_ref, &mut diag);
 
             if object_safe {
                 let parents = self.tcx().hir().parent_iter(self_ty.hir_id);
@@ -338,4 +340,39 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
             );
         }
     }
+
+    /// Look for associated types with the same name as the `-> Trait` and suggest `-> Self::Trait`.
+    fn maybe_suggest_assoc_type(&self, trait_ref: &hir::TraitRef<'_>, diag: &mut Diag<'_>) {
+        let tcx = self.tcx();
+        let [segment] = trait_ref.path.segments else { return };
+        let mut trait_or_impl = None;
+        let mut iter = tcx.hir().parent_owner_iter(trait_ref.hir_ref_id);
+        while let Some((def_id, node)) = iter.next() {
+            if let hir::OwnerNode::Item(hir::Item {
+                kind: hir::ItemKind::Trait(..) | hir::ItemKind::Impl(..),
+                ..
+            }) = node
+            {
+                trait_or_impl = Some(def_id);
+                break;
+            }
+        }
+        let Some(parent_id) = trait_or_impl else { return };
+        let mut assocs = tcx
+            .associated_items(parent_id)
+            .filter_by_name_unhygienic(segment.ident.name)
+            .filter(|assoc| assoc.kind == ty::AssocKind::Type);
+        if let Some(assoc) = assocs.next() {
+            diag.span_label(
+                tcx.def_span(assoc.def_id),
+                "you might have meant to use this associated type",
+            );
+            diag.span_suggestion_verbose(
+                segment.ident.span.shrink_to_lo(),
+                "there is an associated type with the same name",
+                "Self::",
+                Applicability::MaybeIncorrect,
+            );
+        }
+    }
 }

tests/ui/suggestions/issue-116434-2021.rs

@@ -1,19 +1,21 @@
 //@ edition:2021
 
 trait Foo {
-    type Clone;
+    type Clone; //~ NOTE you might have meant to use this associated type
     fn foo() -> Clone;
     //~^ ERROR trait objects must include the `dyn` keyword
     //~| HELP `Clone` is not object safe, use `impl Clone` to return an opaque type, as long as you return a single underlying type
+    //~| HELP there is an associated type with the same name
 }
 
 trait DbHandle: Sized {}
 
 trait DbInterface {
-    type DbHandle;
+    type DbHandle; //~ NOTE you might have meant to use this associated type
     fn handle() -> DbHandle;
     //~^ ERROR trait objects must include the `dyn` keyword
     //~| HELP `DbHandle` is not object safe, use `impl DbHandle` to return an opaque type, as long as you return a single underlying type
+    //~| HELP there is an associated type with the same name
 }
 
 fn main() {}

tests/ui/suggestions/issue-116434-2021.stderr

@@ -1,24 +1,36 @@
 error[E0782]: trait objects must include the `dyn` keyword
   --> $DIR/issue-116434-2021.rs:5:17
    |
+LL |     type Clone;
+   |     ---------- you might have meant to use this associated type
 LL |     fn foo() -> Clone;
    |                 ^^^^^
    |
 help: `Clone` is not object safe, use `impl Clone` to return an opaque type, as long as you return a single underlying type
    |
 LL |     fn foo() -> impl Clone;
    |                 ++++
+help: there is an associated type with the same name
+   |
+LL |     fn foo() -> Self::Clone;
+   |                 ++++++
 
 error[E0782]: trait objects must include the `dyn` keyword
-  --> $DIR/issue-116434-2021.rs:14:20
+  --> $DIR/issue-116434-2021.rs:15:20
    |
+LL |     type DbHandle;
+   |     ------------- you might have meant to use this associated type
 LL |     fn handle() -> DbHandle;
    |                    ^^^^^^^^
    |
 help: `DbHandle` is not object safe, use `impl DbHandle` to return an opaque type, as long as you return a single underlying type
    |
 LL |     fn handle() -> impl DbHandle;
    |                    ++++
+help: there is an associated type with the same name
+   |
+LL |     fn handle() -> Self::DbHandle;
+   |                    ++++++
 
 error: aborting due to 2 previous errors