src/tools/clippy/clippy_lints/src/redundant_closure_call.rs

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