Merge pull request #2813 from terry90/master

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

diff --git a/clippy_lints/src/matches.rs b/clippy_lints/src/matches.rs
index b617f098e3e7a27899f6695905e4aab90d61827c..8ab0482bacfdba2bb87bd2f46c6f78b28f0f8415 100644 (file)
--- a/clippy_lints/src/matches.rs
+++ b/clippy_lints/src/matches.rs
@@ -5,11 +5,11 @@
 use std::collections::Bound;
 use syntax::ast::LitKind;
 use syntax::codemap::Span;
-use utils::paths;
-use utils::{expr_block, in_external_macro, is_allowed, is_expn_of, match_qpath, match_type, multispan_sugg,
+use crate::utils::paths;
+use crate::utils::{expr_block, in_external_macro, is_allowed, is_expn_of, match_qpath, match_type, multispan_sugg,
             remove_blocks, snippet, span_lint_and_sugg, span_lint_and_then, span_note_and_lint, walk_ptrs_ty};
-use utils::sugg::Sugg;
-use consts::{constant, Constant};
+use crate::utils::sugg::Sugg;
+use crate::consts::{constant, Constant};
 
 /// **What it does:** Checks for matches with a single arm where an `if let`
 /// will usually suffice.
@@ -25,9 +25,9 @@
 ///     _ => ()
 /// }
 /// ```
-declare_lint! {
+declare_clippy_lint! {
     pub SINGLE_MATCH,
-    Warn,
+    style,
     "a match statement with a single nontrivial arm (i.e. where the other arm \
      is `_ => {}`) instead of `if let`"
 }
@@ -46,9 +46,9 @@
 ///     _ => bar(other_ref),
 /// }
 /// ```
-declare_lint! {
+declare_clippy_lint! {
     pub SINGLE_MATCH_ELSE,
-    Allow,
+    pedantic,
     "a match statement with a two arms where the second arm's pattern is a wildcard \
      instead of `if let`"
 }
@@ -70,9 +70,9 @@
 ///     _ => frob(&x),
 /// }
 /// ```
-declare_lint! {
+declare_clippy_lint! {
     pub MATCH_REF_PATS,
-    Warn,
+    style,
     "a match or `if let` with all arms prefixed with `&` instead of deref-ing the match expression"
 }
 
@@ -91,9 +91,9 @@
 ///     false => bar(),
 /// }
 /// ```
-declare_lint! {
+declare_clippy_lint! {
     pub MATCH_BOOL,
-    Warn,
+    style,
     "a match on a boolean expression instead of an `if..else` block"
 }
 
@@ -113,9 +113,9 @@
 ///     _ => (),
 /// }
 /// ```
-declare_lint! {
+declare_clippy_lint! {
     pub MATCH_OVERLAPPING_ARM,
-    Warn,
+    style,
     "a match with overlapping arms"
 }
 
@@ -135,9 +135,9 @@
 ///     Err(_) => panic!("err"),
 /// }
 /// ```
-declare_lint! {
+declare_clippy_lint! {
     pub MATCH_WILD_ERR_ARM,
-    Warn,
+    style,
     "a match with `Err(_)` arm and take drastic actions"
 }
 
@@ -156,9 +156,9 @@
 ///   Some(ref v) => Some(v),
 /// };
 /// ```
-declare_lint! {
+declare_clippy_lint! {
     pub MATCH_AS_REF,
-    Warn,
+    complexity,
     "a match on an Option value instead of using `as_ref()` or `as_mut`"
 }
 
@@ -205,7 +205,7 @@ fn check_single_match(cx: &LateContext, ex: &Expr, arms: &[Arm], expr: &Expr) {
         let els = remove_blocks(&arms[1].body);
         let els = if is_unit_expr(els) {
             None
-        } else if let ExprBlock(_) = els.node {
+        } else if let ExprBlock(_, _) = els.node {
             // matches with blocks that contain statements are prettier as `if let + else`
             Some(els)
         } else {
@@ -365,7 +365,7 @@ fn check_wild_err_arm(cx: &LateContext, ex: &Expr, arms: &[Arm]) {
                 if_chain! {
                     if path_str == "Err";
                     if inner.iter().any(|pat| pat.node == PatKind::Wild);
-                    if let ExprBlock(ref block) = arm.body.node;
+                    if let ExprBlock(ref block, _) = arm.body.node;
                     if is_panic_block(block);
                     then {
                         // `Err(_)` arm with `panic!` found
@@ -470,8 +470,8 @@ fn all_ranges<'a, 'tcx>(
                 [].iter()
             }.filter_map(|pat| {
                 if let PatKind::Range(ref lhs, ref rhs, ref range_end) = pat.node {
-                    let lhs = constant(cx, lhs)?.0;
-                    let rhs = constant(cx, rhs)?.0;
+                    let lhs = constant(cx, cx.tables, lhs)?.0;
+                    let rhs = constant(cx, cx.tables, rhs)?.0;
                     let rhs = match *range_end {
                         RangeEnd::Included => Bound::Included(rhs),
                         RangeEnd::Excluded => Bound::Excluded(rhs),
@@ -480,7 +480,7 @@ fn all_ranges<'a, 'tcx>(
                 }
 
                 if let PatKind::Lit(ref value) = pat.node {
-                    let value = constant(cx, value)?.0;
+                    let value = constant(cx, cx.tables, value)?.0;
                     return Some(SpannedRange { span: pat.span, node: (value.clone(), Bound::Included(value)) });
                 }
 
@@ -534,7 +534,7 @@ fn type_ranges(ranges: &[SpannedRange<Constant>]) -> TypedRanges {
 fn is_unit_expr(expr: &Expr) -> bool {
     match expr.node {
         ExprTup(ref v) if v.is_empty() => true,
-        ExprBlock(ref b) if b.stmts.is_empty() && b.expr.is_none() => true,
+        ExprBlock(ref b, _) if b.stmts.is_empty() && b.expr.is_none() => true,
         _ => false,
     }
 }