src/tools/clippy/clippy_lints/src/methods/unnecessary_filter_map.rs

   1 use clippy_utils::diagnostics::span_lint;
   2 use clippy_utils::usage::mutated_variables;
   3 use clippy_utils::{is_lang_ctor, is_trait_method, path_to_local_id};
   4 use rustc_hir as hir;
   5 use rustc_hir::intravisit::{walk_expr, Visitor};
   6 use rustc_hir::LangItem::{OptionNone, OptionSome};
   7 use rustc_lint::LateContext;
   8 use rustc_middle::ty;
   9 use rustc_span::sym;
  10
  11 use super::UNNECESSARY_FILTER_MAP;
  12
  13 pub(super) fn check(cx: &LateContext<'_>, expr: &hir::Expr<'_>, arg: &hir::Expr<'_>) {
  14     if !is_trait_method(cx, expr, sym::Iterator) {
  15         return;
  16     }
  17
  18     if let hir::ExprKind::Closure(_, _, body_id, ..) = arg.kind {
  19         let body = cx.tcx.hir().body(body_id);
  20         let arg_id = body.params[0].pat.hir_id;
  21         let mutates_arg =
  22             mutated_variables(&body.value, cx).map_or(true, |used_mutably| used_mutably.contains(&arg_id));
  23
  24         let (mut found_mapping, mut found_filtering) = check_expression(cx, arg_id, &body.value);
  25
  26         let mut return_visitor = ReturnVisitor::new(cx, arg_id);
  27         return_visitor.visit_expr(&body.value);
  28         found_mapping |= return_visitor.found_mapping;
  29         found_filtering |= return_visitor.found_filtering;
  30
  31         let sugg = if !found_filtering {
  32             "map"
  33         } else if !found_mapping && !mutates_arg {
  34             let in_ty = cx.typeck_results().node_type(body.params[0].hir_id);
  35             match cx.typeck_results().expr_ty(&body.value).kind() {
  36                 ty::Adt(adt, subst)
  37                     if cx.tcx.is_diagnostic_item(sym::Option, adt.did) && in_ty == subst.type_at(0) =>
  38                 {
  39                     "filter"
  40                 },
  41                 _ => return,
  42             }
  43         } else {
  44             return;
  45         };
  46         span_lint(
  47             cx,
  48             UNNECESSARY_FILTER_MAP,
  49             expr.span,
  50             &format!("this `.filter_map` can be written more simply using `.{}`", sugg),
  51         );
  52     }
  53 }
  54
  55 // returns (found_mapping, found_filtering)
  56 fn check_expression<'tcx>(cx: &LateContext<'tcx>, arg_id: hir::HirId, expr: &'tcx hir::Expr<'_>) -> (bool, bool) {
  57     match &expr.kind {
  58         hir::ExprKind::Call(func, args) => {
  59             if let hir::ExprKind::Path(ref path) = func.kind {
  60                 if is_lang_ctor(cx, path, OptionSome) {
  61                     if path_to_local_id(&args[0], arg_id) {
  62                         return (false, false);
  63                     }
  64                     return (true, false);
  65                 }
  66             }
  67             (true, true)
  68         },
  69         hir::ExprKind::Block(block, _) => block
  70             .expr
  71             .as_ref()
  72             .map_or((false, false), |expr| check_expression(cx, arg_id, expr)),
  73         hir::ExprKind::Match(_, arms, _) => {
  74             let mut found_mapping = false;
  75             let mut found_filtering = false;
  76             for arm in *arms {
  77                 let (m, f) = check_expression(cx, arg_id, arm.body);
  78                 found_mapping |= m;
  79                 found_filtering |= f;
  80             }
  81             (found_mapping, found_filtering)
  82         },
  83         // There must be an else_arm or there will be a type error
  84         hir::ExprKind::If(_, if_arm, Some(else_arm)) => {
  85             let if_check = check_expression(cx, arg_id, if_arm);
  86             let else_check = check_expression(cx, arg_id, else_arm);
  87             (if_check.0 | else_check.0, if_check.1 | else_check.1)
  88         },
  89         hir::ExprKind::Path(path) if is_lang_ctor(cx, path, OptionNone) => (false, true),
  90         _ => (true, true),
  91     }
  92 }
  93
  94 struct ReturnVisitor<'a, 'tcx> {
  95     cx: &'a LateContext<'tcx>,
  96     arg_id: hir::HirId,
  97     // Found a non-None return that isn't Some(input)
  98     found_mapping: bool,
  99     // Found a return that isn't Some
 100     found_filtering: bool,
 101 }
 102
 103 impl<'a, 'tcx> ReturnVisitor<'a, 'tcx> {
 104     fn new(cx: &'a LateContext<'tcx>, arg_id: hir::HirId) -> ReturnVisitor<'a, 'tcx> {
 105         ReturnVisitor {
 106             cx,
 107             arg_id,
 108             found_mapping: false,
 109             found_filtering: false,
 110         }
 111     }
 112 }
 113
 114 impl<'a, 'tcx> Visitor<'tcx> for ReturnVisitor<'a, 'tcx> {
 115     fn visit_expr(&mut self, expr: &'tcx hir::Expr<'_>) {
 116         if let hir::ExprKind::Ret(Some(expr)) = &expr.kind {
 117             let (found_mapping, found_filtering) = check_expression(self.cx, self.arg_id, expr);
 118             self.found_mapping |= found_mapping;
 119             self.found_filtering |= found_filtering;
 120         } else {
 121             walk_expr(self, expr);
 122         }
 123     }
 124 }