clippy_lints/src/double_parens.rs

   1 use crate::utils::{in_macro, span_lint};
   2 use rustc::lint::{EarlyContext, EarlyLintPass, LintArray, LintPass};
   3 use rustc::{declare_tool_lint, lint_array};
   4 use syntax::ast::*;
   5
   6 declare_clippy_lint! {
   7     /// **What it does:** Checks for unnecessary double parentheses.
   8     ///
   9     /// **Why is this bad?** This makes code harder to read and might indicate a
  10     /// mistake.
  11     ///
  12     /// **Known problems:** None.
  13     ///
  14     /// **Example:**
  15     /// ```rust
  16     /// ((0))
  17     /// foo((0))
  18     /// ((1, 2))
  19     /// ```
  20     pub DOUBLE_PARENS,
  21     complexity,
  22     "Warn on unnecessary double parentheses"
  23 }
  24
  25 #[derive(Copy, Clone)]
  26 pub struct DoubleParens;
  27
  28 impl LintPass for DoubleParens {
  29     fn get_lints(&self) -> LintArray {
  30         lint_array!(DOUBLE_PARENS)
  31     }
  32
  33     fn name(&self) -> &'static str {
  34         "DoubleParens"
  35     }
  36 }
  37
  38 impl EarlyLintPass for DoubleParens {
  39     fn check_expr(&mut self, cx: &EarlyContext<'_>, expr: &Expr) {
  40         if in_macro(expr.span) {
  41             return;
  42         }
  43
  44         match expr.node {
  45             ExprKind::Paren(ref in_paren) => match in_paren.node {
  46                 ExprKind::Paren(_) | ExprKind::Tup(_) => {
  47                     span_lint(
  48                         cx,
  49                         DOUBLE_PARENS,
  50                         expr.span,
  51                         "Consider removing unnecessary double parentheses",
  52                     );
  53                 },
  54                 _ => {},
  55             },
  56             ExprKind::Call(_, ref params) => {
  57                 if params.len() == 1 {
  58                     let param = &params[0];
  59                     if let ExprKind::Paren(_) = param.node {
  60                         span_lint(
  61                             cx,
  62                             DOUBLE_PARENS,
  63                             param.span,
  64                             "Consider removing unnecessary double parentheses",
  65                         );
  66                     }
  67                 }
  68             },
  69             ExprKind::MethodCall(_, ref params) => {
  70                 if params.len() == 2 {
  71                     let param = &params[1];
  72                     if let ExprKind::Paren(_) = param.node {
  73                         span_lint(
  74                             cx,
  75                             DOUBLE_PARENS,
  76                             param.span,
  77                             "Consider removing unnecessary double parentheses",
  78                         );
  79                     }
  80                 }
  81             },
  82             _ => {},
  83         }
  84     }
  85 }