clippy_lints/src/methods/unnecessary_filter_map.rs

   1 use crate::utils::paths;
   2 use crate::utils::usage::mutated_variables;
   3 use crate::utils::{match_qpath, match_trait_method, span_lint};
   4 use rustc_hir as hir;
   5 use rustc_hir::def::Res;
   6 use rustc_hir::intravisit::{walk_expr, NestedVisitorMap, Visitor};
   7 use rustc_lint::LateContext;
   8 use rustc_middle::hir::map::Map;
   9
  10 use if_chain::if_chain;
  11
  12 use super::UNNECESSARY_FILTER_MAP;
  13
  14 pub(super) fn lint(cx: &LateContext<'_>, expr: &hir::Expr<'_>, args: &[hir::Expr<'_>]) {
  15     if !match_trait_method(cx, expr, &paths::ITERATOR) {
  16         return;
  17     }
  18
  19     if let hir::ExprKind::Closure(_, _, body_id, ..) = args[1].kind {
  20         let body = cx.tcx.hir().body(body_id);
  21         let arg_id = body.params[0].pat.hir_id;
  22         let mutates_arg =
  23             mutated_variables(&body.value, cx).map_or(true, |used_mutably| used_mutably.contains(&arg_id));
  24
  25         let (mut found_mapping, mut found_filtering) = check_expression(&cx, arg_id, &body.value);
  26
  27         let mut return_visitor = ReturnVisitor::new(&cx, arg_id);
  28         return_visitor.visit_expr(&body.value);
  29         found_mapping |= return_visitor.found_mapping;
  30         found_filtering |= return_visitor.found_filtering;
  31
  32         if !found_filtering {
  33             span_lint(
  34                 cx,
  35                 UNNECESSARY_FILTER_MAP,
  36                 expr.span,
  37                 "this `.filter_map` can be written more simply using `.map`",
  38             );
  39             return;
  40         }
  41
  42         if !found_mapping && !mutates_arg {
  43             span_lint(
  44                 cx,
  45                 UNNECESSARY_FILTER_MAP,
  46                 expr.span,
  47                 "this `.filter_map` can be written more simply using `.filter`",
  48             );
  49             return;
  50         }
  51     }
  52 }
  53
  54 // returns (found_mapping, found_filtering)
  55 fn check_expression<'tcx>(cx: &LateContext<'tcx>, arg_id: hir::HirId, expr: &'tcx hir::Expr<'_>) -> (bool, bool) {
  56     match &expr.kind {
  57         hir::ExprKind::Call(ref func, ref args) => {
  58             if_chain! {
  59                 if let hir::ExprKind::Path(ref path) = func.kind;
  60                 then {
  61                     if match_qpath(path, &paths::OPTION_SOME) {
  62                         if_chain! {
  63                             if let hir::ExprKind::Path(path) = &args[0].kind;
  64                             if let Res::Local(ref local) = cx.qpath_res(path, args[0].hir_id);
  65                             then {
  66                                 if arg_id == *local {
  67                                     return (false, false)
  68                                 }
  69                             }
  70                         }
  71                         return (true, false);
  72                     }
  73                     // We don't know. It might do anything.
  74                     return (true, true);
  75                 }
  76             }
  77             (true, true)
  78         },
  79         hir::ExprKind::Block(ref block, _) => block
  80             .expr
  81             .as_ref()
  82             .map_or((false, false), |expr| check_expression(cx, arg_id, &expr)),
  83         hir::ExprKind::Match(_, arms, _) => {
  84             let mut found_mapping = false;
  85             let mut found_filtering = false;
  86             for arm in *arms {
  87                 let (m, f) = check_expression(cx, arg_id, &arm.body);
  88                 found_mapping |= m;
  89                 found_filtering |= f;
  90             }
  91             (found_mapping, found_filtering)
  92         },
  93         // There must be an else_arm or there will be a type error
  94         hir::ExprKind::If(_, ref if_arm, Some(ref else_arm)) => {
  95             let if_check = check_expression(cx, arg_id, if_arm);
  96             let else_check = check_expression(cx, arg_id, else_arm);
  97             (if_check.0 | else_check.0, if_check.1 | else_check.1)
  98         },
  99         hir::ExprKind::Path(path) if match_qpath(path, &paths::OPTION_NONE) => (false, true),
 100         _ => (true, true),
 101     }
 102 }
 103
 104 struct ReturnVisitor<'a, 'tcx> {
 105     cx: &'a LateContext<'tcx>,
 106     arg_id: hir::HirId,
 107     // Found a non-None return that isn't Some(input)
 108     found_mapping: bool,
 109     // Found a return that isn't Some
 110     found_filtering: bool,
 111 }
 112
 113 impl<'a, 'tcx> ReturnVisitor<'a, 'tcx> {
 114     fn new(cx: &'a LateContext<'tcx>, arg_id: hir::HirId) -> ReturnVisitor<'a, 'tcx> {
 115         ReturnVisitor {
 116             cx,
 117             arg_id,
 118             found_mapping: false,
 119             found_filtering: false,
 120         }
 121     }
 122 }
 123
 124 impl<'a, 'tcx> Visitor<'tcx> for ReturnVisitor<'a, 'tcx> {
 125     type Map = Map<'tcx>;
 126
 127     fn visit_expr(&mut self, expr: &'tcx hir::Expr<'_>) {
 128         if let hir::ExprKind::Ret(Some(expr)) = &expr.kind {
 129             let (found_mapping, found_filtering) = check_expression(self.cx, self.arg_id, expr);
 130             self.found_mapping |= found_mapping;
 131             self.found_filtering |= found_filtering;
 132         } else {
 133             walk_expr(self, expr);
 134         }
 135     }
 136
 137     fn nested_visit_map(&mut self) -> NestedVisitorMap<Self::Map> {
 138         NestedVisitorMap::None
 139     }
 140 }