only check immutable

Author: lengyijun

clippy_lints/src/needless_deref.rs

@@ -6,30 +6,34 @@ use rustc_errors::Applicability;
 use rustc_hir::ExprKind;
 use rustc_hir::UnOp;
 use rustc_lint::{LateContext, LateLintPass};
+use rustc_middle::mir::Mutability;
 use rustc_middle::ty;
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for manual deref in function(no generic type) parameters.
+    /// Checks for `&*(&T)`.
     ///
     /// ### Why is this bad?
-    /// There is no need to deref manually. Compiler will auto deref.
+    /// If you just want to reborrow, `&T` is enough (`&T` is Copy).
+    /// if you want to deref explicitly, `&** (&T)` is what you need.
     ///
     /// ### Known problems
-    /// Complicate type is not handled. For example `foo(&*****(&&T))`.
+    /// None.
     ///
     /// ### Example
     /// ```rust
-    /// fn foo(_: &str) {}
-    /// let pf = &String::new();
+    /// let s = &String::new();
+    ///
     /// // Bad
-    /// foo(&**pf);
-    /// foo(&*String::new());
+    /// let a: &String = &* s;
+    /// foo(&*s);
     ///
     /// // Good
-    /// foo(pf);
-    /// foo(&String::new());
+    /// let a: &String = s;
+    /// foo(&**s);
+    ///
+    /// fn foo(_: &str){ }
     /// ```
     pub NEEDLESS_DEREF,
     complexity,
@@ -42,12 +46,11 @@ impl LateLintPass<'_> for NeedlessDeref {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, e: &'tcx rustc_hir::Expr<'_>) {
         if_chain! {
             if !e.span.from_expansion() && !in_macro(e.span);
-            if let ExprKind::AddrOf(_, ref outer_mutability, addrof_target) = e.kind;
+            if let ExprKind::AddrOf(_, Mutability::Not, addrof_target) = e.kind;
             if let ExprKind::Unary(UnOp::Deref, deref_target) = addrof_target.kind;
             if !matches!(deref_target.kind, ExprKind::Unary(UnOp::Deref, ..) );
             let inner_ty = cx.typeck_results().expr_ty(deref_target);
-            if let ty::Ref(_, _, inner_mutability) = inner_ty.kind();
-            if inner_mutability == outer_mutability ;
+            if let ty::Ref(_, _, Mutability::Not) = inner_ty.kind();
             then{
 
                 let map=cx.tcx.hir();