From 1d7d4e9217fc1be375e5f5d63b1d8e94f4cd61c4 Mon Sep 17 00:00:00 2001 From: Yuki Okushi Date: Sat, 11 Jan 2020 09:05:51 +0900 Subject: [PATCH 1/8] Rustup to rust-lang/rust#67258 --- clippy_lints/src/matches.rs | 22 ++++++++++++---------- clippy_lints/src/utils/author.rs | 8 ++++++-- clippy_lints/src/utils/hir_utils.rs | 5 ++++- clippy_lints/src/utils/inspector.rs | 8 ++++++-- 4 files changed, 28 insertions(+), 15 deletions(-) diff --git a/clippy_lints/src/matches.rs b/clippy_lints/src/matches.rs index 6b5b4e4c4f0..5aed9770d2e 100644 --- a/clippy_lints/src/matches.rs +++ b/clippy_lints/src/matches.rs @@ -713,16 +713,18 @@ fn all_ranges<'a, 'tcx>(cx: &LateContext<'a, 'tcx>, arms: &'tcx [Arm<'_>]) -> Ve } = *arm { if let PatKind::Range(ref lhs, ref rhs, ref range_end) = pat.kind { - 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), - }; - return Some(SpannedRange { - span: pat.span, - node: (lhs, rhs), - }); + if let (Some(l), Some(r)) = (lhs, rhs) { + let lhs = constant(cx, cx.tables, l)?.0; + let rhs = constant(cx, cx.tables, r)?.0; + let rhs = match *range_end { + RangeEnd::Included => Bound::Included(rhs), + RangeEnd::Excluded => Bound::Excluded(rhs), + }; + return Some(SpannedRange { + span: pat.span, + node: (lhs, rhs), + }); + } } if let PatKind::Lit(ref value) = pat.kind { diff --git a/clippy_lints/src/utils/author.rs b/clippy_lints/src/utils/author.rs index 902c3e2b7e7..b9f11f79a37 100644 --- a/clippy_lints/src/utils/author.rs +++ b/clippy_lints/src/utils/author.rs @@ -617,9 +617,13 @@ impl<'tcx> Visitor<'tcx> for PrintVisitor { start_pat, end_pat, end_kind, current ); self.current = start_pat; - self.visit_expr(start); + if let Some(expr) = start { + self.visit_expr(expr); + } self.current = end_pat; - self.visit_expr(end); + if let Some(expr) = end { + self.visit_expr(expr); + } }, PatKind::Slice(ref start, ref middle, ref end) => { let start_pat = self.next("start"); diff --git a/clippy_lints/src/utils/hir_utils.rs b/clippy_lints/src/utils/hir_utils.rs index 13ea90cff59..00baad72e6d 100644 --- a/clippy_lints/src/utils/hir_utils.rs +++ b/clippy_lints/src/utils/hir_utils.rs @@ -195,7 +195,10 @@ impl<'a, 'tcx> SpanlessEq<'a, 'tcx> { ls == rs && over(l, r, |l, r| self.eq_pat(l, r)) }, (&PatKind::Range(ref ls, ref le, ref li), &PatKind::Range(ref rs, ref re, ref ri)) => { - self.eq_expr(ls, rs) && self.eq_expr(le, re) && (*li == *ri) + if let (Some(ls), Some(rs), Some(le), Some(re)) = (ls, rs, le, re) { + return self.eq_expr(ls, rs) && self.eq_expr(le, re) && (*li == *ri); + } + false }, (&PatKind::Ref(ref le, ref lm), &PatKind::Ref(ref re, ref rm)) => lm == rm && self.eq_pat(le, re), (&PatKind::Slice(ref ls, ref li, ref le), &PatKind::Slice(ref rs, ref ri, ref re)) => { diff --git a/clippy_lints/src/utils/inspector.rs b/clippy_lints/src/utils/inspector.rs index 38bf6ee5239..eb889ccc75c 100644 --- a/clippy_lints/src/utils/inspector.rs +++ b/clippy_lints/src/utils/inspector.rs @@ -483,8 +483,12 @@ fn print_pat(cx: &LateContext<'_, '_>, pat: &hir::Pat<'_>, indent: usize) { }, hir::PatKind::Range(ref l, ref r, ref range_end) => { println!("{}Range", ind); - print_expr(cx, l, indent + 1); - print_expr(cx, r, indent + 1); + if let Some(expr) = l { + print_expr(cx, expr, indent + 1); + } + if let Some(expr) = r { + print_expr(cx, expr, indent + 1); + } match *range_end { hir::RangeEnd::Included => println!("{} end included", ind), hir::RangeEnd::Excluded => println!("{} end excluded", ind), From 8daa2784c7ca136b6aa70a75cb7d8b48b1b94117 Mon Sep 17 00:00:00 2001 From: Yuki Okushi Date: Sat, 11 Jan 2020 09:06:09 +0900 Subject: [PATCH 2/8] Rustup to rust-lang/rust#68101 --- clippy_lints/src/needless_pass_by_value.rs | 3 +-- clippy_lints/src/types.rs | 3 +-- clippy_lints/src/utils/diagnostics.rs | 3 +-- 3 files changed, 3 insertions(+), 6 deletions(-) diff --git a/clippy_lints/src/needless_pass_by_value.rs b/clippy_lints/src/needless_pass_by_value.rs index 12be861a9ff..3d40618fbf4 100644 --- a/clippy_lints/src/needless_pass_by_value.rs +++ b/clippy_lints/src/needless_pass_by_value.rs @@ -11,7 +11,7 @@ use rustc::traits; use rustc::traits::misc::can_type_implement_copy; use rustc::ty::{self, RegionKind, TypeFoldable}; use rustc_data_structures::fx::{FxHashMap, FxHashSet}; -use rustc_errors::Applicability; +use rustc_errors::{Applicability, DiagnosticBuilder}; use rustc_hir::intravisit::FnKind; use rustc_hir::*; use rustc_session::declare_tool_lint; @@ -20,7 +20,6 @@ use rustc_target::spec::abi::Abi; use rustc_typeck::expr_use_visitor as euv; use std::borrow::Cow; use syntax::ast::Attribute; -use syntax::errors::DiagnosticBuilder; declare_clippy_lint! { /// **What it does:** Checks for functions taking arguments by value, but not diff --git a/clippy_lints/src/types.rs b/clippy_lints/src/types.rs index 3edc220eda4..cebbbac1699 100644 --- a/clippy_lints/src/types.rs +++ b/clippy_lints/src/types.rs @@ -10,7 +10,7 @@ use rustc::lint::{in_external_macro, LateContext, LateLintPass, LintArray, LintC use rustc::ty::layout::LayoutOf; use rustc::ty::{self, InferTy, Ty, TyCtxt, TypeckTables}; use rustc::{declare_lint_pass, impl_lint_pass}; -use rustc_errors::Applicability; +use rustc_errors::{Applicability, DiagnosticBuilder}; use rustc_hir as hir; use rustc_hir::intravisit::{walk_body, walk_expr, walk_ty, FnKind, NestedVisitorMap, Visitor}; use rustc_hir::*; @@ -21,7 +21,6 @@ use rustc_span::symbol::{sym, Symbol}; use rustc_target::spec::abi::Abi; use rustc_typeck::hir_ty_to_ty; use syntax::ast::{FloatTy, IntTy, LitFloatType, LitIntType, LitKind, UintTy}; -use syntax::errors::DiagnosticBuilder; use crate::consts::{constant, Constant}; use crate::utils::paths; diff --git a/clippy_lints/src/utils/diagnostics.rs b/clippy_lints/src/utils/diagnostics.rs index 629dc0950dc..2e586e738f6 100644 --- a/clippy_lints/src/utils/diagnostics.rs +++ b/clippy_lints/src/utils/diagnostics.rs @@ -1,11 +1,10 @@ //! Clippy wrappers around rustc's diagnostic functions. use rustc::lint::{LateContext, Lint, LintContext}; -use rustc_errors::{Applicability, CodeSuggestion, Substitution, SubstitutionPart, SuggestionStyle}; +use rustc_errors::{Applicability, CodeSuggestion, DiagnosticBuilder, Substitution, SubstitutionPart, SuggestionStyle}; use rustc_hir::HirId; use rustc_span::source_map::{MultiSpan, Span}; use std::env; -use syntax::errors::DiagnosticBuilder; /// Wrapper around `DiagnosticBuilder` that adds a link to Clippy documentation for the emitted lint struct DiagnosticWrapper<'a>(DiagnosticBuilder<'a>); From 10cf141ebb9c9856858d5f4cc36281b2b43d37b3 Mon Sep 17 00:00:00 2001 From: Yuki Okushi Date: Sat, 11 Jan 2020 19:39:43 +0900 Subject: [PATCH 3/8] Apply review comments --- clippy_lints/src/matches.rs | 57 ++++++++++++++++++++------- clippy_lints/src/utils/author.rs | 9 ++--- clippy_lints/src/utils/hir_utils.rs | 7 +--- tests/ui/match_overlapping_arm.rs | 13 ++++++ tests/ui/match_overlapping_arm.stderr | 46 +++++++++++++++------ 5 files changed, 95 insertions(+), 37 deletions(-) diff --git a/clippy_lints/src/matches.rs b/clippy_lints/src/matches.rs index 5aed9770d2e..fca8e1446a8 100644 --- a/clippy_lints/src/matches.rs +++ b/clippy_lints/src/matches.rs @@ -1,4 +1,4 @@ -use crate::consts::{constant, Constant}; +use crate::consts::{constant, miri_to_const, Constant}; use crate::utils::paths; use crate::utils::sugg::Sugg; use crate::utils::{ @@ -444,7 +444,7 @@ fn check_match_bool(cx: &LateContext<'_, '_>, ex: &Expr<'_>, arms: &[Arm<'_>], e fn check_overlapping_arms<'a, 'tcx>(cx: &LateContext<'a, 'tcx>, ex: &'tcx Expr<'_>, arms: &'tcx [Arm<'_>]) { if arms.len() >= 2 && cx.tables.expr_ty(ex).is_integral() { - let ranges = all_ranges(cx, arms); + let ranges = all_ranges(cx, arms, cx.tables.expr_ty(ex)); let type_ranges = type_ranges(&ranges); if !type_ranges.is_empty() { if let Some((start, end)) = overlapping(&type_ranges) { @@ -705,25 +705,52 @@ fn check_wild_in_or_pats(cx: &LateContext<'_, '_>, arms: &[Arm<'_>]) { } /// Gets all arms that are unbounded `PatRange`s. -fn all_ranges<'a, 'tcx>(cx: &LateContext<'a, 'tcx>, arms: &'tcx [Arm<'_>]) -> Vec> { +fn all_ranges<'a, 'tcx>( + cx: &LateContext<'a, 'tcx>, + arms: &'tcx [Arm<'_>], + ty: Ty<'tcx>, +) -> Vec> { arms.iter() .flat_map(|arm| { if let Arm { ref pat, guard: None, .. } = *arm { - if let PatKind::Range(ref lhs, ref rhs, ref range_end) = pat.kind { - if let (Some(l), Some(r)) = (lhs, rhs) { - let lhs = constant(cx, cx.tables, l)?.0; - let rhs = constant(cx, cx.tables, r)?.0; - let rhs = match *range_end { - RangeEnd::Included => Bound::Included(rhs), - RangeEnd::Excluded => Bound::Excluded(rhs), - }; - return Some(SpannedRange { - span: pat.span, - node: (lhs, rhs), - }); + if let PatKind::Range(ref lhs, ref rhs, range_end) = pat.kind { + match (lhs, rhs) { + (Some(lhs), Some(rhs)) => { + 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), + }; + return Some(SpannedRange { + span: pat.span, + node: (lhs, rhs), + }); + }, + (None, Some(rhs)) => { + let lhs = miri_to_const(ty.numeric_min_val(cx.tcx)?)?; + let rhs = constant(cx, cx.tables, rhs)?.0; + let rhs = match range_end { + RangeEnd::Included => Bound::Included(rhs), + RangeEnd::Excluded => Bound::Excluded(rhs), + }; + return Some(SpannedRange { + span: pat.span, + node: (lhs, rhs), + }); + }, + (Some(lhs), None) => { + let lhs = constant(cx, cx.tables, lhs)?.0; + let rhs = miri_to_const(ty.numeric_max_val(cx.tcx)?)?; + return Some(SpannedRange { + span: pat.span, + node: (lhs, Bound::Excluded(rhs)), + }); + }, + _ => return None, } } diff --git a/clippy_lints/src/utils/author.rs b/clippy_lints/src/utils/author.rs index b9f11f79a37..cfbb32806da 100644 --- a/clippy_lints/src/utils/author.rs +++ b/clippy_lints/src/utils/author.rs @@ -12,6 +12,7 @@ use rustc_hir::intravisit::{NestedVisitorMap, Visitor}; use rustc_hir::{BindingAnnotation, Block, Expr, ExprKind, Pat, PatKind, QPath, Stmt, StmtKind, TyKind}; use rustc_session::declare_tool_lint; use syntax::ast::{Attribute, LitFloatType, LitKind}; +use syntax::walk_list; declare_clippy_lint! { /// **What it does:** Generates clippy code that detects the offending pattern @@ -617,13 +618,9 @@ impl<'tcx> Visitor<'tcx> for PrintVisitor { start_pat, end_pat, end_kind, current ); self.current = start_pat; - if let Some(expr) = start { - self.visit_expr(expr); - } + walk_list!(self, visit_expr, start); self.current = end_pat; - if let Some(expr) = end { - self.visit_expr(expr); - } + walk_list!(self, visit_expr, end); }, PatKind::Slice(ref start, ref middle, ref end) => { let start_pat = self.next("start"); diff --git a/clippy_lints/src/utils/hir_utils.rs b/clippy_lints/src/utils/hir_utils.rs index 00baad72e6d..01f719f4ab8 100644 --- a/clippy_lints/src/utils/hir_utils.rs +++ b/clippy_lints/src/utils/hir_utils.rs @@ -194,11 +194,8 @@ impl<'a, 'tcx> SpanlessEq<'a, 'tcx> { (&PatKind::Tuple(ref l, ls), &PatKind::Tuple(ref r, rs)) => { ls == rs && over(l, r, |l, r| self.eq_pat(l, r)) }, - (&PatKind::Range(ref ls, ref le, ref li), &PatKind::Range(ref rs, ref re, ref ri)) => { - if let (Some(ls), Some(rs), Some(le), Some(re)) = (ls, rs, le, re) { - return self.eq_expr(ls, rs) && self.eq_expr(le, re) && (*li == *ri); - } - false + (&PatKind::Range(ref ls, ref le, li), &PatKind::Range(ref rs, ref re, ri)) => { + both(ls, rs, |a, b| self.eq_expr(a, b)) && both(le, re, |a, b| self.eq_expr(a, b)) && (li == ri) }, (&PatKind::Ref(ref le, ref lm), &PatKind::Ref(ref re, ref rm)) => lm == rm && self.eq_pat(le, re), (&PatKind::Slice(ref ls, ref li, ref le), &PatKind::Slice(ref rs, ref ri, ref re)) => { diff --git a/tests/ui/match_overlapping_arm.rs b/tests/ui/match_overlapping_arm.rs index a48de440652..ce7761119cb 100644 --- a/tests/ui/match_overlapping_arm.rs +++ b/tests/ui/match_overlapping_arm.rs @@ -1,4 +1,5 @@ #![feature(exclusive_range_pattern)] +#![feature(half_open_range_patterns)] #![warn(clippy::match_overlapping_arm)] #![allow(clippy::redundant_pattern_matching)] @@ -56,6 +57,18 @@ fn overlapping() { _ => (), } + match 42 { + 0.. => println!("0 .. 42"), + 3.. => println!("3 .. 42"), + _ => (), + } + + match 42 { + ..=23 => println!("0 ... 23"), + ..26 => println!("0 .. 26"), + _ => (), + } + if let None = Some(42) { // nothing } else if let None = Some(42) { diff --git a/tests/ui/match_overlapping_arm.stderr b/tests/ui/match_overlapping_arm.stderr index dcd42fca7b4..32dcefa86d8 100644 --- a/tests/ui/match_overlapping_arm.stderr +++ b/tests/ui/match_overlapping_arm.stderr @@ -1,63 +1,87 @@ error: some ranges overlap - --> $DIR/match_overlapping_arm.rs:11:9 + --> $DIR/match_overlapping_arm.rs:12:9 | LL | 0..=10 => println!("0 ... 10"), | ^^^^^^ | = note: `-D clippy::match-overlapping-arm` implied by `-D warnings` note: overlaps with this - --> $DIR/match_overlapping_arm.rs:12:9 + --> $DIR/match_overlapping_arm.rs:13:9 | LL | 0..=11 => println!("0 ... 11"), | ^^^^^^ error: some ranges overlap - --> $DIR/match_overlapping_arm.rs:17:9 + --> $DIR/match_overlapping_arm.rs:18:9 | LL | 0..=5 => println!("0 ... 5"), | ^^^^^ | note: overlaps with this - --> $DIR/match_overlapping_arm.rs:19:9 + --> $DIR/match_overlapping_arm.rs:20:9 | LL | FOO..=11 => println!("0 ... 11"), | ^^^^^^^^ error: some ranges overlap - --> $DIR/match_overlapping_arm.rs:25:9 + --> $DIR/match_overlapping_arm.rs:26:9 | LL | 0..=5 => println!("0 ... 5"), | ^^^^^ | note: overlaps with this - --> $DIR/match_overlapping_arm.rs:24:9 + --> $DIR/match_overlapping_arm.rs:25:9 | LL | 2 => println!("2"), | ^ error: some ranges overlap - --> $DIR/match_overlapping_arm.rs:31:9 + --> $DIR/match_overlapping_arm.rs:32:9 | LL | 0..=2 => println!("0 ... 2"), | ^^^^^ | note: overlaps with this - --> $DIR/match_overlapping_arm.rs:30:9 + --> $DIR/match_overlapping_arm.rs:31:9 | LL | 2 => println!("2"), | ^ error: some ranges overlap - --> $DIR/match_overlapping_arm.rs:54:9 + --> $DIR/match_overlapping_arm.rs:55:9 | LL | 0..11 => println!("0 .. 11"), | ^^^^^ | note: overlaps with this - --> $DIR/match_overlapping_arm.rs:55:9 + --> $DIR/match_overlapping_arm.rs:56:9 | LL | 0..=11 => println!("0 ... 11"), | ^^^^^^ -error: aborting due to 5 previous errors +error: some ranges overlap + --> $DIR/match_overlapping_arm.rs:61:9 + | +LL | 0.. => println!("0 .. 42"), + | ^^^ + | +note: overlaps with this + --> $DIR/match_overlapping_arm.rs:62:9 + | +LL | 3.. => println!("3 .. 42"), + | ^^^ + +error: some ranges overlap + --> $DIR/match_overlapping_arm.rs:67:9 + | +LL | ..=23 => println!("0 ... 23"), + | ^^^^^ + | +note: overlaps with this + --> $DIR/match_overlapping_arm.rs:68:9 + | +LL | ..26 => println!("0 .. 26"), + | ^^^^ + +error: aborting due to 7 previous errors From 39947992b57239de6581c9761dfad7ac3cf001c8 Mon Sep 17 00:00:00 2001 From: Yuki Okushi Date: Sat, 11 Jan 2020 20:37:08 +0900 Subject: [PATCH 4/8] Rustup to rust-lang/rust#67806 --- clippy_lints/src/approx_const.rs | 5 ++--- clippy_lints/src/arithmetic.rs | 5 ++--- clippy_lints/src/as_conversions.rs | 5 ++--- clippy_lints/src/assertions_on_constants.rs | 5 ++--- clippy_lints/src/assign_ops.rs | 5 ++--- clippy_lints/src/atomic_ordering.rs | 5 ++--- clippy_lints/src/attrs.rs | 6 ++---- clippy_lints/src/bit_mask.rs | 5 ++--- clippy_lints/src/blacklisted_name.rs | 5 ++--- clippy_lints/src/block_in_if_condition.rs | 5 ++--- clippy_lints/src/booleans.rs | 5 ++--- clippy_lints/src/bytecount.rs | 5 ++--- clippy_lints/src/cargo_common_metadata.rs | 5 ++--- clippy_lints/src/checked_conversions.rs | 5 ++--- clippy_lints/src/cognitive_complexity.rs | 5 ++--- clippy_lints/src/collapsible_if.rs | 5 ++--- clippy_lints/src/comparison_chain.rs | 5 ++--- clippy_lints/src/copies.rs | 5 ++--- clippy_lints/src/copy_iterator.rs | 5 ++--- clippy_lints/src/dbg_macro.rs | 5 ++--- clippy_lints/src/default_trait_access.rs | 5 ++--- clippy_lints/src/derive.rs | 5 ++--- clippy_lints/src/doc.rs | 5 ++--- clippy_lints/src/double_comparison.rs | 5 ++--- clippy_lints/src/double_parens.rs | 5 ++--- clippy_lints/src/drop_bounds.rs | 5 ++--- clippy_lints/src/drop_forget_ref.rs | 5 ++--- clippy_lints/src/duration_subsec.rs | 5 ++--- clippy_lints/src/else_if_without_else.rs | 5 ++--- clippy_lints/src/empty_enum.rs | 5 ++--- clippy_lints/src/entry.rs | 5 ++--- clippy_lints/src/enum_clike.rs | 5 ++--- clippy_lints/src/enum_glob_use.rs | 5 ++--- clippy_lints/src/enum_variants.rs | 5 ++--- clippy_lints/src/eq_op.rs | 5 ++--- clippy_lints/src/erasing_op.rs | 5 ++--- clippy_lints/src/escape.rs | 5 ++--- clippy_lints/src/eta_reduction.rs | 5 ++--- clippy_lints/src/eval_order_dependence.rs | 5 ++--- clippy_lints/src/excessive_precision.rs | 5 ++--- clippy_lints/src/exit.rs | 5 ++--- clippy_lints/src/explicit_write.rs | 5 ++--- clippy_lints/src/fallible_impl_from.rs | 5 ++--- clippy_lints/src/format.rs | 5 ++--- clippy_lints/src/formatting.rs | 5 ++--- clippy_lints/src/functions.rs | 5 ++--- clippy_lints/src/get_last_with_len.rs | 5 ++--- clippy_lints/src/identity_conversion.rs | 5 ++--- clippy_lints/src/identity_op.rs | 5 ++--- clippy_lints/src/if_not_else.rs | 5 ++--- clippy_lints/src/implicit_return.rs | 7 ++----- clippy_lints/src/indexing_slicing.rs | 5 ++--- clippy_lints/src/infallible_destructuring_match.rs | 5 ++--- clippy_lints/src/infinite_iter.rs | 5 ++--- clippy_lints/src/inherent_impl.rs | 5 ++--- clippy_lints/src/inherent_to_string.rs | 5 ++--- clippy_lints/src/inline_fn_without_body.rs | 5 ++--- clippy_lints/src/int_plus_one.rs | 5 ++--- clippy_lints/src/integer_division.rs | 5 ++--- clippy_lints/src/items_after_statements.rs | 5 ++--- clippy_lints/src/large_enum_variant.rs | 5 ++--- clippy_lints/src/large_stack_arrays.rs | 5 ++--- clippy_lints/src/len_zero.rs | 5 ++--- clippy_lints/src/let_if_seq.rs | 5 ++--- clippy_lints/src/let_underscore.rs | 5 ++--- clippy_lints/src/lifetimes.rs | 5 ++--- clippy_lints/src/literal_representation.rs | 5 ++--- clippy_lints/src/loops.rs | 5 ++--- clippy_lints/src/main_recursion.rs | 5 ++--- clippy_lints/src/map_clone.rs | 5 ++--- clippy_lints/src/map_unit_fn.rs | 5 ++--- clippy_lints/src/matches.rs | 5 ++--- clippy_lints/src/mem_discriminant.rs | 5 ++--- clippy_lints/src/mem_forget.rs | 5 ++--- clippy_lints/src/mem_replace.rs | 5 ++--- clippy_lints/src/methods/mod.rs | 5 ++--- clippy_lints/src/minmax.rs | 5 ++--- clippy_lints/src/misc.rs | 5 ++--- clippy_lints/src/misc_early.rs | 5 ++--- clippy_lints/src/missing_const_for_fn.rs | 5 ++--- clippy_lints/src/missing_doc.rs | 5 ++--- clippy_lints/src/missing_inline.rs | 5 ++--- clippy_lints/src/modulo_arithmetic.rs | 5 ++--- clippy_lints/src/mul_add.rs | 5 ++--- clippy_lints/src/multiple_crate_versions.rs | 5 ++--- clippy_lints/src/mut_key.rs | 5 ++--- clippy_lints/src/mut_mut.rs | 5 ++--- clippy_lints/src/mut_reference.rs | 5 ++--- clippy_lints/src/mutable_debug_assertion.rs | 6 +++--- clippy_lints/src/mutex_atomic.rs | 5 ++--- clippy_lints/src/needless_bool.rs | 5 ++--- clippy_lints/src/needless_borrow.rs | 5 ++--- clippy_lints/src/needless_borrowed_ref.rs | 5 ++--- clippy_lints/src/needless_continue.rs | 5 ++--- clippy_lints/src/needless_pass_by_value.rs | 5 ++--- clippy_lints/src/needless_update.rs | 5 ++--- clippy_lints/src/neg_cmp_op_on_partial_ord.rs | 5 ++--- clippy_lints/src/neg_multiply.rs | 5 ++--- clippy_lints/src/new_without_default.rs | 5 ++--- clippy_lints/src/no_effect.rs | 5 ++--- clippy_lints/src/non_copy_const.rs | 5 ++--- clippy_lints/src/non_expressive_names.rs | 5 ++--- clippy_lints/src/ok_if_let.rs | 5 ++--- clippy_lints/src/open_options.rs | 5 ++--- clippy_lints/src/overflow_check_conditional.rs | 5 ++--- clippy_lints/src/panic_unimplemented.rs | 5 ++--- clippy_lints/src/partialeq_ne_impl.rs | 5 ++--- clippy_lints/src/path_buf_push_overwrite.rs | 5 ++--- clippy_lints/src/precedence.rs | 5 ++--- clippy_lints/src/ptr.rs | 5 ++--- clippy_lints/src/ptr_offset_with_cast.rs | 5 ++--- clippy_lints/src/question_mark.rs | 5 ++--- clippy_lints/src/ranges.rs | 5 ++--- clippy_lints/src/redundant_clone.rs | 5 ++--- clippy_lints/src/redundant_field_names.rs | 5 ++--- clippy_lints/src/redundant_pattern_matching.rs | 5 ++--- clippy_lints/src/redundant_static_lifetimes.rs | 5 ++--- clippy_lints/src/reference.rs | 5 ++--- clippy_lints/src/regex.rs | 5 ++--- clippy_lints/src/replace_consts.rs | 5 ++--- clippy_lints/src/returns.rs | 5 ++--- clippy_lints/src/serde_api.rs | 5 ++--- clippy_lints/src/shadow.rs | 5 ++--- clippy_lints/src/slow_vector_initialization.rs | 5 ++--- clippy_lints/src/strings.rs | 5 ++--- clippy_lints/src/suspicious_trait_impl.rs | 5 ++--- clippy_lints/src/swap.rs | 5 ++--- clippy_lints/src/tabs_in_doc_comments.rs | 5 ++--- clippy_lints/src/temporary_assignment.rs | 5 ++--- clippy_lints/src/to_digit_is_some.rs | 5 ++--- clippy_lints/src/trait_bounds.rs | 5 ++--- clippy_lints/src/transmute.rs | 5 ++--- clippy_lints/src/transmuting_null.rs | 5 ++--- clippy_lints/src/trivially_copy_pass_by_ref.rs | 5 ++--- clippy_lints/src/try_err.rs | 5 ++--- clippy_lints/src/types.rs | 5 ++--- clippy_lints/src/unicode.rs | 5 ++--- clippy_lints/src/unsafe_removed_from_name.rs | 5 ++--- clippy_lints/src/unused_io_amount.rs | 5 ++--- clippy_lints/src/unused_self.rs | 5 ++--- clippy_lints/src/unwrap.rs | 5 ++--- clippy_lints/src/use_self.rs | 5 ++--- clippy_lints/src/utils/author.rs | 5 ++--- clippy_lints/src/utils/inspector.rs | 5 ++--- clippy_lints/src/utils/internal_lints.rs | 4 ++-- clippy_lints/src/vec.rs | 5 ++--- clippy_lints/src/wildcard_dependencies.rs | 5 ++--- clippy_lints/src/write.rs | 5 ++--- clippy_lints/src/zero_div_zero.rs | 5 ++--- doc/adding_lints.md | 3 +-- tests/ui/outer_expn_data.fixed | 3 +-- tests/ui/outer_expn_data.rs | 3 +-- tests/ui/outer_expn_data.stderr | 2 +- 153 files changed, 303 insertions(+), 456 deletions(-) diff --git a/clippy_lints/src/approx_const.rs b/clippy_lints/src/approx_const.rs index e0b94b98dc4..7c999f1755a 100644 --- a/clippy_lints/src/approx_const.rs +++ b/clippy_lints/src/approx_const.rs @@ -1,8 +1,7 @@ use crate::utils::span_lint; -use rustc::declare_lint_pass; -use rustc::lint::{LateContext, LateLintPass, LintArray, LintPass}; +use rustc::lint::{LateContext, LateLintPass}; use rustc_hir::*; -use rustc_session::declare_tool_lint; +use rustc_session::{declare_lint_pass, declare_tool_lint}; use rustc_span::symbol; use std::f64::consts as f64; use syntax::ast::{FloatTy, LitFloatType, LitKind}; diff --git a/clippy_lints/src/arithmetic.rs b/clippy_lints/src/arithmetic.rs index 9638cb8fbad..bad8331f5af 100644 --- a/clippy_lints/src/arithmetic.rs +++ b/clippy_lints/src/arithmetic.rs @@ -1,9 +1,8 @@ use crate::consts::constant_simple; use crate::utils::span_lint; -use rustc::impl_lint_pass; -use rustc::lint::{LateContext, LateLintPass, LintArray, LintPass}; +use rustc::lint::{LateContext, LateLintPass}; use rustc_hir as hir; -use rustc_session::declare_tool_lint; +use rustc_session::{declare_tool_lint, impl_lint_pass}; use rustc_span::source_map::Span; declare_clippy_lint! { diff --git a/clippy_lints/src/as_conversions.rs b/clippy_lints/src/as_conversions.rs index c2e3871226f..b8d805b3e94 100644 --- a/clippy_lints/src/as_conversions.rs +++ b/clippy_lints/src/as_conversions.rs @@ -1,6 +1,5 @@ -use rustc::declare_lint_pass; -use rustc::lint::{in_external_macro, EarlyContext, EarlyLintPass, LintArray, LintContext, LintPass}; -use rustc_session::declare_tool_lint; +use rustc::lint::{in_external_macro, EarlyContext, EarlyLintPass, LintContext}; +use rustc_session::{declare_lint_pass, declare_tool_lint}; use syntax::ast::*; use crate::utils::span_help_and_lint; diff --git a/clippy_lints/src/assertions_on_constants.rs b/clippy_lints/src/assertions_on_constants.rs index 555825e484f..800cd88f5bc 100644 --- a/clippy_lints/src/assertions_on_constants.rs +++ b/clippy_lints/src/assertions_on_constants.rs @@ -2,10 +2,9 @@ use crate::consts::{constant, Constant}; use crate::utils::paths; use crate::utils::{is_direct_expn_of, is_expn_of, match_function_call, snippet_opt, span_help_and_lint}; use if_chain::if_chain; -use rustc::declare_lint_pass; -use rustc::lint::{LateContext, LateLintPass, LintArray, LintPass}; +use rustc::lint::{LateContext, LateLintPass}; use rustc_hir::*; -use rustc_session::declare_tool_lint; +use rustc_session::{declare_lint_pass, declare_tool_lint}; use syntax::ast::LitKind; declare_clippy_lint! { diff --git a/clippy_lints/src/assign_ops.rs b/clippy_lints/src/assign_ops.rs index 0fe10a1f589..8fc9f56fe6d 100644 --- a/clippy_lints/src/assign_ops.rs +++ b/clippy_lints/src/assign_ops.rs @@ -3,13 +3,12 @@ use crate::utils::{ }; use crate::utils::{higher, sugg}; use if_chain::if_chain; -use rustc::declare_lint_pass; use rustc::hir::map::Map; -use rustc::lint::{LateContext, LateLintPass, LintArray, LintPass}; +use rustc::lint::{LateContext, LateLintPass}; use rustc_errors::Applicability; use rustc_hir as hir; use rustc_hir::intravisit::{walk_expr, NestedVisitorMap, Visitor}; -use rustc_session::declare_tool_lint; +use rustc_session::{declare_lint_pass, declare_tool_lint}; declare_clippy_lint! { /// **What it does:** Checks for `a = a op b` or `a = b commutative_op a` diff --git a/clippy_lints/src/atomic_ordering.rs b/clippy_lints/src/atomic_ordering.rs index fe06c63a553..94db8248ae2 100644 --- a/clippy_lints/src/atomic_ordering.rs +++ b/clippy_lints/src/atomic_ordering.rs @@ -1,11 +1,10 @@ use crate::utils::{match_def_path, span_help_and_lint}; use if_chain::if_chain; -use rustc::declare_lint_pass; -use rustc::lint::{LateContext, LateLintPass, LintArray, LintPass}; +use rustc::lint::{LateContext, LateLintPass}; use rustc::ty; use rustc_hir::def_id::DefId; use rustc_hir::*; -use rustc_session::declare_tool_lint; +use rustc_session::{declare_lint_pass, declare_tool_lint}; declare_clippy_lint! { /// **What it does:** Checks for usage of invalid atomic diff --git a/clippy_lints/src/attrs.rs b/clippy_lints/src/attrs.rs index c57061c0bfa..cc326b52fe4 100644 --- a/clippy_lints/src/attrs.rs +++ b/clippy_lints/src/attrs.rs @@ -6,15 +6,13 @@ use crate::utils::{ span_lint_and_then, without_block_comments, }; use if_chain::if_chain; -use rustc::declare_lint_pass; use rustc::lint::{ - in_external_macro, CheckLintNameResult, EarlyContext, EarlyLintPass, LateContext, LateLintPass, LintArray, - LintContext, LintPass, + in_external_macro, CheckLintNameResult, EarlyContext, EarlyLintPass, LateContext, LateLintPass, LintContext, }; use rustc::ty; use rustc_errors::Applicability; use rustc_hir::*; -use rustc_session::declare_tool_lint; +use rustc_session::{declare_lint_pass, declare_tool_lint}; use rustc_span::source_map::Span; use rustc_span::symbol::Symbol; use semver::Version; diff --git a/clippy_lints/src/bit_mask.rs b/clippy_lints/src/bit_mask.rs index 6f7efa08f19..4ff9b6dcf49 100644 --- a/clippy_lints/src/bit_mask.rs +++ b/clippy_lints/src/bit_mask.rs @@ -2,11 +2,10 @@ use crate::consts::{constant, Constant}; use crate::utils::sugg::Sugg; use crate::utils::{span_lint, span_lint_and_then}; use if_chain::if_chain; -use rustc::impl_lint_pass; -use rustc::lint::{LateContext, LateLintPass, LintArray, LintPass}; +use rustc::lint::{LateContext, LateLintPass}; use rustc_errors::Applicability; use rustc_hir::*; -use rustc_session::declare_tool_lint; +use rustc_session::{declare_tool_lint, impl_lint_pass}; use rustc_span::source_map::Span; use syntax::ast::LitKind; diff --git a/clippy_lints/src/blacklisted_name.rs b/clippy_lints/src/blacklisted_name.rs index 44c058911ab..ea2384cd284 100644 --- a/clippy_lints/src/blacklisted_name.rs +++ b/clippy_lints/src/blacklisted_name.rs @@ -1,9 +1,8 @@ use crate::utils::span_lint; -use rustc::impl_lint_pass; -use rustc::lint::{LateContext, LateLintPass, LintArray, LintPass}; +use rustc::lint::{LateContext, LateLintPass}; use rustc_data_structures::fx::FxHashSet; use rustc_hir::*; -use rustc_session::declare_tool_lint; +use rustc_session::{declare_tool_lint, impl_lint_pass}; declare_clippy_lint! { /// **What it does:** Checks for usage of blacklisted names for variables, such diff --git a/clippy_lints/src/block_in_if_condition.rs b/clippy_lints/src/block_in_if_condition.rs index 721314fb666..470a98f19e5 100644 --- a/clippy_lints/src/block_in_if_condition.rs +++ b/clippy_lints/src/block_in_if_condition.rs @@ -1,11 +1,10 @@ use crate::utils::*; use matches::matches; -use rustc::declare_lint_pass; use rustc::hir::map::Map; -use rustc::lint::{in_external_macro, LateContext, LateLintPass, LintArray, LintContext, LintPass}; +use rustc::lint::{in_external_macro, LateContext, LateLintPass, LintContext}; use rustc_hir::intravisit::{walk_expr, NestedVisitorMap, Visitor}; use rustc_hir::*; -use rustc_session::declare_tool_lint; +use rustc_session::{declare_lint_pass, declare_tool_lint}; declare_clippy_lint! { /// **What it does:** Checks for `if` conditions that use blocks to contain an diff --git a/clippy_lints/src/booleans.rs b/clippy_lints/src/booleans.rs index dd0a021ea38..2bff1ba48aa 100644 --- a/clippy_lints/src/booleans.rs +++ b/clippy_lints/src/booleans.rs @@ -3,14 +3,13 @@ use crate::utils::{ span_lint_and_then, SpanlessEq, }; use if_chain::if_chain; -use rustc::declare_lint_pass; use rustc::hir::map::Map; -use rustc::lint::{LateContext, LateLintPass, LintArray, LintPass}; +use rustc::lint::{LateContext, LateLintPass}; use rustc_errors::Applicability; use rustc_hir::intravisit; use rustc_hir::intravisit::*; use rustc_hir::*; -use rustc_session::declare_tool_lint; +use rustc_session::{declare_lint_pass, declare_tool_lint}; use rustc_span::source_map::Span; use syntax::ast::LitKind; diff --git a/clippy_lints/src/bytecount.rs b/clippy_lints/src/bytecount.rs index e70f1f317c3..bab6a657b32 100644 --- a/clippy_lints/src/bytecount.rs +++ b/clippy_lints/src/bytecount.rs @@ -3,12 +3,11 @@ use crate::utils::{ span_lint_and_sugg, walk_ptrs_ty, }; use if_chain::if_chain; -use rustc::declare_lint_pass; -use rustc::lint::{LateContext, LateLintPass, LintArray, LintPass}; +use rustc::lint::{LateContext, LateLintPass}; use rustc::ty; use rustc_errors::Applicability; use rustc_hir::*; -use rustc_session::declare_tool_lint; +use rustc_session::{declare_lint_pass, declare_tool_lint}; use syntax::ast::{Name, UintTy}; declare_clippy_lint! { diff --git a/clippy_lints/src/cargo_common_metadata.rs b/clippy_lints/src/cargo_common_metadata.rs index aa068d834b1..1b8ca33e905 100644 --- a/clippy_lints/src/cargo_common_metadata.rs +++ b/clippy_lints/src/cargo_common_metadata.rs @@ -3,9 +3,8 @@ use std::path::PathBuf; use crate::utils::span_lint; -use rustc::declare_lint_pass; -use rustc::lint::{EarlyContext, EarlyLintPass, LintArray, LintPass}; -use rustc_session::declare_tool_lint; +use rustc::lint::{EarlyContext, EarlyLintPass}; +use rustc_session::{declare_lint_pass, declare_tool_lint}; use rustc_span::source_map::DUMMY_SP; use syntax::ast::*; diff --git a/clippy_lints/src/checked_conversions.rs b/clippy_lints/src/checked_conversions.rs index bc79688eef5..3136310730c 100644 --- a/clippy_lints/src/checked_conversions.rs +++ b/clippy_lints/src/checked_conversions.rs @@ -1,11 +1,10 @@ //! lint on manually implemented checked conversions that could be transformed into `try_from` use if_chain::if_chain; -use rustc::declare_lint_pass; -use rustc::lint::{in_external_macro, LateContext, LateLintPass, LintArray, LintContext, LintPass}; +use rustc::lint::{in_external_macro, LateContext, LateLintPass, LintContext}; use rustc_errors::Applicability; use rustc_hir::*; -use rustc_session::declare_tool_lint; +use rustc_session::{declare_lint_pass, declare_tool_lint}; use syntax::ast::LitKind; use crate::utils::{snippet_with_applicability, span_lint_and_sugg, SpanlessEq}; diff --git a/clippy_lints/src/cognitive_complexity.rs b/clippy_lints/src/cognitive_complexity.rs index 50a7f24cadc..d884567364f 100644 --- a/clippy_lints/src/cognitive_complexity.rs +++ b/clippy_lints/src/cognitive_complexity.rs @@ -1,11 +1,10 @@ //! calculate cognitive complexity and warn about overly complex functions use rustc::hir::map::Map; -use rustc::impl_lint_pass; -use rustc::lint::{LateContext, LateLintPass, LintArray, LintContext, LintPass}; +use rustc::lint::{LateContext, LateLintPass, LintContext}; use rustc_hir::intravisit::{walk_expr, FnKind, NestedVisitorMap, Visitor}; use rustc_hir::*; -use rustc_session::declare_tool_lint; +use rustc_session::{declare_tool_lint, impl_lint_pass}; use rustc_span::source_map::Span; use rustc_span::BytePos; use syntax::ast::Attribute; diff --git a/clippy_lints/src/collapsible_if.rs b/clippy_lints/src/collapsible_if.rs index e34dfc9d999..aaaa3eb1f6e 100644 --- a/clippy_lints/src/collapsible_if.rs +++ b/clippy_lints/src/collapsible_if.rs @@ -13,9 +13,8 @@ //! This lint is **warn** by default use if_chain::if_chain; -use rustc::declare_lint_pass; -use rustc::lint::{EarlyContext, EarlyLintPass, LintArray, LintPass}; -use rustc_session::declare_tool_lint; +use rustc::lint::{EarlyContext, EarlyLintPass}; +use rustc_session::{declare_lint_pass, declare_tool_lint}; use syntax::ast; use crate::utils::sugg::Sugg; diff --git a/clippy_lints/src/comparison_chain.rs b/clippy_lints/src/comparison_chain.rs index 4a239abfb50..60ed68f6363 100644 --- a/clippy_lints/src/comparison_chain.rs +++ b/clippy_lints/src/comparison_chain.rs @@ -1,10 +1,9 @@ use crate::utils::{ get_trait_def_id, if_sequence, implements_trait, parent_node_is_if_expr, paths, span_help_and_lint, SpanlessEq, }; -use rustc::declare_lint_pass; -use rustc::lint::{LateContext, LateLintPass, LintArray, LintPass}; +use rustc::lint::{LateContext, LateLintPass}; use rustc_hir::*; -use rustc_session::declare_tool_lint; +use rustc_session::{declare_lint_pass, declare_tool_lint}; declare_clippy_lint! { /// **What it does:** Checks comparison chains written with `if` that can be diff --git a/clippy_lints/src/copies.rs b/clippy_lints/src/copies.rs index 5d04286575a..4e576b7546b 100644 --- a/clippy_lints/src/copies.rs +++ b/clippy_lints/src/copies.rs @@ -1,11 +1,10 @@ use crate::utils::{get_parent_expr, higher, if_sequence, same_tys, snippet, span_lint_and_then, span_note_and_lint}; use crate::utils::{SpanlessEq, SpanlessHash}; -use rustc::declare_lint_pass; -use rustc::lint::{LateContext, LateLintPass, LintArray, LintPass}; +use rustc::lint::{LateContext, LateLintPass}; use rustc::ty::Ty; use rustc_data_structures::fx::FxHashMap; use rustc_hir::*; -use rustc_session::declare_tool_lint; +use rustc_session::{declare_lint_pass, declare_tool_lint}; use rustc_span::symbol::Symbol; use std::collections::hash_map::Entry; use std::hash::BuildHasherDefault; diff --git a/clippy_lints/src/copy_iterator.rs b/clippy_lints/src/copy_iterator.rs index d7863b0d9a9..d3349bb3cb9 100644 --- a/clippy_lints/src/copy_iterator.rs +++ b/clippy_lints/src/copy_iterator.rs @@ -1,8 +1,7 @@ use crate::utils::{is_copy, match_path, paths, span_note_and_lint}; -use rustc::declare_lint_pass; -use rustc::lint::{LateContext, LateLintPass, LintArray, LintPass}; +use rustc::lint::{LateContext, LateLintPass}; use rustc_hir::{Item, ItemKind}; -use rustc_session::declare_tool_lint; +use rustc_session::{declare_lint_pass, declare_tool_lint}; declare_clippy_lint! { /// **What it does:** Checks for types that implement `Copy` as well as diff --git a/clippy_lints/src/dbg_macro.rs b/clippy_lints/src/dbg_macro.rs index fa19e55af3a..e405c190904 100644 --- a/clippy_lints/src/dbg_macro.rs +++ b/clippy_lints/src/dbg_macro.rs @@ -1,8 +1,7 @@ use crate::utils::{snippet_opt, span_help_and_lint, span_lint_and_sugg}; -use rustc::declare_lint_pass; -use rustc::lint::{EarlyContext, EarlyLintPass, LintArray, LintPass}; +use rustc::lint::{EarlyContext, EarlyLintPass}; use rustc_errors::Applicability; -use rustc_session::declare_tool_lint; +use rustc_session::{declare_lint_pass, declare_tool_lint}; use rustc_span::source_map::Span; use syntax::ast; use syntax::tokenstream::TokenStream; diff --git a/clippy_lints/src/default_trait_access.rs b/clippy_lints/src/default_trait_access.rs index 253d9b8d542..bd3f5e81b28 100644 --- a/clippy_lints/src/default_trait_access.rs +++ b/clippy_lints/src/default_trait_access.rs @@ -1,10 +1,9 @@ use if_chain::if_chain; -use rustc::declare_lint_pass; -use rustc::lint::{LateContext, LateLintPass, LintArray, LintPass}; +use rustc::lint::{LateContext, LateLintPass}; use rustc::ty; use rustc_errors::Applicability; use rustc_hir::*; -use rustc_session::declare_tool_lint; +use rustc_session::{declare_lint_pass, declare_tool_lint}; use crate::utils::{any_parent_is_automatically_derived, match_def_path, paths, span_lint_and_sugg}; diff --git a/clippy_lints/src/derive.rs b/clippy_lints/src/derive.rs index c6215afbbd3..775770a3ecf 100644 --- a/clippy_lints/src/derive.rs +++ b/clippy_lints/src/derive.rs @@ -1,11 +1,10 @@ use crate::utils::paths; use crate::utils::{is_automatically_derived, is_copy, match_path, span_lint_and_then}; use if_chain::if_chain; -use rustc::declare_lint_pass; -use rustc::lint::{LateContext, LateLintPass, LintArray, LintPass}; +use rustc::lint::{LateContext, LateLintPass}; use rustc::ty::{self, Ty}; use rustc_hir::*; -use rustc_session::declare_tool_lint; +use rustc_session::{declare_lint_pass, declare_tool_lint}; use rustc_span::source_map::Span; declare_clippy_lint! { diff --git a/clippy_lints/src/doc.rs b/clippy_lints/src/doc.rs index d7c232eec1a..db666790829 100644 --- a/clippy_lints/src/doc.rs +++ b/clippy_lints/src/doc.rs @@ -1,10 +1,9 @@ use crate::utils::{match_type, paths, return_ty, span_lint}; use itertools::Itertools; -use rustc::impl_lint_pass; -use rustc::lint::{in_external_macro, LateContext, LateLintPass, LintArray, LintPass}; +use rustc::lint::{in_external_macro, LateContext, LateLintPass}; use rustc_data_structures::fx::FxHashSet; use rustc_hir as hir; -use rustc_session::declare_tool_lint; +use rustc_session::{declare_tool_lint, impl_lint_pass}; use rustc_span::source_map::{BytePos, MultiSpan, Span}; use rustc_span::Pos; use std::ops::Range; diff --git a/clippy_lints/src/double_comparison.rs b/clippy_lints/src/double_comparison.rs index d2ff544bd03..0bc03889021 100644 --- a/clippy_lints/src/double_comparison.rs +++ b/clippy_lints/src/double_comparison.rs @@ -1,10 +1,9 @@ //! Lint on unnecessary double comparisons. Some examples: -use rustc::declare_lint_pass; -use rustc::lint::{LateContext, LateLintPass, LintArray, LintPass}; +use rustc::lint::{LateContext, LateLintPass}; use rustc_errors::Applicability; use rustc_hir::*; -use rustc_session::declare_tool_lint; +use rustc_session::{declare_lint_pass, declare_tool_lint}; use rustc_span::source_map::Span; use crate::utils::{snippet_with_applicability, span_lint_and_sugg, SpanlessEq}; diff --git a/clippy_lints/src/double_parens.rs b/clippy_lints/src/double_parens.rs index 52a5e2a1a49..d6f1ced99a2 100644 --- a/clippy_lints/src/double_parens.rs +++ b/clippy_lints/src/double_parens.rs @@ -1,7 +1,6 @@ use crate::utils::span_lint; -use rustc::declare_lint_pass; -use rustc::lint::{EarlyContext, EarlyLintPass, LintArray, LintPass}; -use rustc_session::declare_tool_lint; +use rustc::lint::{EarlyContext, EarlyLintPass}; +use rustc_session::{declare_lint_pass, declare_tool_lint}; use syntax::ast::*; declare_clippy_lint! { diff --git a/clippy_lints/src/drop_bounds.rs b/clippy_lints/src/drop_bounds.rs index 825f3b8de74..df06d6d42f8 100644 --- a/clippy_lints/src/drop_bounds.rs +++ b/clippy_lints/src/drop_bounds.rs @@ -1,9 +1,8 @@ use crate::utils::{match_def_path, paths, span_lint}; use if_chain::if_chain; -use rustc::declare_lint_pass; -use rustc::lint::{LateLintPass, LintArray, LintPass}; +use rustc::lint::LateLintPass; use rustc_hir::*; -use rustc_session::declare_tool_lint; +use rustc_session::{declare_lint_pass, declare_tool_lint}; declare_clippy_lint! { /// **What it does:** Checks for generics with `std::ops::Drop` as bounds. diff --git a/clippy_lints/src/drop_forget_ref.rs b/clippy_lints/src/drop_forget_ref.rs index d8ce2fcf661..d7f3722aaee 100644 --- a/clippy_lints/src/drop_forget_ref.rs +++ b/clippy_lints/src/drop_forget_ref.rs @@ -1,10 +1,9 @@ use crate::utils::{is_copy, match_def_path, paths, qpath_res, span_note_and_lint}; use if_chain::if_chain; -use rustc::declare_lint_pass; -use rustc::lint::{LateContext, LateLintPass, LintArray, LintPass}; +use rustc::lint::{LateContext, LateLintPass}; use rustc::ty; use rustc_hir::*; -use rustc_session::declare_tool_lint; +use rustc_session::{declare_lint_pass, declare_tool_lint}; declare_clippy_lint! { /// **What it does:** Checks for calls to `std::mem::drop` with a reference diff --git a/clippy_lints/src/duration_subsec.rs b/clippy_lints/src/duration_subsec.rs index 0ec9cc9084a..85be5938651 100644 --- a/clippy_lints/src/duration_subsec.rs +++ b/clippy_lints/src/duration_subsec.rs @@ -1,9 +1,8 @@ use if_chain::if_chain; -use rustc::declare_lint_pass; -use rustc::lint::{LateContext, LateLintPass, LintArray, LintPass}; +use rustc::lint::{LateContext, LateLintPass}; use rustc_errors::Applicability; use rustc_hir::*; -use rustc_session::declare_tool_lint; +use rustc_session::{declare_lint_pass, declare_tool_lint}; use rustc_span::source_map::Spanned; use crate::consts::{constant, Constant}; diff --git a/clippy_lints/src/else_if_without_else.rs b/clippy_lints/src/else_if_without_else.rs index 8043a8c8555..69ef27032da 100644 --- a/clippy_lints/src/else_if_without_else.rs +++ b/clippy_lints/src/else_if_without_else.rs @@ -1,8 +1,7 @@ //! Lint on if expressions with an else if, but without a final else branch. -use rustc::declare_lint_pass; -use rustc::lint::{in_external_macro, EarlyContext, EarlyLintPass, LintArray, LintContext, LintPass}; -use rustc_session::declare_tool_lint; +use rustc::lint::{in_external_macro, EarlyContext, EarlyLintPass, LintContext}; +use rustc_session::{declare_lint_pass, declare_tool_lint}; use syntax::ast::*; use crate::utils::span_help_and_lint; diff --git a/clippy_lints/src/empty_enum.rs b/clippy_lints/src/empty_enum.rs index f16a71fe63f..d92db682207 100644 --- a/clippy_lints/src/empty_enum.rs +++ b/clippy_lints/src/empty_enum.rs @@ -1,10 +1,9 @@ //! lint when there is an enum with no variants use crate::utils::span_lint_and_then; -use rustc::declare_lint_pass; -use rustc::lint::{LateContext, LateLintPass, LintArray, LintPass}; +use rustc::lint::{LateContext, LateLintPass}; use rustc_hir::*; -use rustc_session::declare_tool_lint; +use rustc_session::{declare_lint_pass, declare_tool_lint}; declare_clippy_lint! { /// **What it does:** Checks for `enum`s with no variants. diff --git a/clippy_lints/src/entry.rs b/clippy_lints/src/entry.rs index 7a91dd53c2f..e06350d0dcc 100644 --- a/clippy_lints/src/entry.rs +++ b/clippy_lints/src/entry.rs @@ -2,13 +2,12 @@ use crate::utils::SpanlessEq; use crate::utils::{get_item_name, higher, match_type, paths, snippet, snippet_opt}; use crate::utils::{snippet_with_applicability, span_lint_and_then, walk_ptrs_ty}; use if_chain::if_chain; -use rustc::declare_lint_pass; use rustc::hir::map::Map; -use rustc::lint::{LateContext, LateLintPass, LintArray, LintPass}; +use rustc::lint::{LateContext, LateLintPass}; use rustc_errors::Applicability; use rustc_hir::intravisit::{walk_expr, NestedVisitorMap, Visitor}; use rustc_hir::*; -use rustc_session::declare_tool_lint; +use rustc_session::{declare_lint_pass, declare_tool_lint}; use rustc_span::source_map::Span; declare_clippy_lint! { diff --git a/clippy_lints/src/enum_clike.rs b/clippy_lints/src/enum_clike.rs index e3f862dc2a3..c7d191c03f9 100644 --- a/clippy_lints/src/enum_clike.rs +++ b/clippy_lints/src/enum_clike.rs @@ -3,12 +3,11 @@ use crate::consts::{miri_to_const, Constant}; use crate::utils::span_lint; -use rustc::declare_lint_pass; -use rustc::lint::{LateContext, LateLintPass, LintArray, LintPass}; +use rustc::lint::{LateContext, LateLintPass}; use rustc::ty; use rustc::ty::util::IntTypeExt; use rustc_hir::*; -use rustc_session::declare_tool_lint; +use rustc_session::{declare_lint_pass, declare_tool_lint}; use std::convert::TryFrom; use syntax::ast::{IntTy, UintTy}; diff --git a/clippy_lints/src/enum_glob_use.rs b/clippy_lints/src/enum_glob_use.rs index 6cd3e1c86b4..88065ddb1a5 100644 --- a/clippy_lints/src/enum_glob_use.rs +++ b/clippy_lints/src/enum_glob_use.rs @@ -1,11 +1,10 @@ //! lint on `use`ing all variants of an enum use crate::utils::span_lint; -use rustc::declare_lint_pass; -use rustc::lint::{LateContext, LateLintPass, LintArray, LintPass}; +use rustc::lint::{LateContext, LateLintPass}; use rustc_hir::def::{DefKind, Res}; use rustc_hir::*; -use rustc_session::declare_tool_lint; +use rustc_session::{declare_lint_pass, declare_tool_lint}; use rustc_span::source_map::Span; declare_clippy_lint! { diff --git a/clippy_lints/src/enum_variants.rs b/clippy_lints/src/enum_variants.rs index 9db9385d004..5b4c059f0cd 100644 --- a/clippy_lints/src/enum_variants.rs +++ b/clippy_lints/src/enum_variants.rs @@ -2,9 +2,8 @@ use crate::utils::{camel_case, is_present_in_source}; use crate::utils::{span_help_and_lint, span_lint}; -use rustc::impl_lint_pass; -use rustc::lint::{EarlyContext, EarlyLintPass, Lint, LintArray, LintPass}; -use rustc_session::declare_tool_lint; +use rustc::lint::{EarlyContext, EarlyLintPass, Lint}; +use rustc_session::{declare_tool_lint, impl_lint_pass}; use rustc_span::source_map::Span; use rustc_span::symbol::Symbol; use syntax::ast::*; diff --git a/clippy_lints/src/eq_op.rs b/clippy_lints/src/eq_op.rs index 232a26790d0..b058b7f46ce 100644 --- a/clippy_lints/src/eq_op.rs +++ b/clippy_lints/src/eq_op.rs @@ -1,9 +1,8 @@ use crate::utils::{implements_trait, is_copy, multispan_sugg, snippet, span_lint, span_lint_and_then, SpanlessEq}; -use rustc::declare_lint_pass; -use rustc::lint::{LateContext, LateLintPass, LintArray, LintPass}; +use rustc::lint::{LateContext, LateLintPass}; use rustc_errors::Applicability; use rustc_hir::*; -use rustc_session::declare_tool_lint; +use rustc_session::{declare_lint_pass, declare_tool_lint}; declare_clippy_lint! { /// **What it does:** Checks for equal operands to comparison, logical and diff --git a/clippy_lints/src/erasing_op.rs b/clippy_lints/src/erasing_op.rs index 6ff90315a97..129314c51fb 100644 --- a/clippy_lints/src/erasing_op.rs +++ b/clippy_lints/src/erasing_op.rs @@ -1,7 +1,6 @@ -use rustc::declare_lint_pass; -use rustc::lint::{LateContext, LateLintPass, LintArray, LintPass}; +use rustc::lint::{LateContext, LateLintPass}; use rustc_hir::*; -use rustc_session::declare_tool_lint; +use rustc_session::{declare_lint_pass, declare_tool_lint}; use rustc_span::source_map::Span; use crate::consts::{constant_simple, Constant}; diff --git a/clippy_lints/src/escape.rs b/clippy_lints/src/escape.rs index 899e288b6ef..90e57381bf8 100644 --- a/clippy_lints/src/escape.rs +++ b/clippy_lints/src/escape.rs @@ -1,11 +1,10 @@ -use rustc::impl_lint_pass; -use rustc::lint::{LateContext, LateLintPass, LintArray, LintPass}; +use rustc::lint::{LateContext, LateLintPass}; use rustc::ty::layout::LayoutOf; use rustc::ty::{self, Ty}; use rustc_hir::intravisit as visit; use rustc_hir::HirIdSet; use rustc_hir::{self, *}; -use rustc_session::declare_tool_lint; +use rustc_session::{declare_tool_lint, impl_lint_pass}; use rustc_span::source_map::Span; use rustc_typeck::expr_use_visitor::*; diff --git a/clippy_lints/src/eta_reduction.rs b/clippy_lints/src/eta_reduction.rs index 486200fd371..93699e3c23d 100644 --- a/clippy_lints/src/eta_reduction.rs +++ b/clippy_lints/src/eta_reduction.rs @@ -1,11 +1,10 @@ use if_chain::if_chain; use matches::matches; -use rustc::declare_lint_pass; -use rustc::lint::{in_external_macro, LateContext, LateLintPass, LintArray, LintContext, LintPass}; +use rustc::lint::{in_external_macro, LateContext, LateLintPass, LintContext}; use rustc::ty::{self, Ty}; use rustc_errors::Applicability; use rustc_hir::*; -use rustc_session::declare_tool_lint; +use rustc_session::{declare_lint_pass, declare_tool_lint}; use crate::utils::{ implements_trait, is_adjusted, iter_input_pats, snippet_opt, span_lint_and_then, type_is_unsafe_function, diff --git a/clippy_lints/src/eval_order_dependence.rs b/clippy_lints/src/eval_order_dependence.rs index 84545ed6967..be37c9c2154 100644 --- a/clippy_lints/src/eval_order_dependence.rs +++ b/clippy_lints/src/eval_order_dependence.rs @@ -1,12 +1,11 @@ use crate::utils::{get_parent_expr, span_lint, span_note_and_lint}; use if_chain::if_chain; -use rustc::declare_lint_pass; use rustc::hir::map::Map; -use rustc::lint::{LateContext, LateLintPass, LintArray, LintPass}; +use rustc::lint::{LateContext, LateLintPass}; use rustc::ty; use rustc_hir::intravisit::{walk_expr, NestedVisitorMap, Visitor}; use rustc_hir::*; -use rustc_session::declare_tool_lint; +use rustc_session::{declare_lint_pass, declare_tool_lint}; declare_clippy_lint! { /// **What it does:** Checks for a read and a write to the same variable where diff --git a/clippy_lints/src/excessive_precision.rs b/clippy_lints/src/excessive_precision.rs index 8c51538d35b..bc3983877fb 100644 --- a/clippy_lints/src/excessive_precision.rs +++ b/clippy_lints/src/excessive_precision.rs @@ -1,12 +1,11 @@ use crate::utils::span_lint_and_sugg; use crate::utils::sugg::format_numeric_literal; use if_chain::if_chain; -use rustc::declare_lint_pass; -use rustc::lint::{LateContext, LateLintPass, LintArray, LintPass}; +use rustc::lint::{LateContext, LateLintPass}; use rustc::ty; use rustc_errors::Applicability; use rustc_hir as hir; -use rustc_session::declare_tool_lint; +use rustc_session::{declare_lint_pass, declare_tool_lint}; use rustc_span::symbol::Symbol; use std::f32; use std::f64; diff --git a/clippy_lints/src/exit.rs b/clippy_lints/src/exit.rs index 13c44020363..3d1eadd4c00 100644 --- a/clippy_lints/src/exit.rs +++ b/clippy_lints/src/exit.rs @@ -1,9 +1,8 @@ use crate::utils::{is_entrypoint_fn, match_def_path, paths, qpath_res, span_lint}; use if_chain::if_chain; -use rustc::declare_lint_pass; -use rustc::lint::{LateContext, LateLintPass, LintArray, LintPass}; +use rustc::lint::{LateContext, LateLintPass}; use rustc_hir::{Expr, ExprKind, Item, ItemKind, Node}; -use rustc_session::declare_tool_lint; +use rustc_session::{declare_lint_pass, declare_tool_lint}; declare_clippy_lint! { /// **What it does:** `exit()` terminates the program and doesn't provide a diff --git a/clippy_lints/src/explicit_write.rs b/clippy_lints/src/explicit_write.rs index 0a52e252de9..a96b23a87d8 100644 --- a/clippy_lints/src/explicit_write.rs +++ b/clippy_lints/src/explicit_write.rs @@ -1,10 +1,9 @@ use crate::utils::{is_expn_of, match_function_call, paths, span_lint, span_lint_and_sugg}; use if_chain::if_chain; -use rustc::declare_lint_pass; -use rustc::lint::{LateContext, LateLintPass, LintArray, LintPass}; +use rustc::lint::{LateContext, LateLintPass}; use rustc_errors::Applicability; use rustc_hir::*; -use rustc_session::declare_tool_lint; +use rustc_session::{declare_lint_pass, declare_tool_lint}; use syntax::ast::LitKind; declare_clippy_lint! { diff --git a/clippy_lints/src/fallible_impl_from.rs b/clippy_lints/src/fallible_impl_from.rs index 6aafb5e1ef1..3da9ed5d443 100644 --- a/clippy_lints/src/fallible_impl_from.rs +++ b/clippy_lints/src/fallible_impl_from.rs @@ -1,12 +1,11 @@ use crate::utils::paths::{BEGIN_PANIC, BEGIN_PANIC_FMT, FROM_TRAIT, OPTION, RESULT}; use crate::utils::{is_expn_of, match_def_path, method_chain_args, span_lint_and_then, walk_ptrs_ty}; use if_chain::if_chain; -use rustc::declare_lint_pass; use rustc::hir::map::Map; -use rustc::lint::{LateContext, LateLintPass, LintArray, LintPass}; +use rustc::lint::{LateContext, LateLintPass}; use rustc::ty::{self, Ty}; use rustc_hir as hir; -use rustc_session::declare_tool_lint; +use rustc_session::{declare_lint_pass, declare_tool_lint}; use rustc_span::Span; declare_clippy_lint! { diff --git a/clippy_lints/src/format.rs b/clippy_lints/src/format.rs index bd0e1ab2909..3082153fa99 100644 --- a/clippy_lints/src/format.rs +++ b/clippy_lints/src/format.rs @@ -4,11 +4,10 @@ use crate::utils::{ walk_ptrs_ty, }; use if_chain::if_chain; -use rustc::declare_lint_pass; -use rustc::lint::{LateContext, LateLintPass, LintArray, LintContext, LintPass}; +use rustc::lint::{LateContext, LateLintPass, LintContext}; use rustc_errors::Applicability; use rustc_hir::*; -use rustc_session::declare_tool_lint; +use rustc_session::{declare_lint_pass, declare_tool_lint}; use rustc_span::source_map::Span; use syntax::ast::LitKind; diff --git a/clippy_lints/src/formatting.rs b/clippy_lints/src/formatting.rs index d31b15cba9e..18d12fd30fb 100644 --- a/clippy_lints/src/formatting.rs +++ b/clippy_lints/src/formatting.rs @@ -1,8 +1,7 @@ use crate::utils::{differing_macro_contexts, snippet_opt, span_help_and_lint, span_note_and_lint}; use if_chain::if_chain; -use rustc::declare_lint_pass; -use rustc::lint::{in_external_macro, EarlyContext, EarlyLintPass, LintArray, LintPass}; -use rustc_session::declare_tool_lint; +use rustc::lint::{in_external_macro, EarlyContext, EarlyLintPass}; +use rustc_session::{declare_lint_pass, declare_tool_lint}; use syntax::ast::*; declare_clippy_lint! { diff --git a/clippy_lints/src/functions.rs b/clippy_lints/src/functions.rs index 65a5e7be830..77bd4a86444 100644 --- a/clippy_lints/src/functions.rs +++ b/clippy_lints/src/functions.rs @@ -5,15 +5,14 @@ use crate::utils::{ }; use matches::matches; use rustc::hir::map::Map; -use rustc::impl_lint_pass; -use rustc::lint::{in_external_macro, LateContext, LateLintPass, LintArray, LintContext, LintPass}; +use rustc::lint::{in_external_macro, LateContext, LateLintPass, LintContext}; use rustc::ty::{self, Ty}; use rustc_data_structures::fx::FxHashSet; use rustc_errors::Applicability; use rustc_hir as hir; use rustc_hir::intravisit; use rustc_hir::{def::Res, def_id::DefId}; -use rustc_session::declare_tool_lint; +use rustc_session::{declare_tool_lint, impl_lint_pass}; use rustc_span::source_map::Span; use rustc_target::spec::abi::Abi; use syntax::ast::Attribute; diff --git a/clippy_lints/src/get_last_with_len.rs b/clippy_lints/src/get_last_with_len.rs index c9939bc5d7c..50f9defbed3 100644 --- a/clippy_lints/src/get_last_with_len.rs +++ b/clippy_lints/src/get_last_with_len.rs @@ -2,11 +2,10 @@ use crate::utils::{is_type_diagnostic_item, snippet_with_applicability, span_lint_and_sugg, SpanlessEq}; use if_chain::if_chain; -use rustc::declare_lint_pass; -use rustc::lint::{LateContext, LateLintPass, LintArray, LintPass}; +use rustc::lint::{LateContext, LateLintPass}; use rustc_errors::Applicability; use rustc_hir::{BinOpKind, Expr, ExprKind}; -use rustc_session::declare_tool_lint; +use rustc_session::{declare_lint_pass, declare_tool_lint}; use rustc_span::source_map::Spanned; use rustc_span::symbol::Symbol; use syntax::ast::LitKind; diff --git a/clippy_lints/src/identity_conversion.rs b/clippy_lints/src/identity_conversion.rs index 54cf499ae3b..1720e86db87 100644 --- a/clippy_lints/src/identity_conversion.rs +++ b/clippy_lints/src/identity_conversion.rs @@ -1,11 +1,10 @@ use crate::utils::{ match_def_path, match_trait_method, paths, same_tys, snippet, snippet_with_macro_callsite, span_lint_and_then, }; -use rustc::impl_lint_pass; -use rustc::lint::{LateContext, LateLintPass, LintArray, LintPass}; +use rustc::lint::{LateContext, LateLintPass}; use rustc_errors::Applicability; use rustc_hir::*; -use rustc_session::declare_tool_lint; +use rustc_session::{declare_tool_lint, impl_lint_pass}; declare_clippy_lint! { /// **What it does:** Checks for always-identical `Into`/`From`/`IntoIter` conversions. diff --git a/clippy_lints/src/identity_op.rs b/clippy_lints/src/identity_op.rs index b6d02ff9e76..303af53f664 100644 --- a/clippy_lints/src/identity_op.rs +++ b/clippy_lints/src/identity_op.rs @@ -1,8 +1,7 @@ -use rustc::declare_lint_pass; -use rustc::lint::{LateContext, LateLintPass, LintArray, LintPass}; +use rustc::lint::{LateContext, LateLintPass}; use rustc::ty; use rustc_hir::*; -use rustc_session::declare_tool_lint; +use rustc_session::{declare_lint_pass, declare_tool_lint}; use rustc_span::source_map::Span; use crate::consts::{constant_simple, Constant}; diff --git a/clippy_lints/src/if_not_else.rs b/clippy_lints/src/if_not_else.rs index a266d7c2434..add37f1c86c 100644 --- a/clippy_lints/src/if_not_else.rs +++ b/clippy_lints/src/if_not_else.rs @@ -1,9 +1,8 @@ //! lint on if branches that could be swapped so no `!` operation is necessary //! on the condition -use rustc::declare_lint_pass; -use rustc::lint::{in_external_macro, EarlyContext, EarlyLintPass, LintArray, LintContext, LintPass}; -use rustc_session::declare_tool_lint; +use rustc::lint::{in_external_macro, EarlyContext, EarlyLintPass, LintContext}; +use rustc_session::{declare_lint_pass, declare_tool_lint}; use syntax::ast::*; use crate::utils::span_help_and_lint; diff --git a/clippy_lints/src/implicit_return.rs b/clippy_lints/src/implicit_return.rs index ef1e7ea96dc..4623b327e26 100644 --- a/clippy_lints/src/implicit_return.rs +++ b/clippy_lints/src/implicit_return.rs @@ -4,14 +4,11 @@ use crate::utils::{ snippet_opt, span_lint_and_then, }; use if_chain::if_chain; -use rustc::{ - declare_lint_pass, - lint::{LateContext, LateLintPass, LintArray, LintPass}, -}; +use rustc::lint::{LateContext, LateLintPass}; use rustc_errors::Applicability; use rustc_hir::intravisit::FnKind; use rustc_hir::{Body, Expr, ExprKind, FnDecl, HirId, MatchSource, StmtKind}; -use rustc_session::declare_tool_lint; +use rustc_session::{declare_lint_pass, declare_tool_lint}; use rustc_span::source_map::Span; declare_clippy_lint! { diff --git a/clippy_lints/src/indexing_slicing.rs b/clippy_lints/src/indexing_slicing.rs index 9083f5823aa..f6be230cb91 100644 --- a/clippy_lints/src/indexing_slicing.rs +++ b/clippy_lints/src/indexing_slicing.rs @@ -4,11 +4,10 @@ use crate::consts::{constant, Constant}; use crate::utils; use crate::utils::higher; use crate::utils::higher::Range; -use rustc::declare_lint_pass; -use rustc::lint::{LateContext, LateLintPass, LintArray, LintPass}; +use rustc::lint::{LateContext, LateLintPass}; use rustc::ty; use rustc_hir::*; -use rustc_session::declare_tool_lint; +use rustc_session::{declare_lint_pass, declare_tool_lint}; use syntax::ast::RangeLimits; declare_clippy_lint! { diff --git a/clippy_lints/src/infallible_destructuring_match.rs b/clippy_lints/src/infallible_destructuring_match.rs index d70b45eaecb..93cbd88409f 100644 --- a/clippy_lints/src/infallible_destructuring_match.rs +++ b/clippy_lints/src/infallible_destructuring_match.rs @@ -1,10 +1,9 @@ use super::utils::{get_arg_name, match_var, remove_blocks, snippet_with_applicability, span_lint_and_sugg}; use if_chain::if_chain; -use rustc::declare_lint_pass; -use rustc::lint::{LateContext, LateLintPass, LintArray, LintPass}; +use rustc::lint::{LateContext, LateLintPass}; use rustc_errors::Applicability; use rustc_hir::*; -use rustc_session::declare_tool_lint; +use rustc_session::{declare_lint_pass, declare_tool_lint}; declare_clippy_lint! { /// **What it does:** Checks for matches being used to destructure a single-variant enum diff --git a/clippy_lints/src/infinite_iter.rs b/clippy_lints/src/infinite_iter.rs index 25c97d5af80..037088e810e 100644 --- a/clippy_lints/src/infinite_iter.rs +++ b/clippy_lints/src/infinite_iter.rs @@ -1,7 +1,6 @@ -use rustc::declare_lint_pass; -use rustc::lint::{LateContext, LateLintPass, LintArray, LintPass}; +use rustc::lint::{LateContext, LateLintPass}; use rustc_hir::*; -use rustc_session::declare_tool_lint; +use rustc_session::{declare_lint_pass, declare_tool_lint}; use crate::utils::{get_trait_def_id, higher, implements_trait, match_qpath, match_type, paths, span_lint}; diff --git a/clippy_lints/src/inherent_impl.rs b/clippy_lints/src/inherent_impl.rs index c162de3ad8c..ed855484fe0 100644 --- a/clippy_lints/src/inherent_impl.rs +++ b/clippy_lints/src/inherent_impl.rs @@ -1,11 +1,10 @@ //! lint on inherent implementations use crate::utils::{in_macro, span_lint_and_then}; -use rustc::impl_lint_pass; -use rustc::lint::{LateContext, LateLintPass, LintArray, LintPass}; +use rustc::lint::{LateContext, LateLintPass}; use rustc_data_structures::fx::FxHashMap; use rustc_hir::*; -use rustc_session::declare_tool_lint; +use rustc_session::{declare_tool_lint, impl_lint_pass}; use rustc_span::Span; declare_clippy_lint! { diff --git a/clippy_lints/src/inherent_to_string.rs b/clippy_lints/src/inherent_to_string.rs index 9d7c3b46fed..4bfadc34f61 100644 --- a/clippy_lints/src/inherent_to_string.rs +++ b/clippy_lints/src/inherent_to_string.rs @@ -1,8 +1,7 @@ use if_chain::if_chain; -use rustc::declare_lint_pass; -use rustc::lint::{LateContext, LateLintPass, LintArray, LintPass}; +use rustc::lint::{LateContext, LateLintPass}; use rustc_hir::{ImplItem, ImplItemKind}; -use rustc_session::declare_tool_lint; +use rustc_session::{declare_lint_pass, declare_tool_lint}; use crate::utils::{ get_trait_def_id, implements_trait, match_type, paths, return_ty, span_help_and_lint, trait_ref_of_method, diff --git a/clippy_lints/src/inline_fn_without_body.rs b/clippy_lints/src/inline_fn_without_body.rs index 4ffc45703ed..54450886448 100644 --- a/clippy_lints/src/inline_fn_without_body.rs +++ b/clippy_lints/src/inline_fn_without_body.rs @@ -2,11 +2,10 @@ use crate::utils::span_lint_and_then; use crate::utils::sugg::DiagnosticBuilderExt; -use rustc::declare_lint_pass; -use rustc::lint::{LateContext, LateLintPass, LintArray, LintPass}; +use rustc::lint::{LateContext, LateLintPass}; use rustc_errors::Applicability; use rustc_hir::*; -use rustc_session::declare_tool_lint; +use rustc_session::{declare_lint_pass, declare_tool_lint}; use syntax::ast::{Attribute, Name}; declare_clippy_lint! { diff --git a/clippy_lints/src/int_plus_one.rs b/clippy_lints/src/int_plus_one.rs index d9dd1392360..a906fccf5fa 100644 --- a/clippy_lints/src/int_plus_one.rs +++ b/clippy_lints/src/int_plus_one.rs @@ -1,9 +1,8 @@ //! lint on blocks unnecessarily using >= with a + 1 or - 1 -use rustc::declare_lint_pass; -use rustc::lint::{EarlyContext, EarlyLintPass, LintArray, LintPass}; +use rustc::lint::{EarlyContext, EarlyLintPass}; use rustc_errors::Applicability; -use rustc_session::declare_tool_lint; +use rustc_session::{declare_lint_pass, declare_tool_lint}; use syntax::ast::*; use crate::utils::{snippet_opt, span_lint_and_then}; diff --git a/clippy_lints/src/integer_division.rs b/clippy_lints/src/integer_division.rs index feb9fac93c9..1d3b6ae2124 100644 --- a/clippy_lints/src/integer_division.rs +++ b/clippy_lints/src/integer_division.rs @@ -1,9 +1,8 @@ use crate::utils::span_help_and_lint; use if_chain::if_chain; -use rustc::declare_lint_pass; -use rustc::lint::{LateContext, LateLintPass, LintArray, LintPass}; +use rustc::lint::{LateContext, LateLintPass}; use rustc_hir as hir; -use rustc_session::declare_tool_lint; +use rustc_session::{declare_lint_pass, declare_tool_lint}; declare_clippy_lint! { /// **What it does:** Checks for division of integers diff --git a/clippy_lints/src/items_after_statements.rs b/clippy_lints/src/items_after_statements.rs index 06ed5e29c85..cc13498ad23 100644 --- a/clippy_lints/src/items_after_statements.rs +++ b/clippy_lints/src/items_after_statements.rs @@ -2,9 +2,8 @@ use crate::utils::span_lint; use matches::matches; -use rustc::declare_lint_pass; -use rustc::lint::{EarlyContext, EarlyLintPass, LintArray, LintPass}; -use rustc_session::declare_tool_lint; +use rustc::lint::{EarlyContext, EarlyLintPass}; +use rustc_session::{declare_lint_pass, declare_tool_lint}; use syntax::ast::*; declare_clippy_lint! { diff --git a/clippy_lints/src/large_enum_variant.rs b/clippy_lints/src/large_enum_variant.rs index f2638d59879..148446c4196 100644 --- a/clippy_lints/src/large_enum_variant.rs +++ b/clippy_lints/src/large_enum_variant.rs @@ -1,12 +1,11 @@ //! lint when there is a large size difference between variants on an enum use crate::utils::{snippet_opt, span_lint_and_then}; -use rustc::impl_lint_pass; -use rustc::lint::{LateContext, LateLintPass, LintArray, LintPass}; +use rustc::lint::{LateContext, LateLintPass}; use rustc::ty::layout::LayoutOf; use rustc_errors::Applicability; use rustc_hir::*; -use rustc_session::declare_tool_lint; +use rustc_session::{declare_tool_lint, impl_lint_pass}; declare_clippy_lint! { /// **What it does:** Checks for large size differences between variants on diff --git a/clippy_lints/src/large_stack_arrays.rs b/clippy_lints/src/large_stack_arrays.rs index eef583a6e62..28810696cc1 100644 --- a/clippy_lints/src/large_stack_arrays.rs +++ b/clippy_lints/src/large_stack_arrays.rs @@ -1,9 +1,8 @@ -use rustc::impl_lint_pass; -use rustc::lint::{LateContext, LateLintPass, LintArray, LintPass}; +use rustc::lint::{LateContext, LateLintPass}; use rustc::mir::interpret::ConstValue; use rustc::ty::{self, ConstKind}; use rustc_hir::*; -use rustc_session::declare_tool_lint; +use rustc_session::{declare_tool_lint, impl_lint_pass}; use if_chain::if_chain; diff --git a/clippy_lints/src/len_zero.rs b/clippy_lints/src/len_zero.rs index 653e82a2338..d2afd51fba8 100644 --- a/clippy_lints/src/len_zero.rs +++ b/clippy_lints/src/len_zero.rs @@ -1,12 +1,11 @@ use crate::utils::{get_item_name, snippet_with_applicability, span_lint, span_lint_and_sugg, walk_ptrs_ty}; -use rustc::declare_lint_pass; -use rustc::lint::{LateContext, LateLintPass, LintArray, LintPass}; +use rustc::lint::{LateContext, LateLintPass}; use rustc::ty; use rustc_data_structures::fx::FxHashSet; use rustc_errors::Applicability; use rustc_hir::def_id::DefId; use rustc_hir::*; -use rustc_session::declare_tool_lint; +use rustc_session::{declare_lint_pass, declare_tool_lint}; use rustc_span::source_map::{Span, Spanned}; use syntax::ast::{LitKind, Name}; diff --git a/clippy_lints/src/let_if_seq.rs b/clippy_lints/src/let_if_seq.rs index 2b430f71f22..27d14bbd67f 100644 --- a/clippy_lints/src/let_if_seq.rs +++ b/clippy_lints/src/let_if_seq.rs @@ -1,14 +1,13 @@ use crate::utils::{higher, qpath_res, snippet, span_lint_and_then}; use if_chain::if_chain; -use rustc::declare_lint_pass; use rustc::hir::map::Map; -use rustc::lint::{LateContext, LateLintPass, LintArray, LintPass}; +use rustc::lint::{LateContext, LateLintPass}; use rustc_errors::Applicability; use rustc_hir as hir; use rustc_hir::def::Res; use rustc_hir::intravisit; use rustc_hir::BindingAnnotation; -use rustc_session::declare_tool_lint; +use rustc_session::{declare_lint_pass, declare_tool_lint}; declare_clippy_lint! { /// **What it does:** Checks for variable declarations immediately followed by a diff --git a/clippy_lints/src/let_underscore.rs b/clippy_lints/src/let_underscore.rs index 7787a55a2bb..62efcb6b65c 100644 --- a/clippy_lints/src/let_underscore.rs +++ b/clippy_lints/src/let_underscore.rs @@ -1,8 +1,7 @@ use if_chain::if_chain; -use rustc::declare_lint_pass; -use rustc::lint::{LateContext, LateLintPass, LintArray, LintPass}; +use rustc::lint::{LateContext, LateLintPass}; use rustc_hir::*; -use rustc_session::declare_tool_lint; +use rustc_session::{declare_lint_pass, declare_tool_lint}; use crate::utils::{is_must_use_func_call, is_must_use_ty, span_help_and_lint}; diff --git a/clippy_lints/src/lifetimes.rs b/clippy_lints/src/lifetimes.rs index 83f9cf9eac5..2cc44a758ea 100644 --- a/clippy_lints/src/lifetimes.rs +++ b/clippy_lints/src/lifetimes.rs @@ -1,13 +1,12 @@ use matches::matches; -use rustc::declare_lint_pass; use rustc::hir::map::Map; -use rustc::lint::{in_external_macro, LateContext, LateLintPass, LintArray, LintContext, LintPass}; +use rustc::lint::{in_external_macro, LateContext, LateLintPass, LintContext}; use rustc_data_structures::fx::{FxHashMap, FxHashSet}; use rustc_hir::def::{DefKind, Res}; use rustc_hir::intravisit::*; use rustc_hir::FunctionRetTy::Return; use rustc_hir::*; -use rustc_session::declare_tool_lint; +use rustc_session::{declare_lint_pass, declare_tool_lint}; use rustc_span::source_map::Span; use rustc_span::symbol::kw; diff --git a/clippy_lints/src/literal_representation.rs b/clippy_lints/src/literal_representation.rs index 95d13ae05eb..edc287d24d8 100644 --- a/clippy_lints/src/literal_representation.rs +++ b/clippy_lints/src/literal_representation.rs @@ -3,10 +3,9 @@ use crate::utils::{in_macro, snippet_opt, span_lint_and_sugg}; use if_chain::if_chain; -use rustc::lint::{in_external_macro, EarlyContext, EarlyLintPass, LintArray, LintContext, LintPass}; -use rustc::{declare_lint_pass, impl_lint_pass}; +use rustc::lint::{in_external_macro, EarlyContext, EarlyLintPass, LintContext}; use rustc_errors::Applicability; -use rustc_session::declare_tool_lint; +use rustc_session::{declare_lint_pass, declare_tool_lint, impl_lint_pass}; use syntax::ast::*; declare_clippy_lint! { diff --git a/clippy_lints/src/loops.rs b/clippy_lints/src/loops.rs index 1c7407eebc6..8d7be8bca46 100644 --- a/clippy_lints/src/loops.rs +++ b/clippy_lints/src/loops.rs @@ -1,14 +1,13 @@ use crate::reexport::*; use if_chain::if_chain; use itertools::Itertools; -use rustc::declare_lint_pass; -use rustc::lint::{in_external_macro, LateContext, LateLintPass, LintArray, LintContext, LintPass}; +use rustc::lint::{in_external_macro, LateContext, LateLintPass, LintContext}; use rustc::middle::region; use rustc_hir::def::{DefKind, Res}; use rustc_hir::def_id; use rustc_hir::intravisit::{walk_block, walk_expr, walk_pat, walk_stmt, NestedVisitorMap, Visitor}; use rustc_hir::*; -use rustc_session::declare_tool_lint; +use rustc_session::{declare_lint_pass, declare_tool_lint}; // use rustc::middle::region::CodeExtent; use crate::consts::{constant, Constant}; use crate::utils::usage::mutated_variables; diff --git a/clippy_lints/src/main_recursion.rs b/clippy_lints/src/main_recursion.rs index 31b2dbf2ae4..0513eb8ac9e 100644 --- a/clippy_lints/src/main_recursion.rs +++ b/clippy_lints/src/main_recursion.rs @@ -1,7 +1,6 @@ -use rustc::impl_lint_pass; -use rustc::lint::{LateContext, LateLintPass, LintArray, LintPass}; +use rustc::lint::{LateContext, LateLintPass}; use rustc_hir::{Crate, Expr, ExprKind, QPath}; -use rustc_session::declare_tool_lint; +use rustc_session::{declare_tool_lint, impl_lint_pass}; use rustc_span::symbol::sym; use syntax::ast::AttrKind; diff --git a/clippy_lints/src/map_clone.rs b/clippy_lints/src/map_clone.rs index ae2d0830128..99d7c849f84 100644 --- a/clippy_lints/src/map_clone.rs +++ b/clippy_lints/src/map_clone.rs @@ -3,12 +3,11 @@ use crate::utils::{ is_copy, match_trait_method, match_type, remove_blocks, snippet_with_applicability, span_lint_and_sugg, }; use if_chain::if_chain; -use rustc::declare_lint_pass; -use rustc::lint::{LateContext, LateLintPass, LintArray, LintPass}; +use rustc::lint::{LateContext, LateLintPass}; use rustc::ty; use rustc_errors::Applicability; use rustc_hir as hir; -use rustc_session::declare_tool_lint; +use rustc_session::{declare_lint_pass, declare_tool_lint}; use rustc_span::source_map::Span; use syntax::ast::Ident; diff --git a/clippy_lints/src/map_unit_fn.rs b/clippy_lints/src/map_unit_fn.rs index 3855b5a21f9..5a7950927bb 100644 --- a/clippy_lints/src/map_unit_fn.rs +++ b/clippy_lints/src/map_unit_fn.rs @@ -1,12 +1,11 @@ use crate::utils::paths; use crate::utils::{iter_input_pats, match_type, method_chain_args, snippet, span_lint_and_then}; use if_chain::if_chain; -use rustc::declare_lint_pass; -use rustc::lint::{LateContext, LateLintPass, LintArray, LintPass}; +use rustc::lint::{LateContext, LateLintPass}; use rustc::ty::{self, Ty}; use rustc_errors::Applicability; use rustc_hir as hir; -use rustc_session::declare_tool_lint; +use rustc_session::{declare_lint_pass, declare_tool_lint}; use rustc_span::source_map::Span; declare_clippy_lint! { diff --git a/clippy_lints/src/matches.rs b/clippy_lints/src/matches.rs index fca8e1446a8..b11faef1f0d 100644 --- a/clippy_lints/src/matches.rs +++ b/clippy_lints/src/matches.rs @@ -7,13 +7,12 @@ use crate::utils::{ walk_ptrs_ty, }; use if_chain::if_chain; -use rustc::declare_lint_pass; -use rustc::lint::{in_external_macro, LateContext, LateLintPass, LintArray, LintContext, LintPass}; +use rustc::lint::{in_external_macro, LateContext, LateLintPass, LintContext}; use rustc::ty::{self, Ty}; use rustc_errors::Applicability; use rustc_hir::def::CtorKind; use rustc_hir::*; -use rustc_session::declare_tool_lint; +use rustc_session::{declare_lint_pass, declare_tool_lint}; use rustc_span::source_map::Span; use std::cmp::Ordering; use std::collections::Bound; diff --git a/clippy_lints/src/mem_discriminant.rs b/clippy_lints/src/mem_discriminant.rs index 636c0f97578..ba231368b76 100644 --- a/clippy_lints/src/mem_discriminant.rs +++ b/clippy_lints/src/mem_discriminant.rs @@ -1,10 +1,9 @@ use crate::utils::{match_def_path, paths, snippet, span_lint_and_then, walk_ptrs_ty_depth}; use if_chain::if_chain; -use rustc::declare_lint_pass; -use rustc::lint::{LateContext, LateLintPass, LintArray, LintPass}; +use rustc::lint::{LateContext, LateLintPass}; use rustc_errors::Applicability; use rustc_hir::{BorrowKind, Expr, ExprKind}; -use rustc_session::declare_tool_lint; +use rustc_session::{declare_lint_pass, declare_tool_lint}; use std::iter; diff --git a/clippy_lints/src/mem_forget.rs b/clippy_lints/src/mem_forget.rs index 4172ea33950..32c784f7935 100644 --- a/clippy_lints/src/mem_forget.rs +++ b/clippy_lints/src/mem_forget.rs @@ -1,8 +1,7 @@ use crate::utils::{match_def_path, paths, qpath_res, span_lint}; -use rustc::declare_lint_pass; -use rustc::lint::{LateContext, LateLintPass, LintArray, LintPass}; +use rustc::lint::{LateContext, LateLintPass}; use rustc_hir::{Expr, ExprKind}; -use rustc_session::declare_tool_lint; +use rustc_session::{declare_lint_pass, declare_tool_lint}; declare_clippy_lint! { /// **What it does:** Checks for usage of `std::mem::forget(t)` where `t` is diff --git a/clippy_lints/src/mem_replace.rs b/clippy_lints/src/mem_replace.rs index e6b50e546ad..d994a2eab65 100644 --- a/clippy_lints/src/mem_replace.rs +++ b/clippy_lints/src/mem_replace.rs @@ -3,11 +3,10 @@ use crate::utils::{ span_lint_and_sugg, span_lint_and_then, }; use if_chain::if_chain; -use rustc::declare_lint_pass; -use rustc::lint::{in_external_macro, LateContext, LateLintPass, LintArray, LintPass}; +use rustc::lint::{in_external_macro, LateContext, LateLintPass}; use rustc_errors::Applicability; use rustc_hir::{BorrowKind, Expr, ExprKind, Mutability, QPath}; -use rustc_session::declare_tool_lint; +use rustc_session::{declare_lint_pass, declare_tool_lint}; use rustc_span::source_map::Span; declare_clippy_lint! { diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs index 3f621cb8b28..073177b0f3d 100644 --- a/clippy_lints/src/methods/mod.rs +++ b/clippy_lints/src/methods/mod.rs @@ -9,14 +9,13 @@ use std::iter; use if_chain::if_chain; use matches::matches; -use rustc::declare_lint_pass; use rustc::hir::map::Map; -use rustc::lint::{in_external_macro, LateContext, LateLintPass, Lint, LintArray, LintContext, LintPass}; +use rustc::lint::{in_external_macro, LateContext, LateLintPass, Lint, LintContext}; use rustc::ty::{self, Predicate, Ty}; use rustc_errors::Applicability; use rustc_hir as hir; use rustc_hir::intravisit::{self, Visitor}; -use rustc_session::declare_tool_lint; +use rustc_session::{declare_lint_pass, declare_tool_lint}; use rustc_span::source_map::Span; use rustc_span::symbol::{sym, Symbol, SymbolStr}; use syntax::ast; diff --git a/clippy_lints/src/minmax.rs b/clippy_lints/src/minmax.rs index 749f6b92515..956ffd61a26 100644 --- a/clippy_lints/src/minmax.rs +++ b/clippy_lints/src/minmax.rs @@ -1,9 +1,8 @@ use crate::consts::{constant_simple, Constant}; use crate::utils::{match_def_path, paths, span_lint}; -use rustc::declare_lint_pass; -use rustc::lint::{LateContext, LateLintPass, LintArray, LintPass}; +use rustc::lint::{LateContext, LateLintPass}; use rustc_hir::*; -use rustc_session::declare_tool_lint; +use rustc_session::{declare_lint_pass, declare_tool_lint}; use std::cmp::Ordering; declare_clippy_lint! { diff --git a/clippy_lints/src/misc.rs b/clippy_lints/src/misc.rs index 2195b486fd9..9085c928a20 100644 --- a/clippy_lints/src/misc.rs +++ b/clippy_lints/src/misc.rs @@ -1,12 +1,11 @@ use if_chain::if_chain; use matches::matches; -use rustc::declare_lint_pass; -use rustc::lint::{LateContext, LateLintPass, LintArray, LintPass}; +use rustc::lint::{LateContext, LateLintPass}; use rustc::ty; use rustc_errors::Applicability; use rustc_hir::intravisit::FnKind; use rustc_hir::*; -use rustc_session::declare_tool_lint; +use rustc_session::{declare_lint_pass, declare_tool_lint}; use rustc_span::source_map::{ExpnKind, Span}; use syntax::ast::LitKind; diff --git a/clippy_lints/src/misc_early.rs b/clippy_lints/src/misc_early.rs index 376d0593fae..d58083486c9 100644 --- a/clippy_lints/src/misc_early.rs +++ b/clippy_lints/src/misc_early.rs @@ -3,11 +3,10 @@ use crate::utils::{ span_lint_and_then, }; use if_chain::if_chain; -use rustc::declare_lint_pass; -use rustc::lint::{in_external_macro, EarlyContext, EarlyLintPass, LintArray, LintContext, LintPass}; +use rustc::lint::{in_external_macro, EarlyContext, EarlyLintPass, LintContext}; use rustc_data_structures::fx::FxHashMap; use rustc_errors::Applicability; -use rustc_session::declare_tool_lint; +use rustc_session::{declare_lint_pass, declare_tool_lint}; use rustc_span::source_map::Span; use syntax::ast::*; use syntax::visit::{walk_expr, FnKind, Visitor}; diff --git a/clippy_lints/src/missing_const_for_fn.rs b/clippy_lints/src/missing_const_for_fn.rs index de734ccb677..e2fc41f41f3 100644 --- a/clippy_lints/src/missing_const_for_fn.rs +++ b/clippy_lints/src/missing_const_for_fn.rs @@ -1,11 +1,10 @@ use crate::utils::{has_drop, is_entrypoint_fn, span_lint, trait_ref_of_method}; -use rustc::declare_lint_pass; -use rustc::lint::{in_external_macro, LateContext, LateLintPass, LintArray, LintPass}; +use rustc::lint::{in_external_macro, LateContext, LateLintPass}; use rustc_hir as hir; use rustc_hir::intravisit::FnKind; use rustc_hir::{Body, Constness, FnDecl, HirId}; use rustc_mir::transform::qualify_min_const_fn::is_min_const_fn; -use rustc_session::declare_tool_lint; +use rustc_session::{declare_lint_pass, declare_tool_lint}; use rustc_span::Span; use rustc_typeck::hir_ty_to_ty; diff --git a/clippy_lints/src/missing_doc.rs b/clippy_lints/src/missing_doc.rs index e736e13deed..eb3f17ca1bf 100644 --- a/clippy_lints/src/missing_doc.rs +++ b/clippy_lints/src/missing_doc.rs @@ -7,11 +7,10 @@ use crate::utils::span_lint; use if_chain::if_chain; -use rustc::impl_lint_pass; -use rustc::lint::{LateContext, LateLintPass, LintArray, LintContext, LintPass}; +use rustc::lint::{LateContext, LateLintPass, LintContext}; use rustc::ty; use rustc_hir as hir; -use rustc_session::declare_tool_lint; +use rustc_session::{declare_tool_lint, impl_lint_pass}; use rustc_span::source_map::Span; use syntax::ast::{self, MetaItem, MetaItemKind}; use syntax::attr; diff --git a/clippy_lints/src/missing_inline.rs b/clippy_lints/src/missing_inline.rs index c25131c520c..2c209398ff9 100644 --- a/clippy_lints/src/missing_inline.rs +++ b/clippy_lints/src/missing_inline.rs @@ -1,8 +1,7 @@ use crate::utils::span_lint; -use rustc::declare_lint_pass; -use rustc::lint::{self, LateContext, LateLintPass, LintArray, LintContext, LintPass}; +use rustc::lint::{self, LateContext, LateLintPass, LintContext}; use rustc_hir as hir; -use rustc_session::declare_tool_lint; +use rustc_session::{declare_lint_pass, declare_tool_lint}; use rustc_span::source_map::Span; use syntax::ast; diff --git a/clippy_lints/src/modulo_arithmetic.rs b/clippy_lints/src/modulo_arithmetic.rs index 82631257da8..6555db36e83 100644 --- a/clippy_lints/src/modulo_arithmetic.rs +++ b/clippy_lints/src/modulo_arithmetic.rs @@ -1,11 +1,10 @@ use crate::consts::{constant, Constant}; use crate::utils::{sext, span_lint_and_then}; use if_chain::if_chain; -use rustc::declare_lint_pass; -use rustc::lint::{LateContext, LateLintPass, LintArray, LintPass}; +use rustc::lint::{LateContext, LateLintPass}; use rustc::ty::{self}; use rustc_hir::*; -use rustc_session::declare_tool_lint; +use rustc_session::{declare_lint_pass, declare_tool_lint}; use std::fmt::Display; declare_clippy_lint! { diff --git a/clippy_lints/src/mul_add.rs b/clippy_lints/src/mul_add.rs index 27f598c141e..eb307bc4ca3 100644 --- a/clippy_lints/src/mul_add.rs +++ b/clippy_lints/src/mul_add.rs @@ -1,8 +1,7 @@ -use rustc::declare_lint_pass; -use rustc::lint::{LateContext, LateLintPass, LintArray, LintPass}; +use rustc::lint::{LateContext, LateLintPass}; use rustc_errors::Applicability; use rustc_hir::*; -use rustc_session::declare_tool_lint; +use rustc_session::{declare_lint_pass, declare_tool_lint}; use crate::utils::*; diff --git a/clippy_lints/src/multiple_crate_versions.rs b/clippy_lints/src/multiple_crate_versions.rs index 4965352e49e..c3a1e58b72d 100644 --- a/clippy_lints/src/multiple_crate_versions.rs +++ b/clippy_lints/src/multiple_crate_versions.rs @@ -1,9 +1,8 @@ //! lint on multiple versions of a crate being used use crate::utils::span_lint; -use rustc::declare_lint_pass; -use rustc::lint::{EarlyContext, EarlyLintPass, LintArray, LintPass}; -use rustc_session::declare_tool_lint; +use rustc::lint::{EarlyContext, EarlyLintPass}; +use rustc_session::{declare_lint_pass, declare_tool_lint}; use rustc_span::source_map::DUMMY_SP; use syntax::ast::*; diff --git a/clippy_lints/src/mut_key.rs b/clippy_lints/src/mut_key.rs index a64467ef6a2..6df93e063b4 100644 --- a/clippy_lints/src/mut_key.rs +++ b/clippy_lints/src/mut_key.rs @@ -1,9 +1,8 @@ use crate::utils::{match_def_path, paths, span_lint, trait_ref_of_method, walk_ptrs_ty}; -use rustc::declare_lint_pass; -use rustc::lint::{LateContext, LateLintPass, LintArray, LintPass}; +use rustc::lint::{LateContext, LateLintPass}; use rustc::ty::{Adt, Dynamic, Opaque, Param, RawPtr, Ref, Ty, TypeAndMut}; use rustc_hir as hir; -use rustc_session::declare_tool_lint; +use rustc_session::{declare_lint_pass, declare_tool_lint}; use rustc_span::source_map::Span; declare_clippy_lint! { diff --git a/clippy_lints/src/mut_mut.rs b/clippy_lints/src/mut_mut.rs index 5cc59936852..d703539ab55 100644 --- a/clippy_lints/src/mut_mut.rs +++ b/clippy_lints/src/mut_mut.rs @@ -1,11 +1,10 @@ use crate::utils::{higher, span_lint}; -use rustc::declare_lint_pass; use rustc::hir::map::Map; -use rustc::lint::{in_external_macro, LateContext, LateLintPass, LintArray, LintContext, LintPass}; +use rustc::lint::{in_external_macro, LateContext, LateLintPass, LintContext}; use rustc::ty; use rustc_hir as hir; use rustc_hir::intravisit; -use rustc_session::declare_tool_lint; +use rustc_session::{declare_lint_pass, declare_tool_lint}; declare_clippy_lint! { /// **What it does:** Checks for instances of `mut mut` references. diff --git a/clippy_lints/src/mut_reference.rs b/clippy_lints/src/mut_reference.rs index 165b3a7c7e6..59d489a74bb 100644 --- a/clippy_lints/src/mut_reference.rs +++ b/clippy_lints/src/mut_reference.rs @@ -1,10 +1,9 @@ use crate::utils::span_lint; -use rustc::declare_lint_pass; -use rustc::lint::{LateContext, LateLintPass, LintArray, LintPass}; +use rustc::lint::{LateContext, LateLintPass}; use rustc::ty::subst::Subst; use rustc::ty::{self, Ty}; use rustc_hir::*; -use rustc_session::declare_tool_lint; +use rustc_session::{declare_lint_pass, declare_tool_lint}; declare_clippy_lint! { /// **What it does:** Detects giving a mutable reference to a function that only diff --git a/clippy_lints/src/mutable_debug_assertion.rs b/clippy_lints/src/mutable_debug_assertion.rs index 0918886a979..8815e394092 100644 --- a/clippy_lints/src/mutable_debug_assertion.rs +++ b/clippy_lints/src/mutable_debug_assertion.rs @@ -2,11 +2,11 @@ use crate::utils::{is_direct_expn_of, span_lint}; use if_chain::if_chain; use matches::matches; use rustc::hir::map::Map; -use rustc::lint::{LateContext, LateLintPass, LintArray, LintPass}; -use rustc::{declare_lint_pass, ty}; +use rustc::lint::{LateContext, LateLintPass}; +use rustc::ty; use rustc_hir::intravisit::{walk_expr, NestedVisitorMap, Visitor}; use rustc_hir::{BorrowKind, Expr, ExprKind, Mutability, StmtKind, UnOp}; -use rustc_session::declare_tool_lint; +use rustc_session::{declare_lint_pass, declare_tool_lint}; use rustc_span::Span; declare_clippy_lint! { diff --git a/clippy_lints/src/mutex_atomic.rs b/clippy_lints/src/mutex_atomic.rs index e04bd56e054..f0ef16a05bc 100644 --- a/clippy_lints/src/mutex_atomic.rs +++ b/clippy_lints/src/mutex_atomic.rs @@ -3,11 +3,10 @@ //! This lint is **warn** by default use crate::utils::{match_type, paths, span_lint}; -use rustc::declare_lint_pass; -use rustc::lint::{LateContext, LateLintPass, LintArray, LintPass}; +use rustc::lint::{LateContext, LateLintPass}; use rustc::ty::{self, Ty}; use rustc_hir::Expr; -use rustc_session::declare_tool_lint; +use rustc_session::{declare_lint_pass, declare_tool_lint}; use syntax::ast; declare_clippy_lint! { diff --git a/clippy_lints/src/needless_bool.rs b/clippy_lints/src/needless_bool.rs index 78c121b6dd8..3d73c502211 100644 --- a/clippy_lints/src/needless_bool.rs +++ b/clippy_lints/src/needless_bool.rs @@ -4,11 +4,10 @@ use crate::utils::sugg::Sugg; use crate::utils::{higher, parent_node_is_if_expr, span_lint, span_lint_and_sugg}; -use rustc::declare_lint_pass; -use rustc::lint::{LateContext, LateLintPass, LintArray, LintPass}; +use rustc::lint::{LateContext, LateLintPass}; use rustc_errors::Applicability; use rustc_hir::*; -use rustc_session::declare_tool_lint; +use rustc_session::{declare_lint_pass, declare_tool_lint}; use rustc_span::source_map::Spanned; use syntax::ast::LitKind; diff --git a/clippy_lints/src/needless_borrow.rs b/clippy_lints/src/needless_borrow.rs index 98550147274..18e30252c47 100644 --- a/clippy_lints/src/needless_borrow.rs +++ b/clippy_lints/src/needless_borrow.rs @@ -4,13 +4,12 @@ use crate::utils::{snippet_opt, span_lint_and_then}; use if_chain::if_chain; -use rustc::impl_lint_pass; -use rustc::lint::{LateContext, LateLintPass, LintArray, LintPass}; +use rustc::lint::{LateContext, LateLintPass}; use rustc::ty; use rustc::ty::adjustment::{Adjust, Adjustment}; use rustc_errors::Applicability; use rustc_hir::{BindingAnnotation, BorrowKind, Expr, ExprKind, HirId, Item, Mutability, Pat, PatKind}; -use rustc_session::declare_tool_lint; +use rustc_session::{declare_tool_lint, impl_lint_pass}; declare_clippy_lint! { /// **What it does:** Checks for address of operations (`&`) that are going to diff --git a/clippy_lints/src/needless_borrowed_ref.rs b/clippy_lints/src/needless_borrowed_ref.rs index f05b47cf926..497ce3c2927 100644 --- a/clippy_lints/src/needless_borrowed_ref.rs +++ b/clippy_lints/src/needless_borrowed_ref.rs @@ -4,11 +4,10 @@ use crate::utils::{snippet_with_applicability, span_lint_and_then}; use if_chain::if_chain; -use rustc::declare_lint_pass; -use rustc::lint::{LateContext, LateLintPass, LintArray, LintPass}; +use rustc::lint::{LateContext, LateLintPass}; use rustc_errors::Applicability; use rustc_hir::{BindingAnnotation, Mutability, Node, Pat, PatKind}; -use rustc_session::declare_tool_lint; +use rustc_session::{declare_lint_pass, declare_tool_lint}; declare_clippy_lint! { /// **What it does:** Checks for useless borrowed references. diff --git a/clippy_lints/src/needless_continue.rs b/clippy_lints/src/needless_continue.rs index f35b84c449b..81f8eb0cc52 100644 --- a/clippy_lints/src/needless_continue.rs +++ b/clippy_lints/src/needless_continue.rs @@ -33,9 +33,8 @@ //! ``` //! //! This lint is **warn** by default. -use rustc::declare_lint_pass; -use rustc::lint::{EarlyContext, EarlyLintPass, LintArray, LintPass}; -use rustc_session::declare_tool_lint; +use rustc::lint::{EarlyContext, EarlyLintPass}; +use rustc_session::{declare_lint_pass, declare_tool_lint}; use rustc_span::source_map::{original_sp, DUMMY_SP}; use std::borrow::Cow; use syntax::ast; diff --git a/clippy_lints/src/needless_pass_by_value.rs b/clippy_lints/src/needless_pass_by_value.rs index 3d40618fbf4..a223fe57321 100644 --- a/clippy_lints/src/needless_pass_by_value.rs +++ b/clippy_lints/src/needless_pass_by_value.rs @@ -5,8 +5,7 @@ use crate::utils::{ }; use if_chain::if_chain; use matches::matches; -use rustc::declare_lint_pass; -use rustc::lint::{LateContext, LateLintPass, LintArray, LintPass}; +use rustc::lint::{LateContext, LateLintPass}; use rustc::traits; use rustc::traits::misc::can_type_implement_copy; use rustc::ty::{self, RegionKind, TypeFoldable}; @@ -14,7 +13,7 @@ use rustc_data_structures::fx::{FxHashMap, FxHashSet}; use rustc_errors::{Applicability, DiagnosticBuilder}; use rustc_hir::intravisit::FnKind; use rustc_hir::*; -use rustc_session::declare_tool_lint; +use rustc_session::{declare_lint_pass, declare_tool_lint}; use rustc_span::{Span, Symbol}; use rustc_target::spec::abi::Abi; use rustc_typeck::expr_use_visitor as euv; diff --git a/clippy_lints/src/needless_update.rs b/clippy_lints/src/needless_update.rs index f122948893f..f77f0b38015 100644 --- a/clippy_lints/src/needless_update.rs +++ b/clippy_lints/src/needless_update.rs @@ -1,9 +1,8 @@ use crate::utils::span_lint; -use rustc::declare_lint_pass; -use rustc::lint::{LateContext, LateLintPass, LintArray, LintPass}; +use rustc::lint::{LateContext, LateLintPass}; use rustc::ty; use rustc_hir::{Expr, ExprKind}; -use rustc_session::declare_tool_lint; +use rustc_session::{declare_lint_pass, declare_tool_lint}; declare_clippy_lint! { /// **What it does:** Checks for needlessly including a base struct on update diff --git a/clippy_lints/src/neg_cmp_op_on_partial_ord.rs b/clippy_lints/src/neg_cmp_op_on_partial_ord.rs index 1a556fff23f..c85ef532427 100644 --- a/clippy_lints/src/neg_cmp_op_on_partial_ord.rs +++ b/clippy_lints/src/neg_cmp_op_on_partial_ord.rs @@ -1,8 +1,7 @@ use if_chain::if_chain; -use rustc::declare_lint_pass; -use rustc::lint::{in_external_macro, LateContext, LateLintPass, LintArray, LintContext, LintPass}; +use rustc::lint::{in_external_macro, LateContext, LateLintPass, LintContext}; use rustc_hir::*; -use rustc_session::declare_tool_lint; +use rustc_session::{declare_lint_pass, declare_tool_lint}; use crate::utils::{self, paths, span_lint}; diff --git a/clippy_lints/src/neg_multiply.rs b/clippy_lints/src/neg_multiply.rs index 6e77a7a77fa..ac1f031e19b 100644 --- a/clippy_lints/src/neg_multiply.rs +++ b/clippy_lints/src/neg_multiply.rs @@ -1,8 +1,7 @@ use if_chain::if_chain; -use rustc::declare_lint_pass; -use rustc::lint::{LateContext, LateLintPass, LintArray, LintPass}; +use rustc::lint::{LateContext, LateLintPass}; use rustc_hir::*; -use rustc_session::declare_tool_lint; +use rustc_session::{declare_lint_pass, declare_tool_lint}; use rustc_span::source_map::Span; use crate::consts::{self, Constant}; diff --git a/clippy_lints/src/new_without_default.rs b/clippy_lints/src/new_without_default.rs index 84aaa90428d..ee4b2684d30 100644 --- a/clippy_lints/src/new_without_default.rs +++ b/clippy_lints/src/new_without_default.rs @@ -2,14 +2,13 @@ use crate::utils::paths; use crate::utils::sugg::DiagnosticBuilderExt; use crate::utils::{get_trait_def_id, implements_trait, return_ty, same_tys, span_lint_hir_and_then}; use if_chain::if_chain; -use rustc::impl_lint_pass; -use rustc::lint::{in_external_macro, LateContext, LateLintPass, LintArray, LintContext, LintPass}; +use rustc::lint::{in_external_macro, LateContext, LateLintPass, LintContext}; use rustc::ty::{self, Ty}; use rustc_errors::Applicability; use rustc_hir as hir; use rustc_hir::def_id::DefId; use rustc_hir::HirIdSet; -use rustc_session::declare_tool_lint; +use rustc_session::{declare_tool_lint, impl_lint_pass}; use rustc_span::source_map::Span; declare_clippy_lint! { diff --git a/clippy_lints/src/no_effect.rs b/clippy_lints/src/no_effect.rs index 6a00d253c95..409eae184eb 100644 --- a/clippy_lints/src/no_effect.rs +++ b/clippy_lints/src/no_effect.rs @@ -1,10 +1,9 @@ use crate::utils::{has_drop, qpath_res, snippet_opt, span_lint, span_lint_and_sugg}; -use rustc::declare_lint_pass; -use rustc::lint::{LateContext, LateLintPass, LintArray, LintPass}; +use rustc::lint::{LateContext, LateLintPass}; use rustc_errors::Applicability; use rustc_hir::def::{DefKind, Res}; use rustc_hir::{BinOpKind, BlockCheckMode, Expr, ExprKind, Stmt, StmtKind, UnsafeSource}; -use rustc_session::declare_tool_lint; +use rustc_session::{declare_lint_pass, declare_tool_lint}; use std::ops::Deref; declare_clippy_lint! { diff --git a/clippy_lints/src/non_copy_const.rs b/clippy_lints/src/non_copy_const.rs index 6ffad405c2a..cb668d2a3f0 100644 --- a/clippy_lints/src/non_copy_const.rs +++ b/clippy_lints/src/non_copy_const.rs @@ -4,13 +4,12 @@ use std::ptr; -use rustc::declare_lint_pass; -use rustc::lint::{LateContext, LateLintPass, Lint, LintArray, LintPass}; +use rustc::lint::{LateContext, LateLintPass, Lint}; use rustc::ty::adjustment::Adjust; use rustc::ty::{Ty, TypeFlags}; use rustc_hir::def::{DefKind, Res}; use rustc_hir::*; -use rustc_session::declare_tool_lint; +use rustc_session::{declare_lint_pass, declare_tool_lint}; use rustc_span::{InnerSpan, Span, DUMMY_SP}; use rustc_typeck::hir_ty_to_ty; diff --git a/clippy_lints/src/non_expressive_names.rs b/clippy_lints/src/non_expressive_names.rs index 03d0a9a6a56..c7a337d222b 100644 --- a/clippy_lints/src/non_expressive_names.rs +++ b/clippy_lints/src/non_expressive_names.rs @@ -1,7 +1,6 @@ use crate::utils::{span_lint, span_lint_and_then}; -use rustc::impl_lint_pass; -use rustc::lint::{EarlyContext, EarlyLintPass, LintArray, LintPass}; -use rustc_session::declare_tool_lint; +use rustc::lint::{EarlyContext, EarlyLintPass}; +use rustc_session::{declare_tool_lint, impl_lint_pass}; use rustc_span::source_map::Span; use rustc_span::symbol::SymbolStr; use std::cmp::Ordering; diff --git a/clippy_lints/src/ok_if_let.rs b/clippy_lints/src/ok_if_let.rs index 083f0ee2168..106a6f4bc56 100644 --- a/clippy_lints/src/ok_if_let.rs +++ b/clippy_lints/src/ok_if_let.rs @@ -1,9 +1,8 @@ use crate::utils::{match_type, method_chain_args, paths, snippet, span_help_and_lint}; use if_chain::if_chain; -use rustc::declare_lint_pass; -use rustc::lint::{LateContext, LateLintPass, LintArray, LintPass}; +use rustc::lint::{LateContext, LateLintPass}; use rustc_hir::*; -use rustc_session::declare_tool_lint; +use rustc_session::{declare_lint_pass, declare_tool_lint}; declare_clippy_lint! { /// **What it does:*** Checks for unnecessary `ok()` in if let. diff --git a/clippy_lints/src/open_options.rs b/clippy_lints/src/open_options.rs index f41ac30c481..0d96df13745 100644 --- a/clippy_lints/src/open_options.rs +++ b/clippy_lints/src/open_options.rs @@ -1,8 +1,7 @@ use crate::utils::{match_type, paths, span_lint, walk_ptrs_ty}; -use rustc::declare_lint_pass; -use rustc::lint::{LateContext, LateLintPass, LintArray, LintPass}; +use rustc::lint::{LateContext, LateLintPass}; use rustc_hir::{Expr, ExprKind}; -use rustc_session::declare_tool_lint; +use rustc_session::{declare_lint_pass, declare_tool_lint}; use rustc_span::source_map::{Span, Spanned}; use syntax::ast::LitKind; diff --git a/clippy_lints/src/overflow_check_conditional.rs b/clippy_lints/src/overflow_check_conditional.rs index 453ebb1c6e1..42898e97e90 100644 --- a/clippy_lints/src/overflow_check_conditional.rs +++ b/clippy_lints/src/overflow_check_conditional.rs @@ -1,9 +1,8 @@ use crate::utils::{span_lint, SpanlessEq}; use if_chain::if_chain; -use rustc::declare_lint_pass; -use rustc::lint::{LateContext, LateLintPass, LintArray, LintPass}; +use rustc::lint::{LateContext, LateLintPass}; use rustc_hir::*; -use rustc_session::declare_tool_lint; +use rustc_session::{declare_lint_pass, declare_tool_lint}; declare_clippy_lint! { /// **What it does:** Detects classic underflow/overflow checks. diff --git a/clippy_lints/src/panic_unimplemented.rs b/clippy_lints/src/panic_unimplemented.rs index 8677be55918..9034a8111ef 100644 --- a/clippy_lints/src/panic_unimplemented.rs +++ b/clippy_lints/src/panic_unimplemented.rs @@ -1,9 +1,8 @@ use crate::utils::{is_direct_expn_of, is_expn_of, match_function_call, paths, span_lint}; use if_chain::if_chain; -use rustc::declare_lint_pass; -use rustc::lint::{LateContext, LateLintPass, LintArray, LintPass}; +use rustc::lint::{LateContext, LateLintPass}; use rustc_hir::*; -use rustc_session::declare_tool_lint; +use rustc_session::{declare_lint_pass, declare_tool_lint}; use rustc_span::Span; use syntax::ast::LitKind; diff --git a/clippy_lints/src/partialeq_ne_impl.rs b/clippy_lints/src/partialeq_ne_impl.rs index 7522b96e1cd..140fb392149 100644 --- a/clippy_lints/src/partialeq_ne_impl.rs +++ b/clippy_lints/src/partialeq_ne_impl.rs @@ -1,9 +1,8 @@ use crate::utils::{is_automatically_derived, span_lint_hir}; use if_chain::if_chain; -use rustc::declare_lint_pass; -use rustc::lint::{LateContext, LateLintPass, LintArray, LintPass}; +use rustc::lint::{LateContext, LateLintPass}; use rustc_hir::*; -use rustc_session::declare_tool_lint; +use rustc_session::{declare_lint_pass, declare_tool_lint}; declare_clippy_lint! { /// **What it does:** Checks for manual re-implementations of `PartialEq::ne`. diff --git a/clippy_lints/src/path_buf_push_overwrite.rs b/clippy_lints/src/path_buf_push_overwrite.rs index 2ae67d2e995..7cf1d991dd3 100644 --- a/clippy_lints/src/path_buf_push_overwrite.rs +++ b/clippy_lints/src/path_buf_push_overwrite.rs @@ -1,10 +1,9 @@ use crate::utils::{match_type, paths, span_lint_and_sugg, walk_ptrs_ty}; use if_chain::if_chain; -use rustc::declare_lint_pass; -use rustc::lint::{LateContext, LateLintPass, LintArray, LintPass}; +use rustc::lint::{LateContext, LateLintPass}; use rustc_errors::Applicability; use rustc_hir::*; -use rustc_session::declare_tool_lint; +use rustc_session::{declare_lint_pass, declare_tool_lint}; use std::path::{Component, Path}; use syntax::ast::LitKind; diff --git a/clippy_lints/src/precedence.rs b/clippy_lints/src/precedence.rs index 37901a0b1b4..6ffdf048f4e 100644 --- a/clippy_lints/src/precedence.rs +++ b/clippy_lints/src/precedence.rs @@ -1,8 +1,7 @@ use crate::utils::{snippet_with_applicability, span_lint_and_sugg}; -use rustc::declare_lint_pass; -use rustc::lint::{EarlyContext, EarlyLintPass, LintArray, LintPass}; +use rustc::lint::{EarlyContext, EarlyLintPass}; use rustc_errors::Applicability; -use rustc_session::declare_tool_lint; +use rustc_session::{declare_lint_pass, declare_tool_lint}; use rustc_span::source_map::Spanned; use syntax::ast::*; diff --git a/clippy_lints/src/ptr.rs b/clippy_lints/src/ptr.rs index 907a46846d0..340b6a3ccf4 100644 --- a/clippy_lints/src/ptr.rs +++ b/clippy_lints/src/ptr.rs @@ -6,13 +6,12 @@ use crate::utils::{ walk_ptrs_hir_ty, }; use if_chain::if_chain; -use rustc::declare_lint_pass; -use rustc::lint::{LateContext, LateLintPass, LintArray, LintPass}; +use rustc::lint::{LateContext, LateLintPass}; use rustc::ty; use rustc_errors::Applicability; use rustc_hir::QPath; use rustc_hir::*; -use rustc_session::declare_tool_lint; +use rustc_session::{declare_lint_pass, declare_tool_lint}; use rustc_span::source_map::Span; use rustc_span::{MultiSpan, Symbol}; use std::borrow::Cow; diff --git a/clippy_lints/src/ptr_offset_with_cast.rs b/clippy_lints/src/ptr_offset_with_cast.rs index 129adbe5fed..31791c643c4 100644 --- a/clippy_lints/src/ptr_offset_with_cast.rs +++ b/clippy_lints/src/ptr_offset_with_cast.rs @@ -1,9 +1,8 @@ use crate::utils; -use rustc::declare_lint_pass; -use rustc::lint::{LateContext, LateLintPass, LintArray, LintPass}; +use rustc::lint::{LateContext, LateLintPass}; use rustc_errors::Applicability; use rustc_hir::{Expr, ExprKind}; -use rustc_session::declare_tool_lint; +use rustc_session::{declare_lint_pass, declare_tool_lint}; use std::fmt; declare_clippy_lint! { diff --git a/clippy_lints/src/question_mark.rs b/clippy_lints/src/question_mark.rs index 12d0197c3a0..4bd7812442c 100644 --- a/clippy_lints/src/question_mark.rs +++ b/clippy_lints/src/question_mark.rs @@ -1,10 +1,9 @@ use if_chain::if_chain; -use rustc::declare_lint_pass; -use rustc::lint::{LateContext, LateLintPass, LintArray, LintPass}; +use rustc::lint::{LateContext, LateLintPass}; use rustc_errors::Applicability; use rustc_hir::def::{DefKind, Res}; use rustc_hir::*; -use rustc_session::declare_tool_lint; +use rustc_session::{declare_lint_pass, declare_tool_lint}; use crate::utils::paths::*; use crate::utils::sugg::Sugg; diff --git a/clippy_lints/src/ranges.rs b/clippy_lints/src/ranges.rs index a5e61da6740..1cf403f8757 100644 --- a/clippy_lints/src/ranges.rs +++ b/clippy_lints/src/ranges.rs @@ -1,9 +1,8 @@ use if_chain::if_chain; -use rustc::declare_lint_pass; -use rustc::lint::{LateContext, LateLintPass, LintArray, LintPass}; +use rustc::lint::{LateContext, LateLintPass}; use rustc_errors::Applicability; use rustc_hir::*; -use rustc_session::declare_tool_lint; +use rustc_session::{declare_lint_pass, declare_tool_lint}; use rustc_span::source_map::Spanned; use syntax::ast::RangeLimits; diff --git a/clippy_lints/src/redundant_clone.rs b/clippy_lints/src/redundant_clone.rs index c11dfb06a66..59857219976 100644 --- a/clippy_lints/src/redundant_clone.rs +++ b/clippy_lints/src/redundant_clone.rs @@ -4,8 +4,7 @@ use crate::utils::{ }; use if_chain::if_chain; use matches::matches; -use rustc::declare_lint_pass; -use rustc::lint::{LateContext, LateLintPass, LintArray, LintPass}; +use rustc::lint::{LateContext, LateLintPass}; use rustc::mir::{ self, traversal, visit::{MutatingUseContext, PlaceContext, Visitor as _}, @@ -19,7 +18,7 @@ use rustc_index::bit_set::{BitSet, HybridBitSet}; use rustc_mir::dataflow::{ do_dataflow, BitDenotation, BottomValue, DataflowResults, DataflowResultsCursor, DebugFormatted, GenKillSet, }; -use rustc_session::declare_tool_lint; +use rustc_session::{declare_lint_pass, declare_tool_lint}; use rustc_span::source_map::{BytePos, Span}; use std::convert::TryFrom; diff --git a/clippy_lints/src/redundant_field_names.rs b/clippy_lints/src/redundant_field_names.rs index 46010af1c09..a970bf42329 100644 --- a/clippy_lints/src/redundant_field_names.rs +++ b/clippy_lints/src/redundant_field_names.rs @@ -1,8 +1,7 @@ use crate::utils::span_lint_and_sugg; -use rustc::declare_lint_pass; -use rustc::lint::{EarlyContext, EarlyLintPass, LintArray, LintPass}; +use rustc::lint::{EarlyContext, EarlyLintPass}; use rustc_errors::Applicability; -use rustc_session::declare_tool_lint; +use rustc_session::{declare_lint_pass, declare_tool_lint}; use syntax::ast::*; declare_clippy_lint! { diff --git a/clippy_lints/src/redundant_pattern_matching.rs b/clippy_lints/src/redundant_pattern_matching.rs index 59e55e58398..7e2c7a7a331 100644 --- a/clippy_lints/src/redundant_pattern_matching.rs +++ b/clippy_lints/src/redundant_pattern_matching.rs @@ -1,9 +1,8 @@ use crate::utils::{match_qpath, paths, snippet, span_lint_and_then}; -use rustc::declare_lint_pass; -use rustc::lint::{LateContext, LateLintPass, LintArray, LintPass}; +use rustc::lint::{LateContext, LateLintPass}; use rustc_errors::Applicability; use rustc_hir::*; -use rustc_session::declare_tool_lint; +use rustc_session::{declare_lint_pass, declare_tool_lint}; use syntax::ast::LitKind; declare_clippy_lint! { diff --git a/clippy_lints/src/redundant_static_lifetimes.rs b/clippy_lints/src/redundant_static_lifetimes.rs index 12c530cf221..fd11682da6f 100644 --- a/clippy_lints/src/redundant_static_lifetimes.rs +++ b/clippy_lints/src/redundant_static_lifetimes.rs @@ -1,8 +1,7 @@ use crate::utils::{snippet, span_lint_and_then}; -use rustc::declare_lint_pass; -use rustc::lint::{EarlyContext, EarlyLintPass, LintArray, LintPass}; +use rustc::lint::{EarlyContext, EarlyLintPass}; use rustc_errors::Applicability; -use rustc_session::declare_tool_lint; +use rustc_session::{declare_lint_pass, declare_tool_lint}; use syntax::ast::*; declare_clippy_lint! { diff --git a/clippy_lints/src/reference.rs b/clippy_lints/src/reference.rs index 6bb4236b043..64ed9ce8387 100644 --- a/clippy_lints/src/reference.rs +++ b/clippy_lints/src/reference.rs @@ -1,9 +1,8 @@ use crate::utils::{in_macro, snippet_with_applicability, span_lint_and_sugg}; use if_chain::if_chain; -use rustc::declare_lint_pass; -use rustc::lint::{EarlyContext, EarlyLintPass, LintArray, LintPass}; +use rustc::lint::{EarlyContext, EarlyLintPass}; use rustc_errors::Applicability; -use rustc_session::declare_tool_lint; +use rustc_session::{declare_lint_pass, declare_tool_lint}; use syntax::ast::{Expr, ExprKind, UnOp}; declare_clippy_lint! { diff --git a/clippy_lints/src/regex.rs b/clippy_lints/src/regex.rs index 188ff6d205f..06874608c88 100644 --- a/clippy_lints/src/regex.rs +++ b/clippy_lints/src/regex.rs @@ -1,11 +1,10 @@ use crate::consts::{constant, Constant}; use crate::utils::{is_expn_of, match_def_path, match_type, paths, span_help_and_lint, span_lint}; use if_chain::if_chain; -use rustc::impl_lint_pass; -use rustc::lint::{LateContext, LateLintPass, LintArray, LintPass}; +use rustc::lint::{LateContext, LateLintPass}; use rustc_data_structures::fx::FxHashSet; use rustc_hir::*; -use rustc_session::declare_tool_lint; +use rustc_session::{declare_tool_lint, impl_lint_pass}; use rustc_span::source_map::{BytePos, Span}; use std::convert::TryFrom; use syntax::ast::{LitKind, StrStyle}; diff --git a/clippy_lints/src/replace_consts.rs b/clippy_lints/src/replace_consts.rs index 26ce494245c..7bf143009fd 100644 --- a/clippy_lints/src/replace_consts.rs +++ b/clippy_lints/src/replace_consts.rs @@ -1,11 +1,10 @@ use crate::utils::{match_def_path, span_lint_and_sugg}; use if_chain::if_chain; -use rustc::declare_lint_pass; -use rustc::lint::{LateContext, LateLintPass, LintArray, LintPass}; +use rustc::lint::{LateContext, LateLintPass}; use rustc_errors::Applicability; use rustc_hir::def::{DefKind, Res}; use rustc_hir::*; -use rustc_session::declare_tool_lint; +use rustc_session::{declare_lint_pass, declare_tool_lint}; declare_clippy_lint! { /// **What it does:** Checks for usage of standard library diff --git a/clippy_lints/src/returns.rs b/clippy_lints/src/returns.rs index ced784ca491..a5f4f87b58b 100644 --- a/clippy_lints/src/returns.rs +++ b/clippy_lints/src/returns.rs @@ -1,8 +1,7 @@ use if_chain::if_chain; -use rustc::declare_lint_pass; -use rustc::lint::{in_external_macro, EarlyContext, EarlyLintPass, LintArray, LintContext, LintPass}; +use rustc::lint::{in_external_macro, EarlyContext, EarlyLintPass, LintContext}; use rustc_errors::Applicability; -use rustc_session::declare_tool_lint; +use rustc_session::{declare_lint_pass, declare_tool_lint}; use rustc_span::source_map::Span; use rustc_span::BytePos; use syntax::ast; diff --git a/clippy_lints/src/serde_api.rs b/clippy_lints/src/serde_api.rs index 68c3cc70d28..cb43e86e42e 100644 --- a/clippy_lints/src/serde_api.rs +++ b/clippy_lints/src/serde_api.rs @@ -1,8 +1,7 @@ use crate::utils::{get_trait_def_id, paths, span_lint}; -use rustc::declare_lint_pass; -use rustc::lint::{LateContext, LateLintPass, LintArray, LintPass}; +use rustc::lint::{LateContext, LateLintPass}; use rustc_hir::*; -use rustc_session::declare_tool_lint; +use rustc_session::{declare_lint_pass, declare_tool_lint}; declare_clippy_lint! { /// **What it does:** Checks for mis-uses of the serde API. diff --git a/clippy_lints/src/shadow.rs b/clippy_lints/src/shadow.rs index 825f9ee3a41..eb23c5099b5 100644 --- a/clippy_lints/src/shadow.rs +++ b/clippy_lints/src/shadow.rs @@ -1,11 +1,10 @@ use crate::reexport::*; use crate::utils::{contains_name, higher, iter_input_pats, snippet, span_lint_and_then}; -use rustc::declare_lint_pass; -use rustc::lint::{in_external_macro, LateContext, LateLintPass, LintArray, LintContext, LintPass}; +use rustc::lint::{in_external_macro, LateContext, LateLintPass, LintContext}; use rustc::ty; use rustc_hir::intravisit::FnKind; use rustc_hir::*; -use rustc_session::declare_tool_lint; +use rustc_session::{declare_lint_pass, declare_tool_lint}; use rustc_span::source_map::Span; declare_clippy_lint! { diff --git a/clippy_lints/src/slow_vector_initialization.rs b/clippy_lints/src/slow_vector_initialization.rs index 512bf21a9f3..9e178a70534 100644 --- a/clippy_lints/src/slow_vector_initialization.rs +++ b/clippy_lints/src/slow_vector_initialization.rs @@ -1,13 +1,12 @@ use crate::utils::sugg::Sugg; use crate::utils::{get_enclosing_block, match_qpath, span_lint_and_then, SpanlessEq}; use if_chain::if_chain; -use rustc::declare_lint_pass; use rustc::hir::map::Map; -use rustc::lint::{LateContext, LateLintPass, Lint, LintArray, LintPass}; +use rustc::lint::{LateContext, LateLintPass, Lint}; use rustc_errors::Applicability; use rustc_hir::intravisit::{walk_block, walk_expr, walk_stmt, NestedVisitorMap, Visitor}; use rustc_hir::*; -use rustc_session::declare_tool_lint; +use rustc_session::{declare_lint_pass, declare_tool_lint}; use rustc_span::symbol::Symbol; use syntax::ast::LitKind; diff --git a/clippy_lints/src/strings.rs b/clippy_lints/src/strings.rs index e36dbbbe5f4..eda00d5c2f1 100644 --- a/clippy_lints/src/strings.rs +++ b/clippy_lints/src/strings.rs @@ -1,8 +1,7 @@ -use rustc::declare_lint_pass; -use rustc::lint::{in_external_macro, LateContext, LateLintPass, LintArray, LintContext, LintPass}; +use rustc::lint::{in_external_macro, LateContext, LateLintPass, LintContext}; use rustc_errors::Applicability; use rustc_hir::*; -use rustc_session::declare_tool_lint; +use rustc_session::{declare_lint_pass, declare_tool_lint}; use rustc_span::source_map::Spanned; use if_chain::if_chain; diff --git a/clippy_lints/src/suspicious_trait_impl.rs b/clippy_lints/src/suspicious_trait_impl.rs index 7092397619a..28cf80491de 100644 --- a/clippy_lints/src/suspicious_trait_impl.rs +++ b/clippy_lints/src/suspicious_trait_impl.rs @@ -1,11 +1,10 @@ use crate::utils::{get_trait_def_id, span_lint, trait_ref_of_method}; use if_chain::if_chain; -use rustc::declare_lint_pass; use rustc::hir::map::Map; -use rustc::lint::{LateContext, LateLintPass, LintArray, LintPass}; +use rustc::lint::{LateContext, LateLintPass}; use rustc_hir as hir; use rustc_hir::intravisit::{walk_expr, NestedVisitorMap, Visitor}; -use rustc_session::declare_tool_lint; +use rustc_session::{declare_lint_pass, declare_tool_lint}; declare_clippy_lint! { /// **What it does:** Lints for suspicious operations in impls of arithmetic operators, e.g. diff --git a/clippy_lints/src/swap.rs b/clippy_lints/src/swap.rs index 4b8fcbb63c5..7587d1ec271 100644 --- a/clippy_lints/src/swap.rs +++ b/clippy_lints/src/swap.rs @@ -5,12 +5,11 @@ use crate::utils::{ }; use if_chain::if_chain; use matches::matches; -use rustc::declare_lint_pass; -use rustc::lint::{LateContext, LateLintPass, LintArray, LintPass}; +use rustc::lint::{LateContext, LateLintPass}; use rustc::ty; use rustc_errors::Applicability; use rustc_hir::*; -use rustc_session::declare_tool_lint; +use rustc_session::{declare_lint_pass, declare_tool_lint}; use rustc_span::Symbol; declare_clippy_lint! { diff --git a/clippy_lints/src/tabs_in_doc_comments.rs b/clippy_lints/src/tabs_in_doc_comments.rs index 9d211b7b935..2043f307d8b 100644 --- a/clippy_lints/src/tabs_in_doc_comments.rs +++ b/clippy_lints/src/tabs_in_doc_comments.rs @@ -1,8 +1,7 @@ use crate::utils::span_lint_and_sugg; -use rustc::declare_lint_pass; -use rustc::lint::{EarlyContext, EarlyLintPass, LintArray, LintPass}; +use rustc::lint::{EarlyContext, EarlyLintPass}; use rustc_errors::Applicability; -use rustc_session::declare_tool_lint; +use rustc_session::{declare_lint_pass, declare_tool_lint}; use rustc_span::source_map::{BytePos, Span}; use std::convert::TryFrom; use syntax::ast; diff --git a/clippy_lints/src/temporary_assignment.rs b/clippy_lints/src/temporary_assignment.rs index b5419c80341..5b1350bbcb9 100644 --- a/clippy_lints/src/temporary_assignment.rs +++ b/clippy_lints/src/temporary_assignment.rs @@ -1,10 +1,9 @@ use crate::utils::is_adjusted; use crate::utils::span_lint; -use rustc::declare_lint_pass; -use rustc::lint::{LateContext, LateLintPass, LintArray, LintPass}; +use rustc::lint::{LateContext, LateLintPass}; use rustc_hir::def::{DefKind, Res}; use rustc_hir::{Expr, ExprKind}; -use rustc_session::declare_tool_lint; +use rustc_session::{declare_lint_pass, declare_tool_lint}; declare_clippy_lint! { /// **What it does:** Checks for construction of a structure or tuple just to diff --git a/clippy_lints/src/to_digit_is_some.rs b/clippy_lints/src/to_digit_is_some.rs index 3d5f3347eda..c1373b24ad2 100644 --- a/clippy_lints/src/to_digit_is_some.rs +++ b/clippy_lints/src/to_digit_is_some.rs @@ -1,11 +1,10 @@ use crate::utils::{match_def_path, snippet_with_applicability, span_lint_and_sugg}; use if_chain::if_chain; -use rustc::declare_lint_pass; -use rustc::lint::{LateContext, LateLintPass, LintArray, LintPass}; +use rustc::lint::{LateContext, LateLintPass}; use rustc::ty; use rustc_errors::Applicability; use rustc_hir as hir; -use rustc_session::declare_tool_lint; +use rustc_session::{declare_lint_pass, declare_tool_lint}; declare_clippy_lint! { /// **What it does:** Checks for `.to_digit(..).is_some()` on `char`s. diff --git a/clippy_lints/src/trait_bounds.rs b/clippy_lints/src/trait_bounds.rs index 476517362a1..897883a1c04 100644 --- a/clippy_lints/src/trait_bounds.rs +++ b/clippy_lints/src/trait_bounds.rs @@ -1,9 +1,8 @@ use crate::utils::{in_macro, snippet, span_help_and_lint, SpanlessHash}; -use rustc::impl_lint_pass; -use rustc::lint::{LateContext, LateLintPass, LintArray, LintPass}; +use rustc::lint::{LateContext, LateLintPass}; use rustc_data_structures::fx::FxHashMap; use rustc_hir::*; -use rustc_session::declare_tool_lint; +use rustc_session::{declare_tool_lint, impl_lint_pass}; #[derive(Copy, Clone)] pub struct TraitBounds; diff --git a/clippy_lints/src/transmute.rs b/clippy_lints/src/transmute.rs index 30ea81125c5..667959acc38 100644 --- a/clippy_lints/src/transmute.rs +++ b/clippy_lints/src/transmute.rs @@ -2,12 +2,11 @@ use crate::utils::{ is_normalizable, last_path_segment, match_def_path, paths, snippet, span_lint, span_lint_and_then, sugg, }; use if_chain::if_chain; -use rustc::declare_lint_pass; -use rustc::lint::{LateContext, LateLintPass, LintArray, LintPass}; +use rustc::lint::{LateContext, LateLintPass}; use rustc::ty::{self, Ty}; use rustc_errors::Applicability; use rustc_hir::*; -use rustc_session::declare_tool_lint; +use rustc_session::{declare_lint_pass, declare_tool_lint}; use std::borrow::Cow; use syntax::ast; diff --git a/clippy_lints/src/transmuting_null.rs b/clippy_lints/src/transmuting_null.rs index 3ecd45b580d..056b3669bcb 100644 --- a/clippy_lints/src/transmuting_null.rs +++ b/clippy_lints/src/transmuting_null.rs @@ -1,10 +1,9 @@ use crate::consts::{constant_context, Constant}; use crate::utils::{match_qpath, paths, span_lint}; use if_chain::if_chain; -use rustc::declare_lint_pass; -use rustc::lint::{in_external_macro, LateContext, LateLintPass, LintArray, LintContext, LintPass}; +use rustc::lint::{in_external_macro, LateContext, LateLintPass, LintContext}; use rustc_hir::{Expr, ExprKind}; -use rustc_session::declare_tool_lint; +use rustc_session::{declare_lint_pass, declare_tool_lint}; use syntax::ast::LitKind; declare_clippy_lint! { diff --git a/clippy_lints/src/trivially_copy_pass_by_ref.rs b/clippy_lints/src/trivially_copy_pass_by_ref.rs index f8a6a2acd8a..33738492244 100644 --- a/clippy_lints/src/trivially_copy_pass_by_ref.rs +++ b/clippy_lints/src/trivially_copy_pass_by_ref.rs @@ -3,15 +3,14 @@ use std::cmp; use crate::utils::{is_copy, is_self_ty, snippet, span_lint_and_sugg}; use if_chain::if_chain; use matches::matches; -use rustc::impl_lint_pass; -use rustc::lint::{LateContext, LateLintPass, LintArray, LintPass}; +use rustc::lint::{LateContext, LateLintPass}; use rustc::session::config::Config as SessionConfig; use rustc::ty; use rustc_errors::Applicability; use rustc_hir as hir; use rustc_hir::intravisit::FnKind; use rustc_hir::*; -use rustc_session::declare_tool_lint; +use rustc_session::{declare_tool_lint, impl_lint_pass}; use rustc_span::Span; use rustc_target::abi::LayoutOf; use rustc_target::spec::abi::Abi; diff --git a/clippy_lints/src/try_err.rs b/clippy_lints/src/try_err.rs index 76c1decc611..e407f225faa 100644 --- a/clippy_lints/src/try_err.rs +++ b/clippy_lints/src/try_err.rs @@ -1,11 +1,10 @@ use crate::utils::{match_qpath, paths, snippet, snippet_with_macro_callsite, span_lint_and_sugg}; use if_chain::if_chain; -use rustc::declare_lint_pass; -use rustc::lint::{in_external_macro, LateContext, LateLintPass, LintArray, LintPass}; +use rustc::lint::{in_external_macro, LateContext, LateLintPass}; use rustc::ty::Ty; use rustc_errors::Applicability; use rustc_hir::*; -use rustc_session::declare_tool_lint; +use rustc_session::{declare_lint_pass, declare_tool_lint}; declare_clippy_lint! { /// **What it does:** Checks for usages of `Err(x)?`. diff --git a/clippy_lints/src/types.rs b/clippy_lints/src/types.rs index cebbbac1699..db5b6c21655 100644 --- a/clippy_lints/src/types.rs +++ b/clippy_lints/src/types.rs @@ -6,15 +6,14 @@ use std::collections::BTreeMap; use if_chain::if_chain; use rustc::hir::map::Map; -use rustc::lint::{in_external_macro, LateContext, LateLintPass, LintArray, LintContext, LintPass}; +use rustc::lint::{in_external_macro, LateContext, LateLintPass, LintContext}; use rustc::ty::layout::LayoutOf; use rustc::ty::{self, InferTy, Ty, TyCtxt, TypeckTables}; -use rustc::{declare_lint_pass, impl_lint_pass}; use rustc_errors::{Applicability, DiagnosticBuilder}; use rustc_hir as hir; use rustc_hir::intravisit::{walk_body, walk_expr, walk_ty, FnKind, NestedVisitorMap, Visitor}; use rustc_hir::*; -use rustc_session::declare_tool_lint; +use rustc_session::{declare_lint_pass, declare_tool_lint, impl_lint_pass}; use rustc_span::hygiene::{ExpnKind, MacroKind}; use rustc_span::source_map::Span; use rustc_span::symbol::{sym, Symbol}; diff --git a/clippy_lints/src/unicode.rs b/clippy_lints/src/unicode.rs index ebef3c0faa8..e0187e05a32 100644 --- a/clippy_lints/src/unicode.rs +++ b/clippy_lints/src/unicode.rs @@ -1,9 +1,8 @@ use crate::utils::{is_allowed, snippet, span_lint_and_sugg}; -use rustc::declare_lint_pass; -use rustc::lint::{LateContext, LateLintPass, LintArray, LintPass}; +use rustc::lint::{LateContext, LateLintPass}; use rustc_errors::Applicability; use rustc_hir::*; -use rustc_session::declare_tool_lint; +use rustc_session::{declare_lint_pass, declare_tool_lint}; use rustc_span::source_map::Span; use syntax::ast::LitKind; use unicode_normalization::UnicodeNormalization; diff --git a/clippy_lints/src/unsafe_removed_from_name.rs b/clippy_lints/src/unsafe_removed_from_name.rs index 008dc578bf9..6a77cb8f818 100644 --- a/clippy_lints/src/unsafe_removed_from_name.rs +++ b/clippy_lints/src/unsafe_removed_from_name.rs @@ -1,7 +1,6 @@ use crate::utils::span_lint; -use rustc::declare_lint_pass; -use rustc::lint::{EarlyContext, EarlyLintPass, LintArray, LintPass}; -use rustc_session::declare_tool_lint; +use rustc::lint::{EarlyContext, EarlyLintPass}; +use rustc_session::{declare_lint_pass, declare_tool_lint}; use rustc_span::source_map::Span; use rustc_span::symbol::SymbolStr; use syntax::ast::*; diff --git a/clippy_lints/src/unused_io_amount.rs b/clippy_lints/src/unused_io_amount.rs index b51e13c3915..c89e0696541 100644 --- a/clippy_lints/src/unused_io_amount.rs +++ b/clippy_lints/src/unused_io_amount.rs @@ -1,8 +1,7 @@ use crate::utils::{is_try, match_qpath, match_trait_method, paths, span_lint}; -use rustc::declare_lint_pass; -use rustc::lint::{LateContext, LateLintPass, LintArray, LintPass}; +use rustc::lint::{LateContext, LateLintPass}; use rustc_hir as hir; -use rustc_session::declare_tool_lint; +use rustc_session::{declare_lint_pass, declare_tool_lint}; declare_clippy_lint! { /// **What it does:** Checks for unused written/read amount. diff --git a/clippy_lints/src/unused_self.rs b/clippy_lints/src/unused_self.rs index b145d354c89..78707b30690 100644 --- a/clippy_lints/src/unused_self.rs +++ b/clippy_lints/src/unused_self.rs @@ -1,11 +1,10 @@ use if_chain::if_chain; -use rustc::declare_lint_pass; use rustc::hir::map::Map; -use rustc::lint::{LateContext, LateLintPass, LintArray, LintPass}; +use rustc::lint::{LateContext, LateLintPass}; use rustc_hir::def::Res; use rustc_hir::intravisit::{walk_path, NestedVisitorMap, Visitor}; use rustc_hir::{AssocItemKind, HirId, ImplItemKind, ImplItemRef, Item, ItemKind, Path}; -use rustc_session::declare_tool_lint; +use rustc_session::{declare_lint_pass, declare_tool_lint}; use crate::utils::span_help_and_lint; diff --git a/clippy_lints/src/unwrap.rs b/clippy_lints/src/unwrap.rs index 7a4fe159d8b..78bb478c6a9 100644 --- a/clippy_lints/src/unwrap.rs +++ b/clippy_lints/src/unwrap.rs @@ -1,11 +1,10 @@ use crate::utils::{higher::if_block, match_type, paths, span_lint_and_then, usage::is_potentially_mutated}; use if_chain::if_chain; -use rustc::declare_lint_pass; use rustc::hir::map::Map; -use rustc::lint::{LateContext, LateLintPass, LintArray, LintPass}; +use rustc::lint::{LateContext, LateLintPass}; use rustc_hir::intravisit::*; use rustc_hir::*; -use rustc_session::declare_tool_lint; +use rustc_session::{declare_lint_pass, declare_tool_lint}; use rustc_span::source_map::Span; declare_clippy_lint! { diff --git a/clippy_lints/src/use_self.rs b/clippy_lints/src/use_self.rs index 81e6e2e99cc..2b8c5155511 100644 --- a/clippy_lints/src/use_self.rs +++ b/clippy_lints/src/use_self.rs @@ -1,7 +1,6 @@ use if_chain::if_chain; -use rustc::declare_lint_pass; use rustc::hir::map::Map; -use rustc::lint::{in_external_macro, LateContext, LateLintPass, LintArray, LintContext, LintPass}; +use rustc::lint::{in_external_macro, LateContext, LateLintPass, LintContext}; use rustc::ty; use rustc::ty::{DefIdTree, Ty}; use rustc_errors::Applicability; @@ -9,7 +8,7 @@ use rustc_hir as hir; use rustc_hir::def::{DefKind, Res}; use rustc_hir::intravisit::{walk_item, walk_path, walk_ty, NestedVisitorMap, Visitor}; use rustc_hir::*; -use rustc_session::declare_tool_lint; +use rustc_session::{declare_lint_pass, declare_tool_lint}; use rustc_span::symbol::kw; use crate::utils::{differing_macro_contexts, span_lint_and_sugg}; diff --git a/clippy_lints/src/utils/author.rs b/clippy_lints/src/utils/author.rs index cfbb32806da..591cf14b718 100644 --- a/clippy_lints/src/utils/author.rs +++ b/clippy_lints/src/utils/author.rs @@ -2,15 +2,14 @@ //! to generate a clippy lint detecting said code automatically. use crate::utils::{get_attr, higher}; -use rustc::declare_lint_pass; use rustc::hir::map::Map; -use rustc::lint::{LateContext, LateLintPass, LintArray, LintContext, LintPass}; +use rustc::lint::{LateContext, LateLintPass, LintContext}; use rustc::session::Session; use rustc_data_structures::fx::FxHashMap; use rustc_hir as hir; use rustc_hir::intravisit::{NestedVisitorMap, Visitor}; use rustc_hir::{BindingAnnotation, Block, Expr, ExprKind, Pat, PatKind, QPath, Stmt, StmtKind, TyKind}; -use rustc_session::declare_tool_lint; +use rustc_session::{declare_lint_pass, declare_tool_lint}; use syntax::ast::{Attribute, LitFloatType, LitKind}; use syntax::walk_list; diff --git a/clippy_lints/src/utils/inspector.rs b/clippy_lints/src/utils/inspector.rs index eb889ccc75c..3316ad6da50 100644 --- a/clippy_lints/src/utils/inspector.rs +++ b/clippy_lints/src/utils/inspector.rs @@ -1,12 +1,11 @@ //! checks for attributes use crate::utils::get_attr; -use rustc::declare_lint_pass; -use rustc::lint::{LateContext, LateLintPass, LintArray, LintContext, LintPass}; +use rustc::lint::{LateContext, LateLintPass, LintContext}; use rustc::session::Session; use rustc_hir as hir; use rustc_hir::print; -use rustc_session::declare_tool_lint; +use rustc_session::{declare_lint_pass, declare_tool_lint}; use syntax::ast::Attribute; declare_clippy_lint! { diff --git a/clippy_lints/src/utils/internal_lints.rs b/clippy_lints/src/utils/internal_lints.rs index e63b29be965..bd5228367e6 100644 --- a/clippy_lints/src/utils/internal_lints.rs +++ b/clippy_lints/src/utils/internal_lints.rs @@ -4,8 +4,7 @@ use crate::utils::{ }; use if_chain::if_chain; use rustc::hir::map::Map; -use rustc::lint::{EarlyContext, EarlyLintPass, LateContext, LateLintPass, LintArray, LintPass}; -use rustc::{declare_lint_pass, impl_lint_pass}; +use rustc::lint::{EarlyContext, EarlyLintPass, LateContext, LateLintPass}; use rustc_data_structures::fx::{FxHashMap, FxHashSet}; use rustc_errors::Applicability; use rustc_hir as hir; @@ -13,6 +12,7 @@ use rustc_hir::def::{DefKind, Res}; use rustc_hir::intravisit::{walk_expr, NestedVisitorMap, Visitor}; use rustc_hir::*; use rustc_session::declare_tool_lint; +use rustc_session::{declare_lint_pass, impl_lint_pass}; use rustc_span::source_map::Span; use rustc_span::symbol::SymbolStr; use syntax::ast; diff --git a/clippy_lints/src/vec.rs b/clippy_lints/src/vec.rs index c5951dc1e78..ef6c1359ac3 100644 --- a/clippy_lints/src/vec.rs +++ b/clippy_lints/src/vec.rs @@ -1,12 +1,11 @@ use crate::consts::constant; use crate::utils::{higher, is_copy, snippet_with_applicability, span_lint_and_sugg}; use if_chain::if_chain; -use rustc::declare_lint_pass; -use rustc::lint::{LateContext, LateLintPass, LintArray, LintPass}; +use rustc::lint::{LateContext, LateLintPass}; use rustc::ty::{self, Ty}; use rustc_errors::Applicability; use rustc_hir::*; -use rustc_session::declare_tool_lint; +use rustc_session::{declare_lint_pass, declare_tool_lint}; use rustc_span::source_map::Span; declare_clippy_lint! { diff --git a/clippy_lints/src/wildcard_dependencies.rs b/clippy_lints/src/wildcard_dependencies.rs index 30bd5195024..3b2231cef47 100644 --- a/clippy_lints/src/wildcard_dependencies.rs +++ b/clippy_lints/src/wildcard_dependencies.rs @@ -1,7 +1,6 @@ use crate::utils::span_lint; -use rustc::declare_lint_pass; -use rustc::lint::{EarlyContext, EarlyLintPass, LintArray, LintPass}; -use rustc_session::declare_tool_lint; +use rustc::lint::{EarlyContext, EarlyLintPass}; +use rustc_session::{declare_lint_pass, declare_tool_lint}; use rustc_span::source_map::DUMMY_SP; use syntax::ast::*; diff --git a/clippy_lints/src/write.rs b/clippy_lints/src/write.rs index f459040905f..6dfbbbc7914 100644 --- a/clippy_lints/src/write.rs +++ b/clippy_lints/src/write.rs @@ -2,12 +2,11 @@ use std::borrow::Cow; use std::ops::Range; use crate::utils::{snippet_with_applicability, span_lint, span_lint_and_sugg, span_lint_and_then}; -use rustc::declare_lint_pass; -use rustc::lint::{EarlyContext, EarlyLintPass, LintArray, LintPass}; +use rustc::lint::{EarlyContext, EarlyLintPass}; use rustc_errors::Applicability; use rustc_lexer::unescape::{self, EscapeError}; use rustc_parse::parser; -use rustc_session::declare_tool_lint; +use rustc_session::{declare_lint_pass, declare_tool_lint}; use rustc_span::symbol::Symbol; use rustc_span::{BytePos, Span}; use syntax::ast::*; diff --git a/clippy_lints/src/zero_div_zero.rs b/clippy_lints/src/zero_div_zero.rs index 11cc594fb5d..c9ef09f29a1 100644 --- a/clippy_lints/src/zero_div_zero.rs +++ b/clippy_lints/src/zero_div_zero.rs @@ -1,10 +1,9 @@ use crate::consts::{constant_simple, Constant}; use crate::utils::span_help_and_lint; use if_chain::if_chain; -use rustc::declare_lint_pass; -use rustc::lint::{LateContext, LateLintPass, LintArray, LintPass}; +use rustc::lint::{LateContext, LateLintPass}; use rustc_hir::*; -use rustc_session::declare_tool_lint; +use rustc_session::{declare_lint_pass, declare_tool_lint}; declare_clippy_lint! { /// **What it does:** Checks for `0.0 / 0.0`. diff --git a/doc/adding_lints.md b/doc/adding_lints.md index f140950e47f..45b80a6b0c1 100644 --- a/doc/adding_lints.md +++ b/doc/adding_lints.md @@ -127,8 +127,7 @@ where all the lint code is. We are going to call the file ```rust use rustc::lint::{LintArray, LintPass, EarlyLintPass}; -use rustc::declare_lint_pass; -use rustc_session::declare_tool_lint; +use rustc_session::{declare_lint_pass, declare_tool_lint}; ``` The next step is to provide a lint declaration. Lints are declared using the diff --git a/tests/ui/outer_expn_data.fixed b/tests/ui/outer_expn_data.fixed index 070279e8279..4c9f1e482ae 100644 --- a/tests/ui/outer_expn_data.fixed +++ b/tests/ui/outer_expn_data.fixed @@ -3,12 +3,11 @@ #![deny(clippy::internal)] #![feature(rustc_private)] -#[macro_use] extern crate rustc; extern crate rustc_hir; #[macro_use] extern crate rustc_session; -use rustc::lint::{LateContext, LateLintPass, LintArray, LintPass}; +use rustc::lint::{LateContext, LateLintPass}; use rustc_hir::Expr; declare_lint! { diff --git a/tests/ui/outer_expn_data.rs b/tests/ui/outer_expn_data.rs index 5e173e7fd99..b69525d04c1 100644 --- a/tests/ui/outer_expn_data.rs +++ b/tests/ui/outer_expn_data.rs @@ -3,12 +3,11 @@ #![deny(clippy::internal)] #![feature(rustc_private)] -#[macro_use] extern crate rustc; extern crate rustc_hir; #[macro_use] extern crate rustc_session; -use rustc::lint::{LateContext, LateLintPass, LintArray, LintPass}; +use rustc::lint::{LateContext, LateLintPass}; use rustc_hir::Expr; declare_lint! { diff --git a/tests/ui/outer_expn_data.stderr b/tests/ui/outer_expn_data.stderr index 8d10d31d8a6..514eb599b06 100644 --- a/tests/ui/outer_expn_data.stderr +++ b/tests/ui/outer_expn_data.stderr @@ -1,5 +1,5 @@ error: usage of `outer_expn().expn_data()` - --> $DIR/outer_expn_data.rs:24:34 + --> $DIR/outer_expn_data.rs:23:34 | LL | let _ = expr.span.ctxt().outer_expn().expn_data(); | ^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `outer_expn_data()` From 3bdf40407606b82becacdb1c0f77e73c2f6c9871 Mon Sep 17 00:00:00 2001 From: Yuki Okushi Date: Sat, 11 Jan 2020 23:21:09 +0900 Subject: [PATCH 5/8] Apply review comments --- clippy_lints/src/matches.rs | 51 ++++++++++++------------------------- 1 file changed, 16 insertions(+), 35 deletions(-) diff --git a/clippy_lints/src/matches.rs b/clippy_lints/src/matches.rs index b11faef1f0d..6e89cba1627 100644 --- a/clippy_lints/src/matches.rs +++ b/clippy_lints/src/matches.rs @@ -716,41 +716,22 @@ fn all_ranges<'a, 'tcx>( } = *arm { if let PatKind::Range(ref lhs, ref rhs, range_end) = pat.kind { - match (lhs, rhs) { - (Some(lhs), Some(rhs)) => { - 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), - }; - return Some(SpannedRange { - span: pat.span, - node: (lhs, rhs), - }); - }, - (None, Some(rhs)) => { - let lhs = miri_to_const(ty.numeric_min_val(cx.tcx)?)?; - let rhs = constant(cx, cx.tables, rhs)?.0; - let rhs = match range_end { - RangeEnd::Included => Bound::Included(rhs), - RangeEnd::Excluded => Bound::Excluded(rhs), - }; - return Some(SpannedRange { - span: pat.span, - node: (lhs, rhs), - }); - }, - (Some(lhs), None) => { - let lhs = constant(cx, cx.tables, lhs)?.0; - let rhs = miri_to_const(ty.numeric_max_val(cx.tcx)?)?; - return Some(SpannedRange { - span: pat.span, - node: (lhs, Bound::Excluded(rhs)), - }); - }, - _ => return None, - } + let lhs = match lhs { + Some(lhs) => constant(cx, cx.tables, lhs)?.0, + None => miri_to_const(ty.numeric_min_val(cx.tcx)?)?, + }; + let rhs = match rhs { + Some(rhs) => constant(cx, cx.tables, rhs)?.0, + None => miri_to_const(ty.numeric_max_val(cx.tcx)?)?, + }; + let rhs = match range_end { + RangeEnd::Included => Bound::Included(rhs), + RangeEnd::Excluded => Bound::Excluded(rhs), + }; + return Some(SpannedRange { + span: pat.span, + node: (lhs, rhs), + }); } if let PatKind::Lit(ref value) = pat.kind { From 11fb749a9680fd79d35a658efd8a0438b6682820 Mon Sep 17 00:00:00 2001 From: Yuki Okushi Date: Sun, 12 Jan 2020 03:05:47 +0900 Subject: [PATCH 6/8] Comment out half-open patterns' tests --- tests/ui/match_overlapping_arm.rs | 3 +++ tests/ui/match_overlapping_arm.stderr | 26 +------------------------- 2 files changed, 4 insertions(+), 25 deletions(-) diff --git a/tests/ui/match_overlapping_arm.rs b/tests/ui/match_overlapping_arm.rs index ce7761119cb..97789bb766f 100644 --- a/tests/ui/match_overlapping_arm.rs +++ b/tests/ui/match_overlapping_arm.rs @@ -57,6 +57,8 @@ fn overlapping() { _ => (), } + /* + // FIXME(JohnTitor): uncomment this once rustfmt knows half-open patterns match 42 { 0.. => println!("0 .. 42"), 3.. => println!("3 .. 42"), @@ -68,6 +70,7 @@ fn overlapping() { ..26 => println!("0 .. 26"), _ => (), } + */ if let None = Some(42) { // nothing diff --git a/tests/ui/match_overlapping_arm.stderr b/tests/ui/match_overlapping_arm.stderr index 32dcefa86d8..eb20d5405a9 100644 --- a/tests/ui/match_overlapping_arm.stderr +++ b/tests/ui/match_overlapping_arm.stderr @@ -59,29 +59,5 @@ note: overlaps with this LL | 0..=11 => println!("0 ... 11"), | ^^^^^^ -error: some ranges overlap - --> $DIR/match_overlapping_arm.rs:61:9 - | -LL | 0.. => println!("0 .. 42"), - | ^^^ - | -note: overlaps with this - --> $DIR/match_overlapping_arm.rs:62:9 - | -LL | 3.. => println!("3 .. 42"), - | ^^^ - -error: some ranges overlap - --> $DIR/match_overlapping_arm.rs:67:9 - | -LL | ..=23 => println!("0 ... 23"), - | ^^^^^ - | -note: overlaps with this - --> $DIR/match_overlapping_arm.rs:68:9 - | -LL | ..26 => println!("0 .. 26"), - | ^^^^ - -error: aborting due to 7 previous errors +error: aborting due to 5 previous errors From 8a3a0ea2eae87d7980b25cde075d83dc7fe671df Mon Sep 17 00:00:00 2001 From: Yuki Okushi Date: Sun, 12 Jan 2020 03:41:54 +0900 Subject: [PATCH 7/8] Rustup to rust-lang/rust#67000 --- clippy_lints/src/consts.rs | 2 +- clippy_lints/src/redundant_clone.rs | 89 +++++++++-------------------- 2 files changed, 29 insertions(+), 62 deletions(-) diff --git a/clippy_lints/src/consts.rs b/clippy_lints/src/consts.rs index 86799fde8e6..e71775cf576 100644 --- a/clippy_lints/src/consts.rs +++ b/clippy_lints/src/consts.rs @@ -334,7 +334,7 @@ impl<'c, 'cc> ConstEvalLateContext<'c, 'cc> { let result = self .lcx .tcx - .const_eval_resolve(self.param_env, def_id, substs, None) + .const_eval_resolve(self.param_env, def_id, substs, None, None) .ok()?; let result = miri_to_const(&result); if result.is_some() { diff --git a/clippy_lints/src/redundant_clone.rs b/clippy_lints/src/redundant_clone.rs index 59857219976..1dcde250417 100644 --- a/clippy_lints/src/redundant_clone.rs +++ b/clippy_lints/src/redundant_clone.rs @@ -157,7 +157,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for RedundantClone { let pred_arg = if_chain! { if let Some((pred_fn_def_id, pred_arg, pred_arg_ty, Some(res))) = is_call_with_ref_arg(cx, mir, &pred_terminator.kind); - if res.base == mir::PlaceBase::Local(cloned); + if res.local == cloned; if match_def_path(cx, pred_fn_def_id, &paths::DEREF_TRAIT_METHOD); if match_type(cx, pred_arg_ty, &paths::PATH_BUF) || match_type(cx, pred_arg_ty, &paths::OS_STRING); @@ -264,7 +264,7 @@ fn is_call_with_ref_arg<'tcx>( if_chain! { if let mir::TerminatorKind::Call { func, args, destination, .. } = kind; if args.len() == 1; - if let mir::Operand::Move(mir::Place { base: mir::PlaceBase::Local(local), .. }) = &args[0]; + if let mir::Operand::Move(mir::Place { local, .. }) = &args[0]; if let ty::FnDef(def_id, _) = func.ty(&*mir, cx.tcx).kind; if let (inner_ty, 1) = walk_ptrs_ty_depth(args[0].ty(&*mir, cx.tcx)); if !is_copy(cx, inner_ty); @@ -288,14 +288,7 @@ fn find_stmt_assigns_to<'tcx>( bb: mir::BasicBlock, ) -> Option<(mir::Local, CannotMoveOut)> { let rvalue = mir.basic_blocks()[bb].statements.iter().rev().find_map(|stmt| { - if let mir::StatementKind::Assign(box ( - mir::Place { - base: mir::PlaceBase::Local(local), - .. - }, - v, - )) = &stmt.kind - { + if let mir::StatementKind::Assign(box (mir::Place { local, .. }, v)) = &stmt.kind { return if *local == to_local { Some(v) } else { None }; } @@ -333,25 +326,15 @@ fn base_local_and_movability<'tcx>( // Accessing a field of an ADT that has `Drop`. Moving the field out will cause E0509. let mut field = false; - let PlaceRef { - base: place_base, - mut projection, - } = place.as_ref(); - if let mir::PlaceBase::Local(local) = place_base { - while let [base @ .., elem] = projection { - projection = base; - deref |= matches!(elem, mir::ProjectionElem::Deref); - field |= matches!(elem, mir::ProjectionElem::Field(..)) - && has_drop( - cx, - mir::Place::ty_from(place_base, projection, &mir.local_decls, cx.tcx).ty, - ); - } - - Some((*local, deref || field)) - } else { - None + let PlaceRef { local, mut projection } = place.as_ref(); + while let [base @ .., elem] = projection { + projection = base; + deref |= matches!(elem, mir::ProjectionElem::Deref); + field |= matches!(elem, mir::ProjectionElem::Field(..)) + && has_drop(cx, mir::Place::ty_from(local, projection, &mir.local_decls, cx.tcx).ty); } + + Some((*local, deref || field)) } struct LocalUseVisitor { @@ -502,38 +485,28 @@ impl<'a, 'tcx> PossibleBorrowerVisitor<'a, 'tcx> { impl<'a, 'tcx> mir::visit::Visitor<'tcx> for PossibleBorrowerVisitor<'a, 'tcx> { fn visit_assign(&mut self, place: &mir::Place<'tcx>, rvalue: &mir::Rvalue<'_>, _location: mir::Location) { - if let mir::PlaceBase::Local(lhs) = place.base { - match rvalue { - mir::Rvalue::Ref(_, _, borrowed) => { - if let mir::PlaceBase::Local(borrowed_local) = borrowed.base { - self.possible_borrower.add(borrowed_local, lhs); + let lhs = place.local; + match rvalue { + mir::Rvalue::Ref(_, _, borrowed) => { + self.possible_borrower.add(borrowed.local, lhs); + }, + other => { + if !ContainsRegion.visit_ty(place.ty(&self.body.local_decls, self.cx.tcx).ty) { + return; + } + rvalue_locals(other, |rhs| { + if lhs != rhs { + self.possible_borrower.add(rhs, lhs); } - }, - other => { - if !ContainsRegion.visit_ty(place.ty(&self.body.local_decls, self.cx.tcx).ty) { - return; - } - rvalue_locals(other, |rhs| { - if lhs != rhs { - self.possible_borrower.add(rhs, lhs); - } - }); - }, - } + }); + }, } } fn visit_terminator(&mut self, terminator: &mir::Terminator<'_>, _loc: mir::Location) { if let mir::TerminatorKind::Call { args, - destination: - Some(( - mir::Place { - base: mir::PlaceBase::Local(dest), - .. - }, - _, - )), + destination: Some((mir::Place { local: dest, .. }, _)), .. } = &terminator.kind { @@ -547,9 +520,7 @@ impl<'a, 'tcx> mir::visit::Visitor<'tcx> for PossibleBorrowerVisitor<'a, 'tcx> { for op in args { match op { mir::Operand::Copy(p) | mir::Operand::Move(p) => { - if let mir::PlaceBase::Local(arg) = p.base { - self.possible_borrower.add(arg, *dest); - } + self.possible_borrower.add(p.local, *dest); }, _ => (), } @@ -570,11 +541,7 @@ fn rvalue_locals(rvalue: &mir::Rvalue<'_>, mut visit: impl FnMut(mir::Local)) { use rustc::mir::Rvalue::*; let mut visit_op = |op: &mir::Operand<'_>| match op { - mir::Operand::Copy(p) | mir::Operand::Move(p) => { - if let mir::PlaceBase::Local(l) = p.base { - visit(l) - } - }, + mir::Operand::Copy(p) | mir::Operand::Move(p) => visit(p.local), _ => (), }; From 2f4b1058631416fdfde1b8b7dc588fe16b8d522f Mon Sep 17 00:00:00 2001 From: Yuki Okushi Date: Sun, 12 Jan 2020 05:20:18 +0900 Subject: [PATCH 8/8] Remove references --- clippy_lints/src/redundant_clone.rs | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/clippy_lints/src/redundant_clone.rs b/clippy_lints/src/redundant_clone.rs index 1dcde250417..30a5b9bd280 100644 --- a/clippy_lints/src/redundant_clone.rs +++ b/clippy_lints/src/redundant_clone.rs @@ -297,11 +297,11 @@ fn find_stmt_assigns_to<'tcx>( match (by_ref, &*rvalue) { (true, mir::Rvalue::Ref(_, _, place)) | (false, mir::Rvalue::Use(mir::Operand::Copy(place))) => { - base_local_and_movability(cx, mir, place) + base_local_and_movability(cx, mir, *place) }, (false, mir::Rvalue::Ref(_, _, place)) => { if let [mir::ProjectionElem::Deref] = place.as_ref().projection { - base_local_and_movability(cx, mir, place) + base_local_and_movability(cx, mir, *place) } else { None } @@ -317,7 +317,7 @@ fn find_stmt_assigns_to<'tcx>( fn base_local_and_movability<'tcx>( cx: &LateContext<'_, 'tcx>, mir: &mir::Body<'tcx>, - place: &mir::Place<'tcx>, + place: mir::Place<'tcx>, ) -> Option<(mir::Local, CannotMoveOut)> { use rustc::mir::PlaceRef;