clippy_lints/src/map_clone.rs

   1 // Copyright 2014-2018 The Rust Project Developers. See the COPYRIGHT
   2 // file at the top-level directory of this distribution.
   3 //
   4 // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
   5 // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
   6 // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
   7 // option. This file may not be copied, modified, or distributed
   8 // except according to those terms.
   9
  10
  11 use crate::rustc::hir;
  12 use crate::rustc::lint::{LateContext, LateLintPass, LintArray, LintPass};
  13 use crate::rustc::{declare_tool_lint, lint_array};
  14 use crate::syntax::source_map::Span;
  15 use crate::utils::paths;
  16 use crate::utils::{
  17     in_macro, match_trait_method, match_type,
  18     remove_blocks, snippet,
  19     span_lint_and_sugg,
  20 };
  21 use if_chain::if_chain;
  22 use crate::syntax::ast::Ident;
  23
  24 #[derive(Clone)]
  25 pub struct Pass;
  26
  27 /// **What it does:** Checks for usage of `iterator.map(|x| x.clone())` and suggests
  28 /// `iterator.cloned()` instead
  29 ///
  30 /// **Why is this bad?** Readability, this can be written more concisely
  31 ///
  32 /// **Known problems:** None.
  33 ///
  34 /// **Example:**
  35 ///
  36 /// ```rust
  37 /// let x = vec![42, 43];
  38 /// let y = x.iter();
  39 /// let z = y.map(|i| *i);
  40 /// ```
  41 ///
  42 /// The correct use would be:
  43 ///
  44 /// ```rust
  45 /// let x = vec![42, 43];
  46 /// let y = x.iter();
  47 /// let z = y.cloned();
  48 /// ```
  49 declare_clippy_lint! {
  50     pub MAP_CLONE,
  51     style,
  52     "using `iterator.map(|x| x.clone())`, or dereferencing closures for `Copy` types"
  53 }
  54
  55 impl LintPass for Pass {
  56     fn get_lints(&self) -> LintArray {
  57         lint_array!(MAP_CLONE)
  58     }
  59 }
  60
  61 impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Pass {
  62     fn check_expr(&mut self, cx: &LateContext<'_, '_>, e: &hir::Expr) {
  63         if in_macro(e.span) {
  64             return;
  65         }
  66
  67         if_chain! {
  68             if let hir::ExprKind::MethodCall(ref method, _, ref args) = e.node;
  69             if args.len() == 2;
  70             if method.ident.as_str() == "map";
  71             let ty = cx.tables.expr_ty(&args[0]);
  72             if match_type(cx, ty, &paths::OPTION) || match_trait_method(cx, e, &paths::ITERATOR);
  73             if let hir::ExprKind::Closure(_, _, body_id, _, _) = args[1].node;
  74             let closure_body = cx.tcx.hir.body(body_id);
  75             let closure_expr = remove_blocks(&closure_body.value);
  76             then {
  77                 match closure_body.arguments[0].pat.node {
  78                     hir::PatKind::Ref(ref inner, _) => if let hir::PatKind::Binding(hir::BindingAnnotation::Unannotated, _, name, None) = inner.node {
  79                         lint(cx, e.span, args[0].span, name, closure_expr);
  80                     },
  81                     hir::PatKind::Binding(hir::BindingAnnotation::Unannotated, _, name, None) => match closure_expr.node {
  82                         hir::ExprKind::Unary(hir::UnOp::UnDeref, ref inner) if !cx.tables.expr_ty(inner).is_box() => lint(cx, e.span, args[0].span, name, inner),
  83                         hir::ExprKind::MethodCall(ref method, _, ref obj) => if method.ident.as_str() == "clone" && match_trait_method(cx, closure_expr, &paths::CLONE_TRAIT) {
  84                             lint(cx, e.span, args[0].span, name, &obj[0]);
  85                         }
  86                         _ => {},
  87                     },
  88                     _ => {},
  89                 }
  90             }
  91         }
  92     }
  93 }
  94
  95 fn lint(cx: &LateContext<'_, '_>, replace: Span, root: Span, name: Ident, path: &hir::Expr) {
  96     if let hir::ExprKind::Path(hir::QPath::Resolved(None, ref path)) = path.node {
  97         if path.segments.len() == 1 && path.segments[0].ident == name {
  98             span_lint_and_sugg(
  99                 cx,
 100                 MAP_CLONE,
 101                 replace,
 102                 "You are using an explicit closure for cloning elements",
 103                 "Consider calling the dedicated `cloned` method",
 104                 format!("{}.cloned()", snippet(cx, root, "..")),
 105             )
 106         }
 107     }
 108 }