Fixes #7915

Fix shadow_same's positive false for async function's params:

Example Code:
```rust
#![deny(clippy::shadow_same)]

pub async fn foo(_a: i32) {
}
```
Output:
```
error: `_a` is shadowed by itself in `_a
```

Hir:
```rust
pub async fn foo(_a: i32)
 ->
     /*impl Trait*/ #[lang = "from_generator"](move |mut _task_context|
                                                   {
                                                       let _a = _a;
                                                       { let _t = { }; _t }
                                                   })
```

Skip checking async function's params.

changelog: Fix shadow_same's positive false for async function's params

Author: surechen

clippy_lints/src/shadow.rs

@@ -1,11 +1,12 @@
 use clippy_utils::diagnostics::span_lint_and_note;
 use clippy_utils::source::snippet;
 use clippy_utils::visitors::is_local_used;
-use rustc_data_structures::fx::FxHashMap;
+use rustc_data_structures::fx::{FxHashMap, FxHashSet};
 use rustc_hir::def::Res;
 use rustc_hir::def_id::LocalDefId;
 use rustc_hir::hir_id::ItemLocalId;
-use rustc_hir::{Block, Body, BodyOwnerKind, Expr, ExprKind, HirId, Node, Pat, PatKind, QPath, UnOp};
+use rustc_hir::intravisit::FnKind;
+use rustc_hir::{Block, Body, BodyOwnerKind, Expr, ExprKind, FnDecl, HirId, IsAsync, Node, Pat, PatKind, QPath, UnOp};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_tool_lint, impl_lint_pass};
 use rustc_span::{Span, Symbol};
@@ -95,6 +96,7 @@ declare_clippy_lint! {
 #[derive(Default)]
 pub(crate) struct Shadow {
     bindings: Vec<FxHashMap<Symbol, Vec<ItemLocalId>>>,
+    skip: Vec<FxHashSet<Symbol>>,
 }
 
 impl_lint_pass!(Shadow => [SHADOW_SAME, SHADOW_REUSE, SHADOW_UNRELATED]);
@@ -121,6 +123,11 @@ impl<'tcx> LateLintPass<'tcx> for Shadow {
                 return;
             }
 
+            if self.skip.len() > 0 && self.skip.last_mut().unwrap().contains(&ident.name) {
+                // skip async function's params
+                return;
+            }
+
             if is_shadow(cx, owner, prev, local_id) {
                 let prev_hir_id = HirId { owner, local_id: prev };
                 lint_shadow(cx, pat, prev_hir_id, ident.span);
@@ -145,6 +152,58 @@ impl<'tcx> LateLintPass<'tcx> for Shadow {
             self.bindings.pop();
         }
     }
+
+    fn check_fn(
+        &mut self,
+        _: &LateContext<'tcx>,
+        kind: FnKind<'tcx>,
+        _: &'tcx FnDecl<'_>,
+        body: &'tcx Body<'_>,
+        _: Span,
+        _: HirId,
+    ) {
+        if_chain! {
+            if let Some(header) = match kind {
+                FnKind::ItemFn(_, _, header, _) => Some(header),
+                FnKind::Method(_, sig, _) => Some(sig.header),
+                _ => None,
+            };
+            if header.asyncness == IsAsync::Async;
+            if body.params.len() > 0;
+            then {
+                self.skip.push(FxHashSet::default());
+                let skip_params = self.skip.last_mut().unwrap();
+                for i in body.params {
+                    if let PatKind::Binding(.., ident, _) = i.pat.kind {
+                       skip_params.insert(ident.name);
+                    }
+                }
+            }
+        }
+    }
+
+    fn check_fn_post(
+        &mut self,
+        _: &LateContext<'tcx>,
+        kind: FnKind<'tcx>,
+        _: &'tcx FnDecl<'_>,
+        body: &'tcx Body<'_>,
+        _: Span,
+        _: HirId,
+    ) {
+        if_chain! {
+            if let Some(header) = match kind {
+                FnKind::ItemFn(_, _, header, _) => Some(header),
+                FnKind::Method(_, sig, _) => Some(sig.header),
+                _ => None,
+            };
+            if header.asyncness == IsAsync::Async;
+            if body.params.len() > 0;
+            then {
+                self.skip.pop();
+            }
+        }
+    }
 }
 
 fn is_shadow(cx: &LateContext<'_>, owner: LocalDefId, first: ItemLocalId, second: ItemLocalId) -> bool {

tests/ui/shadow.rs

@@ -79,4 +79,10 @@ fn question_mark() -> Option<()> {
     None
 }
 
+pub async fn foo1(_a: i32) {}
+
+pub async fn foo2(_a: i32, _b: i64) {
+    let _b = _a;
+}
+
 fn main() {}