Merge branch 'macro-use' into HEAD

[rust.git] / clippy_lints / src / cyclomatic_complexity.rs

diff --git a/clippy_lints/src/cyclomatic_complexity.rs b/clippy_lints/src/cyclomatic_complexity.rs
index f2ee62995a011047b7e7f14dcc233346ce79115c..c397ca7824e22a404c9e59ec5b48b063c380477d 100644 (file)
--- a/clippy_lints/src/cyclomatic_complexity.rs
+++ b/clippy_lints/src/cyclomatic_complexity.rs
@@ -2,13 +2,14 @@
 
 use rustc::cfg::CFG;
 use rustc::lint::*;
+use rustc::{declare_lint, lint_array};
 use rustc::hir::*;
 use rustc::ty;
-use rustc::hir::intravisit::{Visitor, walk_expr, NestedVisitorMap};
+use rustc::hir::intravisit::{walk_expr, NestedVisitorMap, Visitor};
 use syntax::ast::{Attribute, NodeId};
 use syntax::codemap::Span;
 
-use utils::{in_macro, LimitStack, span_help_and_lint, paths, match_type, is_allowed};
+use crate::utils::{in_macro, is_allowed, match_type, paths, span_help_and_lint, LimitStack};
 
 /// **What it does:** Checks for methods with high cyclomatic complexity.
 ///
@@ -19,9 +20,9 @@
 /// complexity.
 ///
 /// **Example:** No. You'll see it when you get the warning.
-declare_lint! {
+declare_clippy_lint! {
     pub CYCLOMATIC_COMPLEXITY,
-    Warn,
+    complexity,
     "functions that should be split up into multiple functions"
 }
 
@@ -31,7 +32,9 @@ pub struct CyclomaticComplexity {
 
 impl CyclomaticComplexity {
     pub fn new(limit: u64) -> Self {
-        CyclomaticComplexity { limit: LimitStack::new(limit) }
+        Self {
+            limit: LimitStack::new(limit),
+        }
     }
 }
 
@@ -61,7 +64,7 @@ fn check<'a, 'tcx: 'a>(&mut self, cx: &'a LateContext<'a, 'tcx>, body: &'tcx Bod
             divergence: 0,
             short_circuits: 0,
             returns: 0,
-            cx: cx,
+            cx,
         };
         helper.visit_expr(expr);
         let CCHelper {
@@ -71,7 +74,7 @@ fn check<'a, 'tcx: 'a>(&mut self, cx: &'a LateContext<'a, 'tcx>, body: &'tcx Bod
             returns,
             ..
         } = helper;
-        let ret_ty = cx.tables.node_id_to_type(expr.id);
+        let ret_ty = cx.tables.node_id_to_type(expr.hir_id);
         let ret_adjust = if match_type(cx, ret_ty, &paths::RESULT) {
             returns
         } else {
@@ -125,18 +128,12 @@ fn check_fn(
     }
 
     fn enter_lint_attrs(&mut self, cx: &LateContext<'a, 'tcx>, attrs: &'tcx [Attribute]) {
-        self.limit.push_attrs(
-            cx.sess(),
-            attrs,
-            "cyclomatic_complexity",
-        );
+        self.limit
+            .push_attrs(cx.sess(), attrs, "cyclomatic_complexity");
     }
     fn exit_lint_attrs(&mut self, cx: &LateContext<'a, 'tcx>, attrs: &'tcx [Attribute]) {
-        self.limit.pop_attrs(
-            cx.sess(),
-            attrs,
-            "cyclomatic_complexity",
-        );
+        self.limit
+            .pop_attrs(cx.sess(), attrs, "cyclomatic_complexity");
     }
 }
 
@@ -151,16 +148,16 @@ struct CCHelper<'a, 'tcx: 'a> {
 impl<'a, 'tcx> Visitor<'tcx> for CCHelper<'a, 'tcx> {
     fn visit_expr(&mut self, e: &'tcx Expr) {
         match e.node {
-            ExprMatch(_, ref arms, _) => {
+            ExprKind::Match(_, ref arms, _) => {
                 walk_expr(self, e);
                 let arms_n: u64 = arms.iter().map(|arm| arm.pats.len() as u64).sum();
                 if arms_n > 1 {
                     self.match_arms += arms_n - 2;
                 }
             },
-            ExprCall(ref callee, _) => {
+            ExprKind::Call(ref callee, _) => {
                 walk_expr(self, e);
-                let ty = self.cx.tables.node_id_to_type(callee.id);
+                let ty = self.cx.tables.node_id_to_type(callee.hir_id);
                 match ty.sty {
                     ty::TyFnDef(..) | ty::TyFnPtr(_) => {
                         let sig = ty.fn_sig(self.cx.tcx);
@@ -171,15 +168,15 @@ fn visit_expr(&mut self, e: &'tcx Expr) {
                     _ => (),
                 }
             },
-            ExprClosure(..) => (),
-            ExprBinary(op, _, _) => {
+            ExprKind::Closure(.., _) => (),
+            ExprKind::Binary(op, _, _) => {
                 walk_expr(self, e);
                 match op.node {
-                    BiAnd | BiOr => self.short_circuits += 1,
+                    BinOpKind::And | BinOpKind::Or => self.short_circuits += 1,
                     _ => (),
                 }
             },
-            ExprRet(_) => self.returns += 1,
+            ExprKind::Ret(_) => self.returns += 1,
             _ => walk_expr(self, e),
         }
     }
@@ -194,7 +191,7 @@ fn report_cc_bug(_: &LateContext, cc: u64, narms: u64, div: u64, shorts: u64, re
     span_bug!(
         span,
         "Clippy encountered a bug calculating cyclomatic complexity: cc = {}, arms = {}, \
-               div = {}, shorts = {}, returns = {}. Please file a bug report.",
+         div = {}, shorts = {}, returns = {}. Please file a bug report.",
         cc,
         narms,
         div,
@@ -210,9 +207,9 @@ fn report_cc_bug(cx: &LateContext, cc: u64, narms: u64, div: u64, shorts: u64, r
             span,
             &format!(
                 "Clippy encountered a bug calculating cyclomatic complexity \
-                                                    (hide this message with `#[allow(cyclomatic_complexity)]`): \
-                                                    cc = {}, arms = {}, div = {}, shorts = {}, returns = {}. \
-                                                    Please file a bug report.",
+                 (hide this message with `#[allow(cyclomatic_complexity)]`): \
+                 cc = {}, arms = {}, div = {}, shorts = {}, returns = {}. \
+                 Please file a bug report.",
                 cc,
                 narms,
                 div,