needless_deref

lengyijun · lengyijun · commit d1ba632a4571 · 2021-11-04T14:09:41.000Z
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -3030,6 +3030,7 @@ Released 2018-09-13
 [`needless_borrowed_reference`]: https://rust-lang.github.io/rust-clippy/master/index.html#needless_borrowed_reference
 [`needless_collect`]: https://rust-lang.github.io/rust-clippy/master/index.html#needless_collect
 [`needless_continue`]: https://rust-lang.github.io/rust-clippy/master/index.html#needless_continue
+[`needless_deref`]: https://rust-lang.github.io/rust-clippy/master/index.html#needless_deref
 [`needless_doctest_main`]: https://rust-lang.github.io/rust-clippy/master/index.html#needless_doctest_main
 [`needless_for_each`]: https://rust-lang.github.io/rust-clippy/master/index.html#needless_for_each
 [`needless_lifetimes`]: https://rust-lang.github.io/rust-clippy/master/index.html#needless_lifetimes
diff --git a/clippy_lints/src/enum_variants.rs b/clippy_lints/src/enum_variants.rs
@@ -151,8 +151,8 @@ fn check_variant(
         }
     }
     let first = &def.variants[0].ident.name.as_str();
-    let mut pre = &first[..str_utils::camel_case_until(&*first).byte_index];
-    let mut post = &first[str_utils::camel_case_start(&*first).byte_index..];
+    let mut pre = &first[..str_utils::camel_case_until(first).byte_index];
+    let mut post = &first[str_utils::camel_case_start(first).byte_index..];
     for var in def.variants {
         let name = var.ident.name.as_str();
 
diff --git a/clippy_lints/src/eval_order_dependence.rs b/clippy_lints/src/eval_order_dependence.rs
@@ -119,7 +119,7 @@ impl<'a, 'tcx> DivergenceVisitor<'a, 'tcx> {
                         self.visit_expr(if_expr);
                     }
                     // make sure top level arm expressions aren't linted
-                    self.maybe_walk_expr(&*arm.body);
+                    self.maybe_walk_expr(arm.body);
                 }
             },
             _ => walk_expr(self, e),
diff --git a/clippy_lints/src/let_if_seq.rs b/clippy_lints/src/let_if_seq.rs
@@ -67,7 +67,7 @@ impl<'tcx> LateLintPass<'tcx> for LetIfSeq {
                 if let hir::ExprKind::If(hir::Expr { kind: hir::ExprKind::DropTemps(cond), ..}, then, else_) = if_.kind;
                 if !is_local_used(cx, *cond, canonical_id);
                 if let hir::ExprKind::Block(then, _) = then.kind;
-                if let Some(value) = check_assign(cx, canonical_id, &*then);
+                if let Some(value) = check_assign(cx, canonical_id, then);
                 if !is_local_used(cx, value, canonical_id);
                 then {
                     let span = stmt.span.to(if_.span);
diff --git a/clippy_lints/src/lib.register_all.rs b/clippy_lints/src/lib.register_all.rs
@@ -205,6 +205,7 @@ store.register_group(true, "clippy::all", Some("clippy_all"), vec![
     LintId::of(needless_bool::NEEDLESS_BOOL),
     LintId::of(needless_borrow::NEEDLESS_BORROW),
     LintId::of(needless_borrowed_ref::NEEDLESS_BORROWED_REFERENCE),
+    LintId::of(needless_deref::NEEDLESS_DEREF),
     LintId::of(needless_option_as_deref::NEEDLESS_OPTION_AS_DEREF),
     LintId::of(needless_question_mark::NEEDLESS_QUESTION_MARK),
     LintId::of(needless_update::NEEDLESS_UPDATE),
diff --git a/clippy_lints/src/lib.register_complexity.rs b/clippy_lints/src/lib.register_complexity.rs
@@ -55,6 +55,7 @@ store.register_group(true, "clippy::complexity", Some("clippy_complexity"), vec!
     LintId::of(needless_bool::BOOL_COMPARISON),
     LintId::of(needless_bool::NEEDLESS_BOOL),
     LintId::of(needless_borrowed_ref::NEEDLESS_BORROWED_REFERENCE),
+    LintId::of(needless_deref::NEEDLESS_DEREF),
     LintId::of(needless_option_as_deref::NEEDLESS_OPTION_AS_DEREF),
     LintId::of(needless_question_mark::NEEDLESS_QUESTION_MARK),
     LintId::of(needless_update::NEEDLESS_UPDATE),
diff --git a/clippy_lints/src/lib.register_lints.rs b/clippy_lints/src/lib.register_lints.rs
@@ -355,6 +355,7 @@ store.register_lints(&[
     needless_borrow::REF_BINDING_TO_REFERENCE,
     needless_borrowed_ref::NEEDLESS_BORROWED_REFERENCE,
     needless_continue::NEEDLESS_CONTINUE,
+    needless_deref::NEEDLESS_DEREF,
     needless_for_each::NEEDLESS_FOR_EACH,
     needless_option_as_deref::NEEDLESS_OPTION_AS_DEREF,
     needless_pass_by_value::NEEDLESS_PASS_BY_VALUE,
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
@@ -293,6 +293,7 @@ mod needless_bool;
 mod needless_borrow;
 mod needless_borrowed_ref;
 mod needless_continue;
+mod needless_deref;
 mod needless_for_each;
 mod needless_option_as_deref;
 mod needless_pass_by_value;
@@ -575,6 +576,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(|| Box::new(needless_update::NeedlessUpdate));
     store.register_late_pass(|| Box::new(needless_borrow::NeedlessBorrow::default()));
     store.register_late_pass(|| Box::new(needless_borrowed_ref::NeedlessBorrowedRef));
+    store.register_late_pass(|| Box::new(needless_deref::NeedlessDeref));
     store.register_late_pass(|| Box::new(no_effect::NoEffect));
     store.register_late_pass(|| Box::new(temporary_assignment::TemporaryAssignment));
     store.register_late_pass(|| Box::new(transmute::Transmute));
diff --git a/clippy_lints/src/loops/never_loop.rs b/clippy_lints/src/loops/never_loop.rs
@@ -142,7 +142,7 @@ fn never_loop_expr(expr: &Expr<'_>, main_loop_id: HirId) -> NeverLoopResult {
             if arms.is_empty() {
                 e
             } else {
-                let arms = never_loop_expr_branch(&mut arms.iter().map(|a| &*a.body), main_loop_id);
+                let arms = never_loop_expr_branch(&mut arms.iter().map(|a| a.body), main_loop_id);
                 combine_seq(e, arms)
             }
         },
diff --git a/clippy_lints/src/matches.rs b/clippy_lints/src/matches.rs
@@ -877,8 +877,8 @@ fn check_match_bool(cx: &LateContext<'_>, ex: &Expr<'_>, arms: &[Arm<'_>], expr:
                     let exprs = if let PatKind::Lit(arm_bool) = arms[0].pat.kind {
                         if let ExprKind::Lit(ref lit) = arm_bool.kind {
                             match lit.node {
-                                LitKind::Bool(true) => Some((&*arms[0].body, &*arms[1].body)),
-                                LitKind::Bool(false) => Some((&*arms[1].body, &*arms[0].body)),
+                                LitKind::Bool(true) => Some((arms[0].body, arms[1].body)),
+                                LitKind::Bool(false) => Some((arms[1].body, arms[0].body)),
                                 _ => None,
                             }
                         } else {
diff --git a/clippy_lints/src/mut_key.rs b/clippy_lints/src/mut_key.rs
@@ -104,7 +104,7 @@ impl<'tcx> LateLintPass<'tcx> for MutableKeyType {
         if let hir::PatKind::Wild = local.pat.kind {
             return;
         }
-        check_ty(cx, local.span, cx.typeck_results().pat_ty(&*local.pat));
+        check_ty(cx, local.span, cx.typeck_results().pat_ty(local.pat));
     }
 }
 
diff --git a/clippy_lints/src/needless_bool.rs b/clippy_lints/src/needless_bool.rs
@@ -333,7 +333,7 @@ enum Expression {
 }
 
 fn fetch_bool_block(block: &Block<'_>) -> Expression {
-    match (&*block.stmts, block.expr.as_ref()) {
+    match (block.stmts, block.expr.as_ref()) {
         (&[], Some(e)) => fetch_bool_expr(&**e),
         (&[ref e], None) => {
             if let StmtKind::Semi(e) = e.kind {
diff --git a/clippy_lints/src/needless_deref.rs b/clippy_lints/src/needless_deref.rs
@@ -0,0 +1,95 @@
+use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::in_macro;
+use clippy_utils::source::snippet_opt;
+use clippy_utils::source::snippet_with_applicability;
+use rustc_errors::Applicability;
+use rustc_hir::ExprKind;
+use rustc_hir::UnOp;
+use rustc_lint::{LateContext, LateLintPass};
+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.
+    ///
+    /// ### Why is this bad?
+    /// There is no need to deref manually. Compiler will auto deref.
+    ///
+    /// ### Known problems
+    /// Complicate type is not handled. For example `foo(&*****(&&T))`.
+    ///
+    /// ### Example
+    /// ```rust
+    /// fn foo(_: &str) {}
+    /// let pf = &String::new();
+    /// // Bad
+    /// foo(&**pf);
+    /// foo(&*String::new());
+    ///
+    /// // Good
+    /// foo(pf);
+    /// foo(&String::new());
+    /// ```
+    pub NEEDLESS_DEREF,
+    complexity,
+    "remove needless deref"
+}
+
+declare_lint_pass!(NeedlessDeref => [NEEDLESS_DEREF]);
+
+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::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 ;
+            then{
+
+                let map=cx.tcx.hir();
+                if let Some(parent_hir_id) = map.find_parent_node(e.hir_id){
+                    let span=map.span(parent_hir_id);
+                    if span.from_expansion() || in_macro(span) {
+                        return;
+                    }
+                    let parent_node=map.find(parent_hir_id);
+                    if let Some(rustc_hir::Node::Expr(parent_expr)) = parent_node {
+                        if  matches!(parent_expr.kind, ExprKind::Unary(UnOp::Deref, ..)) ||
+                            matches!(parent_expr.kind, ExprKind::AddrOf(..) ){
+                                return;
+                            }
+                    }
+                }
+
+
+                let outer_ty=cx.typeck_results().expr_ty(e);
+                let mut applicability = Applicability::MachineApplicable;
+                if inner_ty == outer_ty {
+                    span_lint_and_sugg(
+                        cx,
+                        NEEDLESS_DEREF,
+                        e.span,
+                        "immediately dereferencing a reference",
+                        "try this",
+                        snippet_with_applicability(cx, deref_target.span, "_", &mut applicability).to_string(),
+                        applicability,
+                    );
+                }else{
+                    span_lint_and_sugg(
+                        cx,
+                        NEEDLESS_DEREF,
+                        e.span,
+                        "reference on a de-referenced",
+                        "you may want to do this",
+                        "&**".to_owned()+&snippet_opt(cx, deref_target.span).unwrap(),
+                        Applicability::MachineApplicable,
+                    );
+                }
+            }
+        }
+    }
+}
diff --git a/clippy_lints/src/pass_by_ref_or_value.rs b/clippy_lints/src/pass_by_ref_or_value.rs
@@ -231,7 +231,7 @@ impl<'tcx> LateLintPass<'tcx> for PassByRefOrValue {
         }
 
         if let hir::TraitItemKind::Fn(method_sig, _) = &item.kind {
-            self.check_poly_fn(cx, item.def_id, &*method_sig.decl, None);
+            self.check_poly_fn(cx, item.def_id, method_sig.decl, None);
         }
     }
 
diff --git a/clippy_lints/src/redundant_clone.rs b/clippy_lints/src/redundant_clone.rs
@@ -288,8 +288,8 @@ fn is_call_with_ref_arg<'tcx>(
         if let mir::TerminatorKind::Call { func, args, destination, .. } = kind;
         if args.len() == 1;
         if let mir::Operand::Move(mir::Place { local, .. }) = &args[0];
-        if let ty::FnDef(def_id, _) = *func.ty(&*mir, cx.tcx).kind();
-        if let (inner_ty, 1) = walk_ptrs_ty_depth(args[0].ty(&*mir, cx.tcx));
+        if let ty::FnDef(def_id, _) = *func.ty(mir, cx.tcx).kind();
+        if let (inner_ty, 1) = walk_ptrs_ty_depth(args[0].ty(mir, cx.tcx));
         if !is_copy(cx, inner_ty);
         then {
             Some((def_id, *local, inner_ty, destination.as_ref().map(|(dest, _)| dest)?.as_local()?))
@@ -318,7 +318,7 @@ fn find_stmt_assigns_to<'tcx>(
         None
     })?;
 
-    match (by_ref, &*rvalue) {
+    match (by_ref, rvalue) {
         (true, mir::Rvalue::Ref(_, _, place)) | (false, mir::Rvalue::Use(mir::Operand::Copy(place))) => {
             Some(base_local_and_movability(cx, mir, *place))
         },
diff --git a/clippy_lints/src/redundant_static_lifetimes.rs b/clippy_lints/src/redundant_static_lifetimes.rs
@@ -50,12 +50,12 @@ impl RedundantStaticLifetimes {
     fn visit_type(&mut self, ty: &Ty, cx: &EarlyContext<'_>, reason: &str) {
         match ty.kind {
             // Be careful of nested structures (arrays and tuples)
-            TyKind::Array(ref ty, _) => {
-                self.visit_type(&*ty, cx, reason);
+            TyKind::Array(ref ty, _) | TyKind::Slice(ref ty) => {
+                self.visit_type(ty, cx, reason);
             },
             TyKind::Tup(ref tup) => {
                 for tup_ty in tup {
-                    self.visit_type(&*tup_ty, cx, reason);
+                    self.visit_type(tup_ty, cx, reason);
                 }
             },
             // This is what we are looking for !
@@ -88,9 +88,6 @@ impl RedundantStaticLifetimes {
                 }
                 self.visit_type(&*borrow_type.ty, cx, reason);
             },
-            TyKind::Slice(ref ty) => {
-                self.visit_type(ty, cx, reason);
-            },
             _ => {},
         }
     }
diff --git a/clippy_utils/src/ast_utils.rs b/clippy_utils/src/ast_utils.rs
@@ -611,7 +611,7 @@ pub fn extract_assert_macro_args(mut expr: &Expr) -> Option<[&Expr; 2]> {
         if let [a, b, ..] = tup.as_slice();
         if let (&ExprKind::AddrOf(_, _, ref a), &ExprKind::AddrOf(_, _, ref b)) = (&a.kind, &b.kind);
         then {
-            return Some([&*a, &*b]);
+            return Some([a, b]);
         }
     }
     None
diff --git a/clippy_utils/src/consts.rs b/clippy_utils/src/consts.rs
@@ -458,7 +458,7 @@ impl<'a, 'tcx> ConstEvalLateContext<'a, 'tcx> {
     fn ifthenelse(&mut self, cond: &Expr<'_>, then: &Expr<'_>, otherwise: Option<&Expr<'_>>) -> Option<Constant> {
         if let Some(Constant::Bool(b)) = self.expr(cond) {
             if b {
-                self.expr(&*then)
+                self.expr(then)
             } else {
                 otherwise.as_ref().and_then(|expr| self.expr(expr))
             }
diff --git a/clippy_utils/src/higher.rs b/clippy_utils/src/higher.rs
@@ -43,7 +43,7 @@ impl<'tcx> ForLoop<'tcx> {
             if let hir::StmtKind::Expr(body_expr) = body.kind;
             then {
                 return Some(Self {
-                    pat: &*local.pat,
+                    pat: local.pat,
                     arg: first_arg,
                     body: body_expr,
                     span: first_arm.span
diff --git a/clippy_utils/src/hir_utils.rs b/clippy_utils/src/hir_utils.rs
@@ -391,10 +391,10 @@ impl HirEqInterExpr<'_, '_, '_> {
                 self.eq_ty(lt, rt) && self.eq_body(ll_id.body, rl_id.body)
             },
             (&TyKind::Ptr(ref l_mut), &TyKind::Ptr(ref r_mut)) => {
-                l_mut.mutbl == r_mut.mutbl && self.eq_ty(&*l_mut.ty, &*r_mut.ty)
+                l_mut.mutbl == r_mut.mutbl && self.eq_ty(l_mut.ty, r_mut.ty)
             },
             (&TyKind::Rptr(_, ref l_rmut), &TyKind::Rptr(_, ref r_rmut)) => {
-                l_rmut.mutbl == r_rmut.mutbl && self.eq_ty(&*l_rmut.ty, &*r_rmut.ty)
+                l_rmut.mutbl == r_rmut.mutbl && self.eq_ty(l_rmut.ty, r_rmut.ty)
             },
             (&TyKind::Path(ref l), &TyKind::Path(ref r)) => self.eq_qpath(l, r),
             (&TyKind::Tup(l), &TyKind::Tup(r)) => over(l, r, |l, r| self.eq_ty(l, r)),
@@ -588,7 +588,7 @@ impl<'a, 'tcx> SpanlessHash<'a, 'tcx> {
                     self.hash_name(i.ident.name);
                 }
                 if let Some(j) = *j {
-                    self.hash_expr(&*j);
+                    self.hash_expr(j);
                 }
             },
             ExprKind::Box(e) | ExprKind::DropTemps(e) | ExprKind::Yield(e, _) => {
diff --git a/clippy_utils/src/lib.rs b/clippy_utils/src/lib.rs
@@ -1407,7 +1407,7 @@ pub fn is_refutable(cx: &LateContext<'_>, pat: &Pat<'_>) -> bool {
         },
         PatKind::Tuple(pats, _) => are_refutable(cx, pats),
         PatKind::Struct(ref qpath, fields, _) => {
-            is_enum_variant(cx, qpath, pat.hir_id) || are_refutable(cx, fields.iter().map(|field| &*field.pat))
+            is_enum_variant(cx, qpath, pat.hir_id) || are_refutable(cx, fields.iter().map(|field| field.pat))
         },
         PatKind::TupleStruct(ref qpath, pats, _) => is_enum_variant(cx, qpath, pat.hir_id) || are_refutable(cx, pats),
         PatKind::Slice(head, middle, tail) => {
@@ -1660,7 +1660,7 @@ pub fn if_sequence<'tcx>(mut expr: &'tcx Expr<'tcx>) -> (Vec<&'tcx Expr<'tcx>>,
     let mut blocks: Vec<&Block<'_>> = Vec::new();
 
     while let Some(higher::IfOrIfLet { cond, then, r#else }) = higher::IfOrIfLet::hir(expr) {
-        conds.push(&*cond);
+        conds.push(cond);
         if let ExprKind::Block(block, _) = then.kind {
             blocks.push(block);
         } else {
diff --git a/tests/ui/collapsible_match2.rs b/tests/ui/collapsible_match2.rs
@@ -57,7 +57,7 @@ fn lint_cases(opt_opt: Option<Option<u32>>, res_opt: Result<Option<u32>, String>
 
     // ref pattern and deref
     match Some(&[1]) {
-        Some(ref s) => match &*s {
+        Some(ref s) => match s {
             [n] => foo(n),
             _ => (),
         },
diff --git a/tests/ui/collapsible_match2.stderr b/tests/ui/collapsible_match2.stderr
@@ -78,7 +78,7 @@ LL |             [n] => foo(n),
 error: this `match` can be collapsed into the outer `match`
   --> $DIR/collapsible_match2.rs:60:24
    |
-LL |           Some(ref s) => match &*s {
+LL |           Some(ref s) => match s {
    |  ________________________^
 LL | |             [n] => foo(n),
 LL | |             _ => (),
@@ -88,7 +88,7 @@ LL | |         },
 help: the outer pattern can be modified to include the inner pattern
   --> $DIR/collapsible_match2.rs:60:14
    |
-LL |         Some(ref s) => match &*s {
+LL |         Some(ref s) => match s {
    |              ^^^^^ replace this binding
 LL |             [n] => foo(n),
    |             ^^^ with this pattern
diff --git a/tests/ui/explicit_deref_methods.fixed b/tests/ui/explicit_deref_methods.fixed
@@ -1,6 +1,8 @@
 // run-rustfix
 
-#![allow(unused_variables, clippy::clone_double_ref)]
+#![allow(unused_variables)]
+#![allow(clippy::clone_double_ref)]
+#![allow(clippy::needless_deref)]
 #![warn(clippy::explicit_deref_methods)]
 
 use std::ops::{Deref, DerefMut};
diff --git a/tests/ui/explicit_deref_methods.rs b/tests/ui/explicit_deref_methods.rs
@@ -1,6 +1,8 @@
 // run-rustfix
 
-#![allow(unused_variables, clippy::clone_double_ref)]
+#![allow(unused_variables)]
+#![allow(clippy::clone_double_ref)]
+#![allow(clippy::needless_deref)]
 #![warn(clippy::explicit_deref_methods)]
 
 use std::ops::{Deref, DerefMut};
diff --git a/tests/ui/explicit_deref_methods.stderr b/tests/ui/explicit_deref_methods.stderr
diff --git a/tests/ui/forget_ref.rs b/tests/ui/forget_ref.rs
diff --git a/tests/ui/forget_ref.stderr b/tests/ui/forget_ref.stderr
diff --git a/tests/ui/needless_deref.rs b/tests/ui/needless_deref.rs
diff --git a/tests/ui/needless_deref.stderr b/tests/ui/needless_deref.stderr

Original file line number	Diff line number	Diff line change
`@@ -151,8 +151,8 @@ fn check_variant(`
`151`	`151`	`}`
`152`	`152`	`}`
`153`	`153`	`let first = &def.variants[0].ident.name.as_str();`
`154`		`- let mut pre = &first[..str_utils::camel_case_until(&*first).byte_index];`
`155`		`- let mut post = &first[str_utils::camel_case_start(&*first).byte_index..];`
	`154`	`+ let mut pre = &first[..str_utils::camel_case_until(first).byte_index];`
	`155`	`+ let mut post = &first[str_utils::camel_case_start(first).byte_index..];`
`156`	`156`	`for var in def.variants {`
`157`	`157`	`let name = var.ident.name.as_str();`
`158`	`158`
Original file line number	Diff line number	Diff line change
`@@ -119,7 +119,7 @@ impl<'a, 'tcx> DivergenceVisitor<'a, 'tcx> {`
`119`	`119`	`self.visit_expr(if_expr);`
`120`	`120`	`}`
`121`	`121`	`// make sure top level arm expressions aren't linted`
`122`		`- self.maybe_walk_expr(&*arm.body);`
	`122`	`+ self.maybe_walk_expr(arm.body);`
`123`	`123`	`}`
`124`	`124`	`},`
`125`	`125`	`_ => walk_expr(self, e),`
Original file line number	Diff line number	Diff line change
`@@ -142,7 +142,7 @@ fn never_loop_expr(expr: &Expr<'_>, main_loop_id: HirId) -> NeverLoopResult {`
`142`	`142`	`if arms.is_empty() {`
`143`	`143`	`e`
`144`	`144`	`} else {`
`145`		`- let arms = never_loop_expr_branch(&mut arms.iter().map(\|a\| &*a.body), main_loop_id);`
	`145`	`+ let arms = never_loop_expr_branch(&mut arms.iter().map(\|a\| a.body), main_loop_id);`
`146`	`146`	`combine_seq(e, arms)`
`147`	`147`	`}`
`148`	`148`	`},`