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 ede9dcb1fbd22a9cceb19f16909f515142452b34..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::{walk_expr, NestedVisitorMap, Visitor};
 use syntax::ast::{Attribute, NodeId};
 use syntax::codemap::Span;
 
-use utils::{in_macro, is_allowed, match_type, paths, span_help_and_lint, LimitStack};
+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"
 }
 
@@ -63,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 {
@@ -147,14 +148,14 @@ 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.hir_id);
                 match ty.sty {
@@ -167,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),
         }
     }