Merge branch 'master' into issue2894

Author: Michael Wright

.travis.yml

@@ -48,8 +48,6 @@ matrix:
     - env: INTEGRATION=serde-rs/serde
     - env: INTEGRATION=Geal/nom
     - env: INTEGRATION=hyperium/hyper
-    - env: INTEGRATION=rust-lang/cargo
-    - env: INTEGRATION=rust-lang-nursery/rls
 
 script:
   - |

clippy_lints/Cargo.toml

@@ -21,8 +21,8 @@ edition = "2018"
 [dependencies]
 cargo_metadata = "0.5"
 itertools = "0.7"
-lazy_static = "1.0"
-matches = "0.1.2"
+lazy_static = "1.0.2"
+matches = "0.1.7"
 quine-mc_cluskey = "0.2.2"
 regex-syntax = "0.6"
 semver = "0.9.0"
@@ -32,7 +32,7 @@ toml = "0.4"
 unicode-normalization = "0.1"
 pulldown-cmark = "0.1"
 url = "1.7.0"
-if_chain = "0.1"
+if_chain = "0.1.3"
 
 [features]
 debugging = []

clippy_lints/src/approx_const.rs

@@ -1,6 +1,7 @@
 use crate::utils::span_lint;
 use rustc::hir::*;
 use rustc::lint::*;
+use rustc::{declare_lint, lint_array};
 use std::f64::consts as f64;
 use syntax::ast::{FloatTy, Lit, LitKind};
 use syntax::symbol;
@@ -69,7 +70,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Pass {
     }
 }
 
-fn check_lit(cx: &LateContext, lit: &Lit, e: &Expr) {
+fn check_lit(cx: &LateContext<'_, '_>, lit: &Lit, e: &Expr) {
     match lit.node {
         LitKind::Float(s, FloatTy::F32) => check_known_consts(cx, e, s, "f32"),
         LitKind::Float(s, FloatTy::F64) => check_known_consts(cx, e, s, "f64"),
@@ -78,7 +79,7 @@ fn check_lit(cx: &LateContext, lit: &Lit, e: &Expr) {
     }
 }
 
-fn check_known_consts(cx: &LateContext, e: &Expr, s: symbol::Symbol, module: &str) {
+fn check_known_consts(cx: &LateContext<'_, '_>, e: &Expr, s: symbol::Symbol, module: &str) {
     let s = s.as_str();
     if s.parse::<f64>().is_ok() {
         for &(constant, name, min_digits) in KNOWN_CONSTS {

clippy_lints/src/arithmetic.rs

@@ -1,6 +1,7 @@
 use crate::utils::span_lint;
 use rustc::hir;
 use rustc::lint::*;
+use rustc::{declare_lint, lint_array};
 use syntax::codemap::Span;
 
 /// **What it does:** Checks for plain integer arithmetic.

clippy_lints/src/assign_ops.rs

@@ -3,6 +3,8 @@ use crate::utils::{higher, sugg};
 use rustc::hir;
 use rustc::hir::intravisit::{walk_expr, NestedVisitorMap, Visitor};
 use rustc::lint::*;
+use rustc::{declare_lint, lint_array};
+use if_chain::if_chain;
 use syntax::ast;
 
 /// **What it does:** Checks for compound assignment operations (`+=` and
@@ -49,8 +51,10 @@ declare_clippy_lint! {
 /// **Why is this bad?** Most likely these are bugs where one meant to write `a
 /// op= b`.
 ///
-/// **Known problems:** Someone might actually mean `a op= a op b`, but that
-/// should rather be written as `a = (2 * a) op b` where applicable.
+/// **Known problems:** Clippy cannot know for sure if `a op= a op b` should have
+/// been `a = a op a op b` or `a = a op b`/`a op= b`. Therefore it suggests both.
+/// If `a op= a op b` is really the correct behaviour it should be
+/// written as `a = a op a op b` as it's less confusing.
 ///
 /// **Example:**
 /// ```rust

clippy_lints/src/attrs.rs

@@ -7,6 +7,8 @@ use crate::utils::{
 };
 use rustc::hir::*;
 use rustc::lint::*;
+use rustc::{declare_lint, lint_array};
+use if_chain::if_chain;
 use rustc::ty::{self, TyCtxt};
 use semver::Version;
 use syntax::ast::{AttrStyle, Attribute, Lit, LitKind, MetaItemKind, NestedMetaItem, NestedMetaItemKind};
@@ -39,22 +41,31 @@ declare_clippy_lint! {
 }
 
 /// **What it does:** Checks for `extern crate` and `use` items annotated with
-/// lint attributes
+/// lint attributes.
+///
+/// This lint whitelists `#[allow(unused_imports)]` and `#[allow(deprecated)]` on
+/// `use` items and `#[allow(unused_imports)]` on `extern crate` items with a
+/// `#[macro_use]` attribute.
 ///
 /// **Why is this bad?** Lint attributes have no effect on crate imports. Most
-/// likely a `!` was
-/// forgotten
+/// likely a `!` was forgotten.
 ///
-/// **Known problems:** Technically one might allow `unused_import` on a `use`
-/// item,
-/// but it's easier to remove the unused item.
+/// **Known problems:** None.
 ///
 /// **Example:**
 /// ```rust
+/// // Bad
 /// #[deny(dead_code)]
 /// extern crate foo;
-/// #[allow(unused_import)]
+/// #[forbid(dead_code)]
 /// use foo::bar;
+///
+/// // Ok
+/// #[allow(unused_imports)]
+/// use foo::baz;
+/// #[allow(unused_imports)]
+/// #[macro_use]
+/// extern crate baz;
 /// ```
 declare_clippy_lint! {
     pub USELESS_ATTRIBUTE,
@@ -154,17 +165,26 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for AttrPass {
             check_attrs(cx, item.span, item.name, &item.attrs)
         }
         match item.node {
-            ItemKind::ExternCrate(_) | ItemKind::Use(_, _) => {
+            ItemKind::ExternCrate(..) | ItemKind::Use(..) => {
+                let skip_unused_imports = item.attrs.iter().any(|attr| attr.name() == "macro_use");
+
                 for attr in &item.attrs {
                     if let Some(ref lint_list) = attr.meta_item_list() {
                         match &*attr.name().as_str() {
                             "allow" | "warn" | "deny" | "forbid" => {
-                                // whitelist `unused_imports` and `deprecated`
+                                // whitelist `unused_imports` and `deprecated` for `use` items
+                                // and `unused_imports` for `extern crate` items with `macro_use`
                                 for lint in lint_list {
-                                    if is_word(lint, "unused_imports") || is_word(lint, "deprecated") {
-                                        if let ItemKind::Use(_, _) = item.node {
-                                            return;
-                                        }
+                                    match item.node {
+                                        ItemKind::Use(..) => if is_word(lint, "unused_imports")
+                                                                || is_word(lint, "deprecated") {
+                                                return
+                                        },
+                                        ItemKind::ExternCrate(..) => if is_word(lint, "unused_imports")
+                                                                        && skip_unused_imports {
+                                                return
+                                        },
+                                        _ => {},
                                     }
                                 }
                                 let line_span = last_line_of_span(cx, attr.span);
@@ -206,22 +226,22 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for AttrPass {
     }
 }
 
-fn is_relevant_item(tcx: TyCtxt, item: &Item) -> bool {
+fn is_relevant_item(tcx: TyCtxt<'_, '_, '_>, item: &Item) -> bool {
     if let ItemKind::Fn(_, _, _, eid) = item.node {
         is_relevant_expr(tcx, tcx.body_tables(eid), &tcx.hir.body(eid).value)
     } else {
         true
     }
 }
 
-fn is_relevant_impl(tcx: TyCtxt, item: &ImplItem) -> bool {
+fn is_relevant_impl(tcx: TyCtxt<'_, '_, '_>, item: &ImplItem) -> bool {
     match item.node {
         ImplItemKind::Method(_, eid) => is_relevant_expr(tcx, tcx.body_tables(eid), &tcx.hir.body(eid).value),
         _ => false,
     }
 }
 
-fn is_relevant_trait(tcx: TyCtxt, item: &TraitItem) -> bool {
+fn is_relevant_trait(tcx: TyCtxt<'_, '_, '_>, item: &TraitItem) -> bool {
     match item.node {
         TraitItemKind::Method(_, TraitMethod::Required(_)) => true,
         TraitItemKind::Method(_, TraitMethod::Provided(eid)) => {
@@ -231,7 +251,7 @@ fn is_relevant_trait(tcx: TyCtxt, item: &TraitItem) -> bool {
     }
 }
 
-fn is_relevant_block(tcx: TyCtxt, tables: &ty::TypeckTables, block: &Block) -> bool {
+fn is_relevant_block(tcx: TyCtxt<'_, '_, '_>, tables: &ty::TypeckTables<'_>, block: &Block) -> bool {
     if let Some(stmt) = block.stmts.first() {
         match stmt.node {
             StmtKind::Decl(_, _) => true,
@@ -242,7 +262,7 @@ fn is_relevant_block(tcx: TyCtxt, tables: &ty::TypeckTables, block: &Block) -> b
     }
 }
 
-fn is_relevant_expr(tcx: TyCtxt, tables: &ty::TypeckTables, expr: &Expr) -> bool {
+fn is_relevant_expr(tcx: TyCtxt<'_, '_, '_>, tables: &ty::TypeckTables<'_>, expr: &Expr) -> bool {
     match expr.node {
         ExprKind::Block(ref block, _) => is_relevant_block(tcx, tables, block),
         ExprKind::Ret(Some(ref e)) => is_relevant_expr(tcx, tables, e),
@@ -260,7 +280,7 @@ fn is_relevant_expr(tcx: TyCtxt, tables: &ty::TypeckTables, expr: &Expr) -> bool
     }
 }
 
-fn check_attrs(cx: &LateContext, span: Span, name: Name, attrs: &[Attribute]) {
+fn check_attrs(cx: &LateContext<'_, '_>, span: Span, name: Name, attrs: &[Attribute]) {
     if in_macro(span) {
         return;
     }
@@ -311,7 +331,7 @@ fn check_attrs(cx: &LateContext, span: Span, name: Name, attrs: &[Attribute]) {
     }
 }
 
-fn check_semver(cx: &LateContext, span: Span, lit: &Lit) {
+fn check_semver(cx: &LateContext<'_, '_>, span: Span, lit: &Lit) {
     if let LitKind::Str(ref is, _) = lit.node {
         if Version::parse(&is.as_str()).is_ok() {
             return;
@@ -338,7 +358,7 @@ fn is_word(nmi: &NestedMetaItem, expected: &str) -> bool {
 // sources that the user has no control over.
 // For some reason these attributes don't have any expansion info on them, so
 // we have to check it this way until there is a better way.
-fn is_present_in_source(cx: &LateContext, span: Span) -> bool {
+fn is_present_in_source(cx: &LateContext<'_, '_>, span: Span) -> bool {
     if let Some(snippet) = snippet_opt(cx, span) {
         if snippet.is_empty() {
             return false;

clippy_lints/src/bit_mask.rs

@@ -1,5 +1,7 @@
 use rustc::hir::*;
 use rustc::lint::*;
+use rustc::{declare_lint, lint_array};
+use if_chain::if_chain;
 use syntax::ast::LitKind;
 use syntax::codemap::Span;
 use crate::utils::{span_lint, span_lint_and_then};
@@ -156,7 +158,7 @@ fn invert_cmp(cmp: BinOpKind) -> BinOpKind {
 }
 
 
-fn check_compare(cx: &LateContext, bit_op: &Expr, cmp_op: BinOpKind, cmp_value: u128, span: Span) {
+fn check_compare(cx: &LateContext<'_, '_>, bit_op: &Expr, cmp_op: BinOpKind, cmp_value: u128, span: Span) {
     if let ExprKind::Binary(ref op, ref left, ref right) = bit_op.node {
         if op.node != BinOpKind::BitAnd && op.node != BinOpKind::BitOr {
             return;
@@ -167,7 +169,7 @@ fn check_compare(cx: &LateContext, bit_op: &Expr, cmp_op: BinOpKind, cmp_value:
     }
 }
 
-fn check_bit_mask(cx: &LateContext, bit_op: BinOpKind, cmp_op: BinOpKind, mask_value: u128, cmp_value: u128, span: Span) {
+fn check_bit_mask(cx: &LateContext<'_, '_>, bit_op: BinOpKind, cmp_op: BinOpKind, mask_value: u128, cmp_value: u128, span: Span) {
     match cmp_op {
         BinOpKind::Eq | BinOpKind::Ne => match bit_op {
             BinOpKind::BitAnd => if mask_value & cmp_value != cmp_value {
@@ -268,7 +270,7 @@ fn check_bit_mask(cx: &LateContext, bit_op: BinOpKind, cmp_op: BinOpKind, mask_v
     }
 }
 
-fn check_ineffective_lt(cx: &LateContext, span: Span, m: u128, c: u128, op: &str) {
+fn check_ineffective_lt(cx: &LateContext<'_, '_>, span: Span, m: u128, c: u128, op: &str) {
     if c.is_power_of_two() && m < c {
         span_lint(
             cx,
@@ -284,7 +286,7 @@ fn check_ineffective_lt(cx: &LateContext, span: Span, m: u128, c: u128, op: &str
     }
 }
 
-fn check_ineffective_gt(cx: &LateContext, span: Span, m: u128, c: u128, op: &str) {
+fn check_ineffective_gt(cx: &LateContext<'_, '_>, span: Span, m: u128, c: u128, op: &str) {
     if (c + 1).is_power_of_two() && m <= c {
         span_lint(
             cx,
@@ -300,7 +302,7 @@ fn check_ineffective_gt(cx: &LateContext, span: Span, m: u128, c: u128, op: &str
     }
 }
 
-fn fetch_int_literal(cx: &LateContext, lit: &Expr) -> Option<u128> {
+fn fetch_int_literal(cx: &LateContext<'_, '_>, lit: &Expr) -> Option<u128> {
     match constant(cx, cx.tables, lit)?.0 {
         Constant::Int(n) => Some(n),
         _ => None,

clippy_lints/src/blacklisted_name.rs

@@ -1,4 +1,5 @@
 use rustc::lint::*;
+use rustc::{declare_lint, lint_array};
 use rustc::hir::*;
 use crate::utils::span_lint;
 

clippy_lints/src/block_in_if_condition.rs

@@ -1,4 +1,6 @@
+use matches::matches;
 use rustc::lint::{LateContext, LateLintPass, LintArray, LintPass};
+use rustc::{declare_lint, lint_array};
 use rustc::hir::*;
 use rustc::hir::intravisit::{walk_expr, NestedVisitorMap, Visitor};
 use crate::utils::*;

clippy_lints/src/booleans.rs

@@ -1,4 +1,5 @@
 use rustc::lint::{LateContext, LateLintPass, LintArray, LintPass};
+use rustc::{declare_lint, lint_array};
 use rustc::hir::*;
 use rustc::hir::intravisit::*;
 use syntax::ast::{LitKind, NodeId, DUMMY_NODE_ID};
@@ -274,7 +275,7 @@ impl<'a, 'tcx, 'v> SuggestContext<'a, 'tcx, 'v> {
 }
 
 // The boolean part of the return indicates whether some simplifications have been applied.
-fn suggest(cx: &LateContext, suggestion: &Bool, terminals: &[&Expr]) -> (String, bool) {
+fn suggest(cx: &LateContext<'_, '_>, suggestion: &Bool, terminals: &[&Expr]) -> (String, bool) {
     let mut suggest_context = SuggestContext {
         terminals,
         cx,

clippy_lints/src/bytecount.rs

@@ -1,5 +1,7 @@
 use rustc::hir::*;
 use rustc::lint::*;
+use rustc::{declare_lint, lint_array};
+use if_chain::if_chain;
 use rustc::ty;
 use syntax::ast::{Name, UintTy};
 use crate::utils::{contains_name, get_pat_name, match_type, paths, single_segment_path, snippet, span_lint_and_sugg,
@@ -36,7 +38,7 @@ impl LintPass for ByteCount {
 }
 
 impl<'a, 'tcx> LateLintPass<'a, 'tcx> for ByteCount {
-    fn check_expr(&mut self, cx: &LateContext, expr: &Expr) {
+    fn check_expr(&mut self, cx: &LateContext<'_, '_>, expr: &Expr) {
         if_chain! {
             if let ExprKind::MethodCall(ref count, _, ref count_args) = expr.node;
             if count.ident.name == "count";

clippy_lints/src/collapsible_if.rs

@@ -13,6 +13,8 @@
 //! This lint is **warn** by default
 
 use rustc::lint::*;
+use rustc::{declare_lint, lint_array};
+use if_chain::if_chain;
 use syntax::ast;
 
 use crate::utils::{in_macro, snippet_block, span_lint_and_sugg, span_lint_and_then};
@@ -78,14 +80,14 @@ impl LintPass for CollapsibleIf {
 }
 
 impl EarlyLintPass for CollapsibleIf {
-    fn check_expr(&mut self, cx: &EarlyContext, expr: &ast::Expr) {
+    fn check_expr(&mut self, cx: &EarlyContext<'_>, expr: &ast::Expr) {
         if !in_macro(expr.span) {
             check_if(cx, expr)
         }
     }
 }
 
-fn check_if(cx: &EarlyContext, expr: &ast::Expr) {
+fn check_if(cx: &EarlyContext<'_>, expr: &ast::Expr) {
     match expr.node {
         ast::ExprKind::If(ref check, ref then, ref else_) => if let Some(ref else_) = *else_ {
             check_collapsible_maybe_if_let(cx, else_);
@@ -99,7 +101,7 @@ fn check_if(cx: &EarlyContext, expr: &ast::Expr) {
     }
 }
 
-fn check_collapsible_maybe_if_let(cx: &EarlyContext, else_: &ast::Expr) {
+fn check_collapsible_maybe_if_let(cx: &EarlyContext<'_>, else_: &ast::Expr) {
     if_chain! {
         if let ast::ExprKind::Block(ref block, _) = else_.node;
         if let Some(else_) = expr_block(block);
@@ -120,7 +122,7 @@ fn check_collapsible_maybe_if_let(cx: &EarlyContext, else_: &ast::Expr) {
     }
 }
 
-fn check_collapsible_no_if_let(cx: &EarlyContext, expr: &ast::Expr, check: &ast::Expr, then: &ast::Block) {
+fn check_collapsible_no_if_let(cx: &EarlyContext<'_>, expr: &ast::Expr, check: &ast::Expr, then: &ast::Block) {
     if_chain! {
         if let Some(inner) = expr_block(then);
         if let ast::ExprKind::If(ref check_inner, ref content, None) = inner.node;