Suggest appropriate type instead of Self in E0401

```
error[E0401]: can't use `Self` from outer item
  --> $DIR/E0401.rs:22:25
   |
LL | impl<T> Iterator for A<T> {
   | ---- `Self` type implicitly declared here, by this `impl`
...
LL |         fn helper(sel: &Self) -> u8 {
   |            ------       ^^^^ use of `Self` from outer item
   |            |
   |            `Self` used in this inner function
   |
help: refer to the type directly here instead
   |
LL -         fn helper(sel: &Self) -> u8 {
LL +         fn helper(sel: &A<T>) -> u8 {
   |
```

Author: estebank

compiler/rustc_resolve/src/diagnostics.rs

@@ -558,6 +558,7 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
                 has_generic_params,
                 def_kind,
                 inner_item,
+                current_self_ty,
             } => {
                 use errs::GenericParamsFromOuterItemLabel as Label;
                 let static_or_const = match def_kind {
@@ -595,7 +596,8 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
                             sm,
                             self.def_span(def_id),
                         )));
-                        err.refer_to_type_directly = Some(span);
+                        err.refer_to_type_directly =
+                            current_self_ty.map(|snippet| errs::UseTypeDirectly { span, snippet });
                         return self.dcx().create_err(err);
                     }
                     Res::Def(DefKind::TyParam, def_id) => {

compiler/rustc_resolve/src/errors.rs

@@ -17,8 +17,8 @@ pub(crate) struct GenericParamsFromOuterItem {
     pub(crate) span: Span,
     #[subdiagnostic]
     pub(crate) label: Option<GenericParamsFromOuterItemLabel>,
-    #[label(resolve_refer_to_type_directly)]
-    pub(crate) refer_to_type_directly: Option<Span>,
+    #[subdiagnostic]
+    pub(crate) refer_to_type_directly: Option<UseTypeDirectly>,
     #[subdiagnostic]
     pub(crate) sugg: Option<GenericParamsFromOuterItemSugg>,
     #[subdiagnostic]
@@ -68,6 +68,18 @@ pub(crate) struct GenericParamsFromOuterItemSugg {
     pub(crate) span: Span,
     pub(crate) snippet: String,
 }
+#[derive(Subdiagnostic)]
+#[suggestion(
+    resolve_refer_to_type_directly,
+    code = "{snippet}",
+    applicability = "maybe-incorrect",
+    style = "verbose"
+)]
+pub(crate) struct UseTypeDirectly {
+    #[primary_span]
+    pub(crate) span: Span,
+    pub(crate) snippet: String,
+}
 
 #[derive(Diagnostic)]
 #[diag(resolve_name_is_already_used_as_generic_parameter, code = E0403)]

compiler/rustc_resolve/src/ident.rs

@@ -1415,6 +1415,11 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
                                 has_generic_params,
                                 def_kind,
                                 inner_item: item,
+                                current_self_ty: diag_metadata
+                                    .and_then(|m| m.current_self_type.as_ref())
+                                    .and_then(|ty| {
+                                        self.tcx.sess.source_map().span_to_snippet(ty.span).ok()
+                                    }),
                             },
                         );
                     }
@@ -1503,6 +1508,11 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
                                 has_generic_params,
                                 def_kind,
                                 inner_item: item,
+                                current_self_ty: diag_metadata
+                                    .and_then(|m| m.current_self_type.as_ref())
+                                    .and_then(|ty| {
+                                        self.tcx.sess.source_map().span_to_snippet(ty.span).ok()
+                                    }),
                             },
                         );
                     }

compiler/rustc_resolve/src/late.rs

@@ -675,7 +675,7 @@ pub(crate) struct DiagMetadata<'ast> {
     current_trait_assoc_items: Option<&'ast [Box<AssocItem>]>,
 
     /// The current self type if inside an impl (used for better errors).
-    current_self_type: Option<Ty>,
+    pub(crate) current_self_type: Option<Ty>,
 
     /// The current self item if inside an ADT (used for better errors).
     current_self_item: Option<NodeId>,

compiler/rustc_resolve/src/lib.rs

@@ -246,6 +246,7 @@ enum ResolutionError<'ra> {
         has_generic_params: HasGenericParams,
         def_kind: DefKind,
         inner_item: Option<(Span, ast::ItemKind)>,
+        current_self_ty: Option<String>,
     },
     /// Error E0403: the name is already used for a type or const parameter in this generic
     /// parameter list.

tests/ui/error-codes/E0401.stderr

@@ -37,11 +37,15 @@ LL | impl<T> Iterator for A<T> {
    | ---- `Self` type implicitly declared here, by this `impl`
 ...
 LL |         fn helper(sel: &Self) -> u8 {
-   |            ------       ^^^^
-   |            |            |
-   |            |            use of `Self` from outer item
-   |            |            refer to the type directly here instead
+   |            ------       ^^^^ use of `Self` from outer item
+   |            |
    |            `Self` used in this inner function
+   |
+help: refer to the type directly here instead
+   |
+LL -         fn helper(sel: &Self) -> u8 {
+LL +         fn helper(sel: &A<T>) -> u8 {
+   |
 
 error: aborting due to 3 previous errors
 

tests/ui/resolve/use-self-in-inner-fn.stderr

@@ -5,11 +5,15 @@ LL | impl A {
    | ---- `Self` type implicitly declared here, by this `impl`
 ...
 LL |         fn peach(this: &Self) {
-   |            -----        ^^^^
-   |            |            |
-   |            |            use of `Self` from outer item
-   |            |            refer to the type directly here instead
+   |            -----        ^^^^ use of `Self` from outer item
+   |            |
    |            `Self` used in this inner function
+   |
+help: refer to the type directly here instead
+   |
+LL -         fn peach(this: &Self) {
+LL +         fn peach(this: &A) {
+   |
 
 error: aborting due to 1 previous error