clippy_lints/src/redundant_closure_call.rs

   1 use clippy_utils::diagnostics::{span_lint, span_lint_and_then};
   2 use clippy_utils::source::snippet_with_applicability;
   3 use if_chain::if_chain;
   4 use rustc_ast::ast;
   5 use rustc_ast::visit as ast_visit;
   6 use rustc_ast::visit::Visitor as AstVisitor;
   7 use rustc_errors::Applicability;
   8 use rustc_hir as hir;
   9 use rustc_hir::intravisit as hir_visit;
  10 use rustc_hir::intravisit::Visitor as HirVisitor;
  11 use rustc_lint::{EarlyContext, EarlyLintPass, LateContext, LateLintPass, LintContext};
  12 use rustc_middle::hir::nested_filter;
  13 use rustc_middle::lint::in_external_macro;
  14 use rustc_session::{declare_lint_pass, declare_tool_lint};
  15
  16 declare_clippy_lint! {
  17     /// ### What it does
  18     /// Detects closures called in the same expression where they
  19     /// are defined.
  20     ///
  21     /// ### Why is this bad?
  22     /// It is unnecessarily adding to the expression's
  23     /// complexity.
  24     ///
  25     /// ### Example
  26     /// ```rust
  27     /// let a = (|| 42)();
  28     /// ```
  29     ///
  30     /// Use instead:
  31     /// ```rust
  32     /// let a = 42;
  33     /// ```
  34     #[clippy::version = "pre 1.29.0"]
  35     pub REDUNDANT_CLOSURE_CALL,
  36     complexity,
  37     "throwaway closures called in the expression they are defined"
  38 }
  39
  40 declare_lint_pass!(RedundantClosureCall => [REDUNDANT_CLOSURE_CALL]);
  41
  42 // Used to find `return` statements or equivalents e.g., `?`
  43 struct ReturnVisitor {
  44     found_return: bool,
  45 }
  46
  47 impl ReturnVisitor {
  48     #[must_use]
  49     fn new() -> Self {
  50         Self { found_return: false }
  51     }
  52 }
  53
  54 impl<'ast> ast_visit::Visitor<'ast> for ReturnVisitor {
  55     fn visit_expr(&mut self, ex: &'ast ast::Expr) {
  56         if let ast::ExprKind::Ret(_) | ast::ExprKind::Try(_) = ex.kind {
  57             self.found_return = true;
  58         }
  59
  60         ast_visit::walk_expr(self, ex);
  61     }
  62 }
  63
  64 impl EarlyLintPass for RedundantClosureCall {
  65     fn check_expr(&mut self, cx: &EarlyContext<'_>, expr: &ast::Expr) {
  66         if in_external_macro(cx.sess(), expr.span) {
  67             return;
  68         }
  69         if_chain! {
  70             if let ast::ExprKind::Call(ref paren, _) = expr.kind;
  71             if let ast::ExprKind::Paren(ref closure) = paren.kind;
  72             if let ast::ExprKind::Closure(_, _, _, _, ref decl, ref block, _) = closure.kind;
  73             then {
  74                 let mut visitor = ReturnVisitor::new();
  75                 visitor.visit_expr(block);
  76                 if !visitor.found_return {
  77                     span_lint_and_then(
  78                         cx,
  79                         REDUNDANT_CLOSURE_CALL,
  80                         expr.span,
  81                         "try not to call a closure in the expression where it is declared",
  82                         |diag| {
  83                             if decl.inputs.is_empty() {
  84                                 let mut app = Applicability::MachineApplicable;
  85                                 let hint =
  86                                     snippet_with_applicability(cx, block.span, "..", &mut app).into_owned();
  87                                 diag.span_suggestion(expr.span, "try doing something like", hint, app);
  88                             }
  89                         },
  90                     );
  91                 }
  92             }
  93         }
  94     }
  95 }
  96
  97 impl<'tcx> LateLintPass<'tcx> for RedundantClosureCall {
  98     fn check_block(&mut self, cx: &LateContext<'tcx>, block: &'tcx hir::Block<'_>) {
  99         fn count_closure_usage<'a, 'tcx>(
 100             cx: &'a LateContext<'tcx>,
 101             block: &'tcx hir::Block<'_>,
 102             path: &'tcx hir::Path<'tcx>,
 103         ) -> usize {
 104             struct ClosureUsageCount<'a, 'tcx> {
 105                 cx: &'a LateContext<'tcx>,
 106                 path: &'tcx hir::Path<'tcx>,
 107                 count: usize,
 108             }
 109             impl<'a, 'tcx> hir_visit::Visitor<'tcx> for ClosureUsageCount<'a, 'tcx> {
 110                 type NestedFilter = nested_filter::OnlyBodies;
 111
 112                 fn visit_expr(&mut self, expr: &'tcx hir::Expr<'tcx>) {
 113                     if_chain! {
 114                         if let hir::ExprKind::Call(closure, _) = expr.kind;
 115                         if let hir::ExprKind::Path(hir::QPath::Resolved(_, path)) = closure.kind;
 116                         if self.path.segments[0].ident == path.segments[0].ident;
 117                         if self.path.res == path.res;
 118                         then {
 119                             self.count += 1;
 120                         }
 121                     }
 122                     hir_visit::walk_expr(self, expr);
 123                 }
 124
 125                 fn nested_visit_map(&mut self) -> Self::Map {
 126                     self.cx.tcx.hir()
 127                 }
 128             }
 129             let mut closure_usage_count = ClosureUsageCount { cx, path, count: 0 };
 130             closure_usage_count.visit_block(block);
 131             closure_usage_count.count
 132         }
 133
 134         for w in block.stmts.windows(2) {
 135             if_chain! {
 136                 if let hir::StmtKind::Local(local) = w[0].kind;
 137                 if let Option::Some(t) = local.init;
 138                 if let hir::ExprKind::Closure { .. } = t.kind;
 139                 if let hir::PatKind::Binding(_, _, ident, _) = local.pat.kind;
 140                 if let hir::StmtKind::Semi(second) = w[1].kind;
 141                 if let hir::ExprKind::Assign(_, call, _) = second.kind;
 142                 if let hir::ExprKind::Call(closure, _) = call.kind;
 143                 if let hir::ExprKind::Path(hir::QPath::Resolved(_, path)) = closure.kind;
 144                 if ident == path.segments[0].ident;
 145                 if count_closure_usage(cx, block, path) == 1;
 146                 then {
 147                     span_lint(
 148                         cx,
 149                         REDUNDANT_CLOSURE_CALL,
 150                         second.span,
 151                         "closure called just once immediately after it was declared",
 152                     );
 153                 }
 154             }
 155         }
 156     }
 157 }