diff options
137 files changed, 803 insertions, 803 deletions
diff --git a/clippy_lints/src/approx_const.rs b/clippy_lints/src/approx_const.rs index bf6355c4a41..4d502a6d093 100644 --- a/clippy_lints/src/approx_const.rs +++ b/clippy_lints/src/approx_const.rs @@ -7,13 +7,13 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -use crate::rustc::hir::*; -use crate::rustc::lint::{LateContext, LateLintPass, LintArray, LintPass}; -use crate::rustc::{declare_tool_lint, lint_array}; -use crate::syntax::ast::{FloatTy, Lit, LitKind}; -use crate::syntax::symbol; use crate::utils::span_lint; +use rustc::hir::*; +use rustc::lint::{LateContext, LateLintPass, LintArray, LintPass}; +use rustc::{declare_tool_lint, lint_array}; use std::f64::consts as f64; +use syntax::ast::{FloatTy, Lit, LitKind}; +use syntax::symbol; /// **What it does:** Checks for floating point literals that approximate /// constants which are defined in diff --git a/clippy_lints/src/arithmetic.rs b/clippy_lints/src/arithmetic.rs index 0b2c00b9b58..51d17b38882 100644 --- a/clippy_lints/src/arithmetic.rs +++ b/clippy_lints/src/arithmetic.rs @@ -7,11 +7,11 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -use crate::rustc::hir; -use crate::rustc::lint::{LateContext, LateLintPass, LintArray, LintPass}; -use crate::rustc::{declare_tool_lint, lint_array}; -use crate::syntax::source_map::Span; use crate::utils::span_lint; +use rustc::hir; +use rustc::lint::{LateContext, LateLintPass, LintArray, LintPass}; +use rustc::{declare_tool_lint, lint_array}; +use syntax::source_map::Span; /// **What it does:** Checks for plain integer arithmetic. /// diff --git a/clippy_lints/src/assign_ops.rs b/clippy_lints/src/assign_ops.rs index f69c66a3d35..a595050d0c0 100644 --- a/clippy_lints/src/assign_ops.rs +++ b/clippy_lints/src/assign_ops.rs @@ -7,15 +7,15 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -use crate::rustc::hir; -use crate::rustc::hir::intravisit::{walk_expr, NestedVisitorMap, Visitor}; -use crate::rustc::lint::{LateContext, LateLintPass, LintArray, LintPass}; -use crate::rustc::{declare_tool_lint, lint_array}; -use crate::rustc_errors::Applicability; -use crate::syntax::ast; use crate::utils::{get_trait_def_id, implements_trait, snippet_opt, span_lint_and_then, SpanlessEq}; use crate::utils::{higher, sugg}; use if_chain::if_chain; +use rustc::hir; +use rustc::hir::intravisit::{walk_expr, NestedVisitorMap, Visitor}; +use rustc::lint::{LateContext, LateLintPass, LintArray, LintPass}; +use rustc::{declare_tool_lint, lint_array}; +use rustc_errors::Applicability; +use syntax::ast; /// **What it does:** Checks for `a = a op b` or `a = b commutative_op a` /// patterns. @@ -240,7 +240,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for AssignOps { } fn is_commutative(op: hir::BinOpKind) -> bool { - use crate::rustc::hir::BinOpKind::*; + use rustc::hir::BinOpKind::*; match op { Add | Mul | And | Or | BitXor | BitAnd | BitOr | Eq | Ne => true, Sub | Div | Rem | Shl | Shr | Lt | Le | Ge | Gt => false, diff --git a/clippy_lints/src/attrs.rs b/clippy_lints/src/attrs.rs index 7310e35116f..08333994fa6 100644 --- a/clippy_lints/src/attrs.rs +++ b/clippy_lints/src/attrs.rs @@ -10,21 +10,21 @@ //! checks for attributes use crate::reexport::*; -use crate::rustc::hir::*; -use crate::rustc::lint::{ - CheckLintNameResult, EarlyContext, EarlyLintPass, LateContext, LateLintPass, LintArray, LintContext, LintPass, -}; -use crate::rustc::ty::{self, TyCtxt}; -use crate::rustc::{declare_tool_lint, lint_array}; -use crate::rustc_errors::Applicability; -use crate::syntax::ast::{AttrStyle, Attribute, Lit, LitKind, MetaItemKind, NestedMetaItem, NestedMetaItemKind}; -use crate::syntax::source_map::Span; use crate::utils::{ in_macro, last_line_of_span, match_def_path, opt_def_id, paths, snippet_opt, span_lint, span_lint_and_sugg, span_lint_and_then, without_block_comments, }; use if_chain::if_chain; +use rustc::hir::*; +use rustc::lint::{ + CheckLintNameResult, EarlyContext, EarlyLintPass, LateContext, LateLintPass, LintArray, LintContext, LintPass, +}; +use rustc::ty::{self, TyCtxt}; +use rustc::{declare_tool_lint, lint_array}; +use rustc_errors::Applicability; use semver::Version; +use syntax::ast::{AttrStyle, Attribute, Lit, LitKind, MetaItemKind, NestedMetaItem, NestedMetaItemKind}; +use syntax::source_map::Span; /// **What it does:** Checks for items annotated with `#[inline(always)]`, /// unless the annotated function is empty or simply panics. diff --git a/clippy_lints/src/bit_mask.rs b/clippy_lints/src/bit_mask.rs index b15ce871c32..abdd624146c 100644 --- a/clippy_lints/src/bit_mask.rs +++ b/clippy_lints/src/bit_mask.rs @@ -8,15 +8,15 @@ // except according to those terms. use crate::consts::{constant, Constant}; -use crate::rustc::hir::*; -use crate::rustc::lint::{LateContext, LateLintPass, LintArray, LintPass}; -use crate::rustc::{declare_tool_lint, lint_array}; -use crate::rustc_errors::Applicability; -use crate::syntax::ast::LitKind; -use crate::syntax::source_map::Span; use crate::utils::sugg::Sugg; use crate::utils::{span_lint, span_lint_and_then}; use if_chain::if_chain; +use rustc::hir::*; +use rustc::lint::{LateContext, LateLintPass, LintArray, LintPass}; +use rustc::{declare_tool_lint, lint_array}; +use rustc_errors::Applicability; +use syntax::ast::LitKind; +use syntax::source_map::Span; /// **What it does:** Checks for incompatible bit masks in comparisons. /// diff --git a/clippy_lints/src/blacklisted_name.rs b/clippy_lints/src/blacklisted_name.rs index bf311b3fd56..ce7da419497 100644 --- a/clippy_lints/src/blacklisted_name.rs +++ b/clippy_lints/src/blacklisted_name.rs @@ -7,10 +7,10 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -use crate::rustc::hir::*; -use crate::rustc::lint::{LateContext, LateLintPass, LintArray, LintPass}; -use crate::rustc::{declare_tool_lint, lint_array}; use crate::utils::span_lint; +use rustc::hir::*; +use rustc::lint::{LateContext, LateLintPass, LintArray, LintPass}; +use rustc::{declare_tool_lint, lint_array}; /// **What it does:** Checks for usage of blacklisted names for variables, such /// as `foo`. diff --git a/clippy_lints/src/block_in_if_condition.rs b/clippy_lints/src/block_in_if_condition.rs index 825bf789a69..b68b43354f7 100644 --- a/clippy_lints/src/block_in_if_condition.rs +++ b/clippy_lints/src/block_in_if_condition.rs @@ -7,12 +7,12 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -use crate::rustc::hir::intravisit::{walk_expr, NestedVisitorMap, Visitor}; -use crate::rustc::hir::*; -use crate::rustc::lint::{LateContext, LateLintPass, LintArray, LintPass}; -use crate::rustc::{declare_tool_lint, lint_array}; use crate::utils::*; use matches::matches; +use rustc::hir::intravisit::{walk_expr, NestedVisitorMap, Visitor}; +use rustc::hir::*; +use rustc::lint::{LateContext, LateLintPass, LintArray, LintPass}; +use rustc::{declare_tool_lint, lint_array}; /// **What it does:** Checks for `if` conditions that use blocks to contain an /// expression. diff --git a/clippy_lints/src/booleans.rs b/clippy_lints/src/booleans.rs index 9f58cb6582e..844f9fb8865 100644 --- a/clippy_lints/src/booleans.rs +++ b/clippy_lints/src/booleans.rs @@ -7,17 +7,17 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -use crate::rustc::hir::intravisit::*; -use crate::rustc::hir::*; -use crate::rustc::lint::{LateContext, LateLintPass, LintArray, LintPass}; -use crate::rustc::{declare_tool_lint, lint_array}; -use crate::rustc_data_structures::thin_vec::ThinVec; -use crate::rustc_errors::Applicability; -use crate::syntax::ast::{LitKind, NodeId, DUMMY_NODE_ID}; -use crate::syntax::source_map::{dummy_spanned, Span, DUMMY_SP}; use crate::utils::{ get_trait_def_id, implements_trait, in_macro, match_type, paths, snippet_opt, span_lint_and_then, SpanlessEq, }; +use rustc::hir::intravisit::*; +use rustc::hir::*; +use rustc::lint::{LateContext, LateLintPass, LintArray, LintPass}; +use rustc::{declare_tool_lint, lint_array}; +use rustc_data_structures::thin_vec::ThinVec; +use rustc_errors::Applicability; +use syntax::ast::{LitKind, NodeId, DUMMY_NODE_ID}; +use syntax::source_map::{dummy_spanned, Span, DUMMY_SP}; /// **What it does:** Checks for boolean expressions that can be written more /// concisely. diff --git a/clippy_lints/src/bytecount.rs b/clippy_lints/src/bytecount.rs index 5d81e51422d..0f2062d9e0f 100644 --- a/clippy_lints/src/bytecount.rs +++ b/clippy_lints/src/bytecount.rs @@ -7,17 +7,17 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -use crate::rustc::hir::*; -use crate::rustc::lint::{LateContext, LateLintPass, LintArray, LintPass}; -use crate::rustc::ty; -use crate::rustc::{declare_tool_lint, lint_array}; -use crate::rustc_errors::Applicability; -use crate::syntax::ast::{Name, UintTy}; use crate::utils::{ contains_name, get_pat_name, match_type, paths, single_segment_path, snippet_with_applicability, span_lint_and_sugg, walk_ptrs_ty, }; use if_chain::if_chain; +use rustc::hir::*; +use rustc::lint::{LateContext, LateLintPass, LintArray, LintPass}; +use rustc::ty; +use rustc::{declare_tool_lint, lint_array}; +use rustc_errors::Applicability; +use syntax::ast::{Name, UintTy}; /// **What it does:** Checks for naive byte counts /// diff --git a/clippy_lints/src/cargo_common_metadata.rs b/clippy_lints/src/cargo_common_metadata.rs index 4d15944d317..9f396b61330 100644 --- a/clippy_lints/src/cargo_common_metadata.rs +++ b/clippy_lints/src/cargo_common_metadata.rs @@ -9,10 +9,10 @@ //! lint on missing cargo common metadata -use crate::rustc::lint::{EarlyContext, EarlyLintPass, LintArray, LintPass}; -use crate::rustc::{declare_tool_lint, lint_array}; -use crate::syntax::{ast::*, source_map::DUMMY_SP}; use crate::utils::span_lint; +use rustc::lint::{EarlyContext, EarlyLintPass, LintArray, LintPass}; +use rustc::{declare_tool_lint, lint_array}; +use syntax::{ast::*, source_map::DUMMY_SP}; use cargo_metadata; diff --git a/clippy_lints/src/collapsible_if.rs b/clippy_lints/src/collapsible_if.rs index a4d834da13f..ae613d70240 100644 --- a/clippy_lints/src/collapsible_if.rs +++ b/clippy_lints/src/collapsible_if.rs @@ -21,14 +21,14 @@ //! //! This lint is **warn** by default -use crate::rustc::lint::{EarlyContext, EarlyLintPass, LintArray, LintPass}; -use crate::rustc::{declare_tool_lint, lint_array}; -use crate::syntax::ast; use if_chain::if_chain; +use rustc::lint::{EarlyContext, EarlyLintPass, LintArray, LintPass}; +use rustc::{declare_tool_lint, lint_array}; +use syntax::ast; -use crate::rustc_errors::Applicability; use crate::utils::sugg::Sugg; use crate::utils::{in_macro, snippet_block, snippet_block_with_applicability, span_lint_and_sugg, span_lint_and_then}; +use rustc_errors::Applicability; /// **What it does:** Checks for nested `if` statements which can be collapsed /// by `&&`-combining their conditions and for `else { if ... }` expressions diff --git a/clippy_lints/src/const_static_lifetime.rs b/clippy_lints/src/const_static_lifetime.rs index ecf3bb1f96e..a7509dae3d5 100644 --- a/clippy_lints/src/const_static_lifetime.rs +++ b/clippy_lints/src/const_static_lifetime.rs @@ -7,11 +7,11 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -use crate::rustc::lint::{EarlyContext, EarlyLintPass, LintArray, LintPass}; -use crate::rustc::{declare_tool_lint, lint_array}; -use crate::rustc_errors::Applicability; -use crate::syntax::ast::*; use crate::utils::{in_macro, snippet, span_lint_and_then}; +use rustc::lint::{EarlyContext, EarlyLintPass, LintArray, LintPass}; +use rustc::{declare_tool_lint, lint_array}; +use rustc_errors::Applicability; +use syntax::ast::*; /// **What it does:** Checks for constants with an explicit `'static` lifetime. /// diff --git a/clippy_lints/src/consts.rs b/clippy_lints/src/consts.rs index 04109cb63df..a1fe13e4962 100644 --- a/clippy_lints/src/consts.rs +++ b/clippy_lints/src/consts.rs @@ -10,20 +10,20 @@ #![allow(clippy::float_cmp)] -use crate::rustc::hir::def::Def; -use crate::rustc::hir::*; -use crate::rustc::lint::LateContext; -use crate::rustc::ty::subst::{Subst, Substs}; -use crate::rustc::ty::{self, Instance, Ty, TyCtxt}; -use crate::rustc::{bug, span_bug}; -use crate::syntax::ast::{FloatTy, LitKind}; -use crate::syntax::ptr::P; use crate::utils::{clip, sext, unsext}; +use rustc::hir::def::Def; +use rustc::hir::*; +use rustc::lint::LateContext; +use rustc::ty::subst::{Subst, Substs}; +use rustc::ty::{self, Instance, Ty, TyCtxt}; +use rustc::{bug, span_bug}; use std::cmp::Ordering::{self, Equal}; use std::cmp::PartialOrd; use std::convert::TryInto; use std::hash::{Hash, Hasher}; use std::rc::Rc; +use syntax::ast::{FloatTy, LitKind}; +use syntax::ptr::P; /// A `LitKind`-like enum to fold constant `Expr`s into. #[derive(Debug, Clone)] @@ -151,7 +151,7 @@ impl Constant { /// parse a `LitKind` to a `Constant` pub fn lit_to_constant<'tcx>(lit: &LitKind, ty: Ty<'tcx>) -> Constant { - use crate::syntax::ast::*; + use syntax::ast::*; match *lit { LitKind::Str(ref is, _) => Constant::Str(is.to_string()), @@ -286,7 +286,7 @@ impl<'c, 'cc> ConstEvalLateContext<'c, 'cc> { /// lookup a possibly constant expression from a ExprKind::Path fn fetch_path(&mut self, qpath: &QPath, id: HirId) -> Option<Constant> { - use crate::rustc::mir::interpret::GlobalId; + use rustc::mir::interpret::GlobalId; let def = self.tables.qpath_def(qpath, id); match def { @@ -430,7 +430,7 @@ impl<'c, 'cc> ConstEvalLateContext<'c, 'cc> { } pub fn miri_to_const<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, result: &ty::Const<'tcx>) -> Option<Constant> { - use crate::rustc::mir::interpret::{ConstValue, Scalar}; + use rustc::mir::interpret::{ConstValue, Scalar}; match result.val { ConstValue::Scalar(Scalar::Bits { bits: b, .. }) => match result.ty.sty { ty::Bool => Some(Constant::Bool(b == 1)), diff --git a/clippy_lints/src/copies.rs b/clippy_lints/src/copies.rs index 2f7aac99acd..01398380075 100644 --- a/clippy_lints/src/copies.rs +++ b/clippy_lints/src/copies.rs @@ -7,17 +7,17 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -use crate::rustc::hir::*; -use crate::rustc::lint::{LateContext, LateLintPass, LintArray, LintPass}; -use crate::rustc::ty::Ty; -use crate::rustc::{declare_tool_lint, lint_array}; -use crate::rustc_data_structures::fx::FxHashMap; -use crate::syntax::symbol::LocalInternedString; use crate::utils::{get_parent_expr, in_macro, snippet, span_lint_and_then, span_note_and_lint}; use crate::utils::{SpanlessEq, SpanlessHash}; +use rustc::hir::*; +use rustc::lint::{LateContext, LateLintPass, LintArray, LintPass}; +use rustc::ty::Ty; +use rustc::{declare_tool_lint, lint_array}; +use rustc_data_structures::fx::FxHashMap; use smallvec::SmallVec; use std::collections::hash_map::Entry; use std::hash::BuildHasherDefault; +use syntax::symbol::LocalInternedString; /// **What it does:** Checks for consecutive `if`s with the same condition. /// diff --git a/clippy_lints/src/copy_iterator.rs b/clippy_lints/src/copy_iterator.rs index e5bbe9eb38a..f45d8eea5e1 100644 --- a/clippy_lints/src/copy_iterator.rs +++ b/clippy_lints/src/copy_iterator.rs @@ -7,10 +7,10 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -use crate::rustc::hir::{Item, ItemKind}; -use crate::rustc::lint::{LateContext, LateLintPass, LintArray, LintPass}; -use crate::rustc::{declare_tool_lint, lint_array}; use crate::utils::{is_copy, match_path, paths, span_note_and_lint}; +use rustc::hir::{Item, ItemKind}; +use rustc::lint::{LateContext, LateLintPass, LintArray, LintPass}; +use rustc::{declare_tool_lint, lint_array}; /// **What it does:** Checks for types that implement `Copy` as well as /// `Iterator`. diff --git a/clippy_lints/src/cyclomatic_complexity.rs b/clippy_lints/src/cyclomatic_complexity.rs index e2f98dce471..695e4329dfd 100644 --- a/clippy_lints/src/cyclomatic_complexity.rs +++ b/clippy_lints/src/cyclomatic_complexity.rs @@ -9,14 +9,14 @@ //! calculate cyclomatic complexity and warn about overly complex functions -use crate::rustc::cfg::CFG; -use crate::rustc::hir::intravisit::{walk_expr, NestedVisitorMap, Visitor}; -use crate::rustc::hir::*; -use crate::rustc::lint::{LateContext, LateLintPass, LintArray, LintContext, LintPass}; -use crate::rustc::ty; -use crate::rustc::{declare_tool_lint, lint_array}; -use crate::syntax::ast::{Attribute, NodeId}; -use crate::syntax::source_map::Span; +use rustc::cfg::CFG; +use rustc::hir::intravisit::{walk_expr, NestedVisitorMap, Visitor}; +use rustc::hir::*; +use rustc::lint::{LateContext, LateLintPass, LintArray, LintContext, LintPass}; +use rustc::ty; +use rustc::{declare_tool_lint, lint_array}; +use syntax::ast::{Attribute, NodeId}; +use syntax::source_map::Span; use crate::utils::{in_macro, is_allowed, match_type, paths, span_help_and_lint, LimitStack}; diff --git a/clippy_lints/src/default_trait_access.rs b/clippy_lints/src/default_trait_access.rs index 134950b267f..9dc404efd7e 100644 --- a/clippy_lints/src/default_trait_access.rs +++ b/clippy_lints/src/default_trait_access.rs @@ -7,12 +7,12 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -use crate::rustc::hir::*; -use crate::rustc::lint::{LateContext, LateLintPass, LintArray, LintPass}; -use crate::rustc::ty; -use crate::rustc::{declare_tool_lint, lint_array}; -use crate::rustc_errors::Applicability; use if_chain::if_chain; +use rustc::hir::*; +use rustc::lint::{LateContext, LateLintPass, LintArray, LintPass}; +use rustc::ty; +use rustc::{declare_tool_lint, lint_array}; +use rustc_errors::Applicability; use crate::utils::{any_parent_is_automatically_derived, match_def_path, opt_def_id, paths, span_lint_and_sugg}; diff --git a/clippy_lints/src/derive.rs b/clippy_lints/src/derive.rs index 02eda701817..b4556ebaff9 100644 --- a/clippy_lints/src/derive.rs +++ b/clippy_lints/src/derive.rs @@ -7,14 +7,14 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -use crate::rustc::hir::*; -use crate::rustc::lint::{LateContext, LateLintPass, LintArray, LintPass}; -use crate::rustc::ty::{self, Ty}; -use crate::rustc::{declare_tool_lint, lint_array}; -use crate::syntax::source_map::Span; 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::hir::*; +use rustc::lint::{LateContext, LateLintPass, LintArray, LintPass}; +use rustc::ty::{self, Ty}; +use rustc::{declare_tool_lint, lint_array}; +use syntax::source_map::Span; /// **What it does:** Checks for deriving `Hash` but implementing `PartialEq` /// explicitly or vice versa. diff --git a/clippy_lints/src/doc.rs b/clippy_lints/src/doc.rs index f8e31a4b2e7..024907185e9 100644 --- a/clippy_lints/src/doc.rs +++ b/clippy_lints/src/doc.rs @@ -7,14 +7,14 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -use crate::rustc::lint::{EarlyContext, EarlyLintPass, LintArray, LintPass}; -use crate::rustc::{declare_tool_lint, lint_array}; -use crate::syntax::ast; -use crate::syntax::source_map::{BytePos, Span}; -use crate::syntax_pos::Pos; use crate::utils::span_lint; use itertools::Itertools; use pulldown_cmark; +use rustc::lint::{EarlyContext, EarlyLintPass, LintArray, LintPass}; +use rustc::{declare_tool_lint, lint_array}; +use syntax::ast; +use syntax::source_map::{BytePos, Span}; +use syntax_pos::Pos; use url::Url; /// **What it does:** Checks for the presence of `_`, `::` or camel-case words diff --git a/clippy_lints/src/double_comparison.rs b/clippy_lints/src/double_comparison.rs index 89440845e5c..34f4a56bef9 100644 --- a/clippy_lints/src/double_comparison.rs +++ b/clippy_lints/src/double_comparison.rs @@ -9,11 +9,11 @@ //! Lint on unnecessary double comparisons. Some examples: -use crate::rustc::hir::*; -use crate::rustc::lint::{LateContext, LateLintPass, LintArray, LintPass}; -use crate::rustc::{declare_tool_lint, lint_array}; -use crate::rustc_errors::Applicability; -use crate::syntax::source_map::Span; +use rustc::hir::*; +use rustc::lint::{LateContext, LateLintPass, LintArray, LintPass}; +use rustc::{declare_tool_lint, lint_array}; +use rustc_errors::Applicability; +use syntax::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 d3979e660cc..3b476b81707 100644 --- a/clippy_lints/src/double_parens.rs +++ b/clippy_lints/src/double_parens.rs @@ -7,10 +7,10 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -use crate::rustc::lint::{EarlyContext, EarlyLintPass, LintArray, LintPass}; -use crate::rustc::{declare_tool_lint, lint_array}; -use crate::syntax::ast::*; use crate::utils::{in_macro, span_lint}; +use rustc::lint::{EarlyContext, EarlyLintPass, LintArray, LintPass}; +use rustc::{declare_tool_lint, lint_array}; +use syntax::ast::*; /// **What it does:** Checks for unnecessary double parentheses. /// diff --git a/clippy_lints/src/drop_forget_ref.rs b/clippy_lints/src/drop_forget_ref.rs index a9741c7a2dd..f0f91c9ab69 100644 --- a/clippy_lints/src/drop_forget_ref.rs +++ b/clippy_lints/src/drop_forget_ref.rs @@ -7,12 +7,12 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -use crate::rustc::hir::*; -use crate::rustc::lint::{LateContext, LateLintPass, LintArray, LintPass}; -use crate::rustc::ty; -use crate::rustc::{declare_tool_lint, lint_array}; use crate::utils::{is_copy, match_def_path, opt_def_id, paths, span_note_and_lint}; use if_chain::if_chain; +use rustc::hir::*; +use rustc::lint::{LateContext, LateLintPass, LintArray, LintPass}; +use rustc::ty; +use rustc::{declare_tool_lint, lint_array}; /// **What it does:** Checks for calls to `std::mem::drop` with a reference /// instead of an owned value. diff --git a/clippy_lints/src/duration_subsec.rs b/clippy_lints/src/duration_subsec.rs index 295f7532e90..aebb378ee9b 100644 --- a/clippy_lints/src/duration_subsec.rs +++ b/clippy_lints/src/duration_subsec.rs @@ -7,12 +7,12 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -use crate::rustc::hir::*; -use crate::rustc::lint::{LateContext, LateLintPass, LintArray, LintPass}; -use crate::rustc::{declare_tool_lint, lint_array}; -use crate::rustc_errors::Applicability; -use crate::syntax::source_map::Spanned; use if_chain::if_chain; +use rustc::hir::*; +use rustc::lint::{LateContext, LateLintPass, LintArray, LintPass}; +use rustc::{declare_tool_lint, lint_array}; +use rustc_errors::Applicability; +use syntax::source_map::Spanned; use crate::consts::{constant, Constant}; use crate::utils::paths; diff --git a/clippy_lints/src/else_if_without_else.rs b/clippy_lints/src/else_if_without_else.rs index e977019fa4e..ff8345290b2 100644 --- a/clippy_lints/src/else_if_without_else.rs +++ b/clippy_lints/src/else_if_without_else.rs @@ -9,9 +9,9 @@ //! lint on if expressions with an else if, but without a final else branch -use crate::rustc::lint::{in_external_macro, EarlyContext, EarlyLintPass, LintArray, LintContext, LintPass}; -use crate::rustc::{declare_tool_lint, lint_array}; -use crate::syntax::ast::*; +use rustc::lint::{in_external_macro, EarlyContext, EarlyLintPass, LintArray, LintContext, LintPass}; +use rustc::{declare_tool_lint, lint_array}; +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 045551d38dc..af2a54069fc 100644 --- a/clippy_lints/src/empty_enum.rs +++ b/clippy_lints/src/empty_enum.rs @@ -9,10 +9,10 @@ //! lint when there is an enum with no variants -use crate::rustc::hir::*; -use crate::rustc::lint::{LateContext, LateLintPass, LintArray, LintPass}; -use crate::rustc::{declare_tool_lint, lint_array}; use crate::utils::span_lint_and_then; +use rustc::hir::*; +use rustc::lint::{LateContext, LateLintPass, LintArray, LintPass}; +use rustc::{declare_tool_lint, lint_array}; /// **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 fad62c6825e..c59bfd1ad92 100644 --- a/clippy_lints/src/entry.rs +++ b/clippy_lints/src/entry.rs @@ -7,15 +7,15 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -use crate::rustc::hir::intravisit::{walk_expr, NestedVisitorMap, Visitor}; -use crate::rustc::hir::*; -use crate::rustc::lint::{LateContext, LateLintPass, LintArray, LintPass}; -use crate::rustc::{declare_tool_lint, lint_array}; -use crate::rustc_errors::Applicability; -use crate::syntax::source_map::Span; use crate::utils::SpanlessEq; use crate::utils::{get_item_name, match_type, paths, snippet, span_lint_and_then, walk_ptrs_ty}; use if_chain::if_chain; +use rustc::hir::intravisit::{walk_expr, NestedVisitorMap, Visitor}; +use rustc::hir::*; +use rustc::lint::{LateContext, LateLintPass, LintArray, LintPass}; +use rustc::{declare_tool_lint, lint_array}; +use rustc_errors::Applicability; +use syntax::source_map::Span; /// **What it does:** Checks for uses of `contains_key` + `insert` on `HashMap` /// or `BTreeMap`. diff --git a/clippy_lints/src/enum_clike.rs b/clippy_lints/src/enum_clike.rs index bd3d3d13bb3..29038cda869 100644 --- a/clippy_lints/src/enum_clike.rs +++ b/clippy_lints/src/enum_clike.rs @@ -11,15 +11,15 @@ //! don't fit into an `i32` use crate::consts::{miri_to_const, Constant}; -use crate::rustc::hir::*; -use crate::rustc::lint::{LateContext, LateLintPass, LintArray, LintPass}; -use crate::rustc::mir::interpret::GlobalId; -use crate::rustc::ty; -use crate::rustc::ty::subst::Substs; -use crate::rustc::ty::util::IntTypeExt; -use crate::rustc::{declare_tool_lint, lint_array}; -use crate::syntax::ast::{IntTy, UintTy}; use crate::utils::span_lint; +use rustc::hir::*; +use rustc::lint::{LateContext, LateLintPass, LintArray, LintPass}; +use rustc::mir::interpret::GlobalId; +use rustc::ty; +use rustc::ty::subst::Substs; +use rustc::ty::util::IntTypeExt; +use rustc::{declare_tool_lint, lint_array}; +use syntax::ast::{IntTy, UintTy}; /// **What it does:** Checks for C-like enumerations that are /// `repr(isize/usize)` and have values that don't fit into an `i32`. diff --git a/clippy_lints/src/enum_glob_use.rs b/clippy_lints/src/enum_glob_use.rs index 3a98c784fe2..aa1ee038c59 100644 --- a/clippy_lints/src/enum_glob_use.rs +++ b/clippy_lints/src/enum_glob_use.rs @@ -9,13 +9,13 @@ //! lint on `use`ing all variants of an enum -use crate::rustc::hir::def::Def; -use crate::rustc::hir::*; -use crate::rustc::lint::{LateContext, LateLintPass, LintArray, LintPass}; -use crate::rustc::{declare_tool_lint, lint_array}; -use crate::syntax::ast::NodeId; -use crate::syntax::source_map::Span; use crate::utils::span_lint; +use rustc::hir::def::Def; +use rustc::hir::*; +use rustc::lint::{LateContext, LateLintPass, LintArray, LintPass}; +use rustc::{declare_tool_lint, lint_array}; +use syntax::ast::NodeId; +use syntax::source_map::Span; /// **What it does:** Checks for `use Enum::*`. /// diff --git a/clippy_lints/src/enum_variants.rs b/clippy_lints/src/enum_variants.rs index c6142a16854..c5d7094dcc1 100644 --- a/clippy_lints/src/enum_variants.rs +++ b/clippy_lints/src/enum_variants.rs @@ -9,13 +9,13 @@ //! lint on enum variants that are prefixed or suffixed by the same characters -use crate::rustc::lint::{EarlyContext, EarlyLintPass, Lint, LintArray, LintPass}; -use crate::rustc::{declare_tool_lint, lint_array}; -use crate::syntax::ast::*; -use crate::syntax::source_map::Span; -use crate::syntax::symbol::LocalInternedString; use crate::utils::{camel_case, in_macro}; use crate::utils::{span_help_and_lint, span_lint}; +use rustc::lint::{EarlyContext, EarlyLintPass, Lint, LintArray, LintPass}; +use rustc::{declare_tool_lint, lint_array}; +use syntax::ast::*; +use syntax::source_map::Span; +use syntax::symbol::LocalInternedString; /// **What it does:** Detects enumeration variants that are prefixed or suffixed /// by the same characters. diff --git a/clippy_lints/src/eq_op.rs b/clippy_lints/src/eq_op.rs index 83644786e51..af9de9fe7e4 100644 --- a/clippy_lints/src/eq_op.rs +++ b/clippy_lints/src/eq_op.rs @@ -7,13 +7,13 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -use crate::rustc::hir::*; -use crate::rustc::lint::{LateContext, LateLintPass, LintArray, LintPass}; -use crate::rustc::{declare_tool_lint, lint_array}; -use crate::rustc_errors::Applicability; use crate::utils::{ implements_trait, in_macro, is_copy, multispan_sugg, snippet, span_lint, span_lint_and_then, SpanlessEq, }; +use rustc::hir::*; +use rustc::lint::{LateContext, LateLintPass, LintArray, LintPass}; +use rustc::{declare_tool_lint, lint_array}; +use rustc_errors::Applicability; /// **What it does:** Checks for equal operands to comparison, logical and /// bitwise, difference and division binary operators (`==`, `>`, etc., `&&`, diff --git a/clippy_lints/src/erasing_op.rs b/clippy_lints/src/erasing_op.rs index e2725cf59b0..43f16c74eb1 100644 --- a/clippy_lints/src/erasing_op.rs +++ b/clippy_lints/src/erasing_op.rs @@ -8,11 +8,11 @@ // except according to those terms. use crate::consts::{constant_simple, Constant}; -use crate::rustc::hir::*; -use crate::rustc::lint::{LateContext, LateLintPass, LintArray, LintPass}; -use crate::rustc::{declare_tool_lint, lint_array}; -use crate::syntax::source_map::Span; use crate::utils::{in_macro, span_lint}; +use rustc::hir::*; +use rustc::lint::{LateContext, LateLintPass, LintArray, LintPass}; +use rustc::{declare_tool_lint, lint_array}; +use syntax::source_map::Span; /// **What it does:** Checks for erasing operations, e.g. `x * 0`. /// diff --git a/clippy_lints/src/escape.rs b/clippy_lints/src/escape.rs index 4b4a6bd9d5c..445aeb3377b 100644 --- a/clippy_lints/src/escape.rs +++ b/clippy_lints/src/escape.rs @@ -7,18 +7,18 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -use crate::rustc::hir::intravisit as visit; -use crate::rustc::hir::*; -use crate::rustc::lint::{LateContext, LateLintPass, LintArray, LintPass}; -use crate::rustc::middle::expr_use_visitor::*; -use crate::rustc::middle::mem_categorization::{cmt_, Categorization}; -use crate::rustc::ty::layout::LayoutOf; -use crate::rustc::ty::{self, Ty}; -use crate::rustc::util::nodemap::NodeSet; -use crate::rustc::{declare_tool_lint, lint_array}; -use crate::syntax::ast::NodeId; -use crate::syntax::source_map::Span; use crate::utils::span_lint; +use rustc::hir::intravisit as visit; +use rustc::hir::*; +use rustc::lint::{LateContext, LateLintPass, LintArray, LintPass}; +use rustc::middle::expr_use_visitor::*; +use rustc::middle::mem_categorization::{cmt_, Categorization}; +use rustc::ty::layout::LayoutOf; +use rustc::ty::{self, Ty}; +use rustc::util::nodemap::NodeSet; +use rustc::{declare_tool_lint, lint_array}; +use syntax::ast::NodeId; +use syntax::source_map::Span; pub struct Pass { pub too_large_for_stack: u64, diff --git a/clippy_lints/src/eta_reduction.rs b/clippy_lints/src/eta_reduction.rs index e06f4d260d4..dd80afbc4ae 100644 --- a/clippy_lints/src/eta_reduction.rs +++ b/clippy_lints/src/eta_reduction.rs @@ -7,12 +7,12 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -use crate::rustc::hir::*; -use crate::rustc::lint::{LateContext, LateLintPass, LintArray, LintPass}; -use crate::rustc::ty; -use crate::rustc::{declare_tool_lint, lint_array}; -use crate::rustc_errors::Applicability; use crate::utils::{is_adjusted, iter_input_pats, snippet_opt, span_lint_and_then}; +use rustc::hir::*; +use rustc::lint::{LateContext, LateLintPass, LintArray, LintPass}; +use rustc::ty; +use rustc::{declare_tool_lint, lint_array}; +use rustc_errors::Applicability; pub struct EtaPass; diff --git a/clippy_lints/src/eval_order_dependence.rs b/clippy_lints/src/eval_order_dependence.rs index 69d3b09a8ae..50944eb5e7e 100644 --- a/clippy_lints/src/eval_order_dependence.rs +++ b/clippy_lints/src/eval_order_dependence.rs @@ -7,14 +7,14 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -use crate::rustc::hir::intravisit::{walk_expr, NestedVisitorMap, Visitor}; -use crate::rustc::hir::*; -use crate::rustc::lint::{LateContext, LateLintPass, LintArray, LintPass}; -use crate::rustc::ty; -use crate::rustc::{declare_tool_lint, lint_array}; -use crate::syntax::ast; use crate::utils::{get_parent_expr, span_lint, span_note_and_lint}; use if_chain::if_chain; +use rustc::hir::intravisit::{walk_expr, NestedVisitorMap, Visitor}; +use rustc::hir::*; +use rustc::lint::{LateContext, LateLintPass, LintArray, LintPass}; +use rustc::ty; +use rustc::{declare_tool_lint, lint_array}; +use syntax::ast; /// **What it does:** Checks for a read and a write to the same variable where /// whether the read occurs before or after the write depends on the evaluation diff --git a/clippy_lints/src/excessive_precision.rs b/clippy_lints/src/excessive_precision.rs index 7d72f417b2a..b3cf9131cce 100644 --- a/clippy_lints/src/excessive_precision.rs +++ b/clippy_lints/src/excessive_precision.rs @@ -7,18 +7,18 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -use crate::rustc::hir; -use crate::rustc::lint::{LateContext, LateLintPass, LintArray, LintPass}; -use crate::rustc::ty; -use crate::rustc::{declare_tool_lint, lint_array}; -use crate::rustc_errors::Applicability; -use crate::syntax::ast::*; -use crate::syntax_pos::symbol::Symbol; use crate::utils::span_lint_and_sugg; use if_chain::if_chain; +use rustc::hir; +use rustc::lint::{LateContext, LateLintPass, LintArray, LintPass}; +use rustc::ty; +use rustc::{declare_tool_lint, lint_array}; +use rustc_errors::Applicability; use std::f32; use std::f64; use std::fmt; +use syntax::ast::*; +use syntax_pos::symbol::Symbol; /// **What it does:** Checks for float literals with a precision greater /// than that supported by the underlying type diff --git a/clippy_lints/src/explicit_write.rs b/clippy_lints/src/explicit_write.rs index a0db3ae8df3..f56e3225d0a 100644 --- a/clippy_lints/src/explicit_write.rs +++ b/clippy_lints/src/explicit_write.rs @@ -7,13 +7,13 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -use crate::rustc::hir::*; -use crate::rustc::lint::{LateContext, LateLintPass, LintArray, LintPass}; -use crate::rustc::{declare_tool_lint, lint_array}; -use crate::rustc_errors::Applicability; -use crate::syntax::ast::LitKind; use crate::utils::{is_expn_of, match_def_path, opt_def_id, resolve_node, span_lint, span_lint_and_sugg}; use if_chain::if_chain; +use rustc::hir::*; +use rustc::lint::{LateContext, LateLintPass, LintArray, LintPass}; +use rustc::{declare_tool_lint, lint_array}; +use rustc_errors::Applicability; +use syntax::ast::LitKind; /// **What it does:** Checks for usage of `write!()` / `writeln()!` which can be /// replaced with `(e)print!()` / `(e)println!()` diff --git a/clippy_lints/src/fallible_impl_from.rs b/clippy_lints/src/fallible_impl_from.rs index 0f1c1f7ef1d..65790b1b42e 100644 --- a/clippy_lints/src/fallible_impl_from.rs +++ b/clippy_lints/src/fallible_impl_from.rs @@ -7,14 +7,14 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -use crate::rustc::hir; -use crate::rustc::lint::{LateContext, LateLintPass, LintArray, LintPass}; -use crate::rustc::ty; -use crate::rustc::{declare_tool_lint, lint_array}; -use crate::syntax_pos::Span; 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, opt_def_id, span_lint_and_then, walk_ptrs_ty}; use if_chain::if_chain; +use rustc::hir; +use rustc::lint::{LateContext, LateLintPass, LintArray, LintPass}; +use rustc::ty; +use rustc::{declare_tool_lint, lint_array}; +use syntax_pos::Span; /// **What it does:** Checks for impls of `From<..>` that contain `panic!()` or `unwrap()` /// @@ -61,8 +61,8 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for FallibleImplFrom { } fn lint_impl_body<'a, 'tcx>(cx: &LateContext<'a, 'tcx>, impl_span: Span, impl_items: &hir::HirVec<hir::ImplItemRef>) { - use crate::rustc::hir::intravisit::{self, NestedVisitorMap, Visitor}; - use crate::rustc::hir::*; + use rustc::hir::intravisit::{self, NestedVisitorMap, Visitor}; + use rustc::hir::*; struct FindPanicUnwrap<'a, 'tcx: 'a> { tcx: ty::TyCtxt<'a, 'tcx, 'tcx>, diff --git a/clippy_lints/src/format.rs b/clippy_lints/src/format.rs index ac80580b148..1db52079d3f 100644 --- a/clippy_lints/src/format.rs +++ b/clippy_lints/src/format.rs @@ -7,18 +7,18 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -use crate::rustc::hir::*; -use crate::rustc::lint::{LateContext, LateLintPass, LintArray, LintPass}; -use crate::rustc::ty; -use crate::rustc::{declare_tool_lint, lint_array}; -use crate::rustc_errors::Applicability; -use crate::syntax::ast::LitKind; use crate::utils::paths; use crate::utils::{ in_macro, is_expn_of, last_path_segment, match_def_path, match_type, opt_def_id, resolve_node, snippet, span_lint_and_then, walk_ptrs_ty, }; use if_chain::if_chain; +use rustc::hir::*; +use rustc::lint::{LateContext, LateLintPass, LintArray, LintPass}; +use rustc::ty; +use rustc::{declare_tool_lint, lint_array}; +use rustc_errors::Applicability; +use syntax::ast::LitKind; /// **What it does:** Checks for the use of `format!("string literal with no /// argument")` and `format!("{}", foo)` where `foo` is a string. diff --git a/clippy_lints/src/formatting.rs b/clippy_lints/src/formatting.rs index cc3801423c8..ce51f1433f9 100644 --- a/clippy_lints/src/formatting.rs +++ b/clippy_lints/src/formatting.rs @@ -7,11 +7,11 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -use crate::rustc::lint::{EarlyContext, EarlyLintPass, LintArray, LintPass}; -use crate::rustc::{declare_tool_lint, lint_array}; -use crate::syntax::ast; -use crate::syntax::ptr::P; use crate::utils::{differing_macro_contexts, in_macro, snippet_opt, span_note_and_lint}; +use rustc::lint::{EarlyContext, EarlyLintPass, LintArray, LintPass}; +use rustc::{declare_tool_lint, lint_array}; +use syntax::ast; +use syntax::ptr::P; /// **What it does:** Checks for use of the non-existent `=*`, `=!` and `=-` /// operators. diff --git a/clippy_lints/src/functions.rs b/clippy_lints/src/functions.rs index e3c43c1c090..19adf2d1dc4 100644 --- a/clippy_lints/src/functions.rs +++ b/clippy_lints/src/functions.rs @@ -7,18 +7,18 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -use crate::rustc::hir; -use crate::rustc::hir::def::Def; -use crate::rustc::hir::intravisit; -use crate::rustc::lint::{LateContext, LateLintPass, LintArray, LintPass}; -use crate::rustc::ty; -use crate::rustc::{declare_tool_lint, lint_array}; -use crate::rustc_data_structures::fx::FxHashSet; -use crate::rustc_target::spec::abi::Abi; -use crate::syntax::ast; -use crate::syntax::source_map::Span; use crate::utils::{iter_input_pats, span_lint, type_is_unsafe_function}; use matches::matches; +use rustc::hir; +use rustc::hir::def::Def; +use rustc::hir::intravisit; +use rustc::lint::{LateContext, LateLintPass, LintArray, LintPass}; +use rustc::ty; +use rustc::{declare_tool_lint, lint_array}; +use rustc_data_structures::fx::FxHashSet; +use rustc_target::spec::abi::Abi; +use syntax::ast; +use syntax::source_map::Span; /// **What it does:** Checks for functions with too many parameters. /// diff --git a/clippy_lints/src/identity_conversion.rs b/clippy_lints/src/identity_conversion.rs index cea759712b8..b18d63a94b6 100644 --- a/clippy_lints/src/identity_conversion.rs +++ b/clippy_lints/src/identity_conversion.rs @@ -7,15 +7,15 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -use crate::rustc::hir::*; -use crate::rustc::lint::{LateContext, LateLintPass, LintArray, LintPass}; -use crate::rustc::{declare_tool_lint, lint_array}; -use crate::rustc_errors::Applicability; -use crate::syntax::ast::NodeId; use crate::utils::{ in_macro, match_def_path, match_trait_method, same_tys, snippet, snippet_with_macro_callsite, span_lint_and_then, }; use crate::utils::{opt_def_id, paths, resolve_node}; +use rustc::hir::*; +use rustc::lint::{LateContext, LateLintPass, LintArray, LintPass}; +use rustc::{declare_tool_lint, lint_array}; +use rustc_errors::Applicability; +use syntax::ast::NodeId; /// **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 aab3c8c8336..5f1101461bd 100644 --- a/clippy_lints/src/identity_op.rs +++ b/clippy_lints/src/identity_op.rs @@ -8,12 +8,12 @@ // except according to those terms. use crate::consts::{constant_simple, Constant}; -use crate::rustc::hir::*; -use crate::rustc::lint::{LateContext, LateLintPass, LintArray, LintPass}; -use crate::rustc::ty; -use crate::rustc::{declare_tool_lint, lint_array}; -use crate::syntax::source_map::Span; use crate::utils::{clip, in_macro, snippet, span_lint, unsext}; +use rustc::hir::*; +use rustc::lint::{LateContext, LateLintPass, LintArray, LintPass}; +use rustc::ty; +use rustc::{declare_tool_lint, lint_array}; +use syntax::source_map::Span; /// **What it does:** Checks for identity operations, e.g. `x + 0`. /// diff --git a/clippy_lints/src/if_not_else.rs b/clippy_lints/src/if_not_else.rs index 8a82b8d6c49..c40fb540da6 100644 --- a/clippy_lints/src/if_not_else.rs +++ b/clippy_lints/src/if_not_else.rs @@ -10,9 +10,9 @@ //! lint on if branches that could be swapped so no `!` operation is necessary //! on the condition -use crate::rustc::lint::{in_external_macro, EarlyContext, EarlyLintPass, LintArray, LintContext, LintPass}; -use crate::rustc::{declare_tool_lint, lint_array}; -use crate::syntax::ast::*; +use rustc::lint::{in_external_macro, EarlyContext, EarlyLintPass, LintArray, LintContext, LintPass}; +use rustc::{declare_tool_lint, lint_array}; +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 dc1869ae04e..674667c4b5b 100644 --- a/clippy_lints/src/implicit_return.rs +++ b/clippy_lints/src/implicit_return.rs @@ -7,12 +7,12 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -use crate::rustc::hir::{intravisit::FnKind, Body, ExprKind, FnDecl}; -use crate::rustc::lint::{LateContext, LateLintPass, LintArray, LintPass}; -use crate::rustc::{declare_tool_lint, lint_array}; -use crate::rustc_errors::Applicability; -use crate::syntax::{ast::NodeId, source_map::Span}; use crate::utils::{in_macro, snippet_opt, span_lint_and_then}; +use rustc::hir::{intravisit::FnKind, Body, ExprKind, FnDecl}; +use rustc::lint::{LateContext, LateLintPass, LintArray, LintPass}; +use rustc::{declare_tool_lint, lint_array}; +use rustc_errors::Applicability; +use syntax::{ast::NodeId, source_map::Span}; /// **What it does:** Checks for missing return statements at the end of a block. /// diff --git a/clippy_lints/src/indexing_slicing.rs b/clippy_lints/src/indexing_slicing.rs index 758b1352471..cf971b63052 100644 --- a/clippy_lints/src/indexing_slicing.rs +++ b/clippy_lints/src/indexing_slicing.rs @@ -10,14 +10,14 @@ //! lint on indexing and slicing operations use crate::consts::{constant, Constant}; -use crate::rustc::hir::*; -use crate::rustc::lint::{LateContext, LateLintPass, LintArray, LintPass}; -use crate::rustc::ty; -use crate::rustc::{declare_tool_lint, lint_array}; -use crate::syntax::ast::RangeLimits; use crate::utils; use crate::utils::higher; use crate::utils::higher::Range; +use rustc::hir::*; +use rustc::lint::{LateContext, LateLintPass, LintArray, LintPass}; +use rustc::ty; +use rustc::{declare_tool_lint, lint_array}; +use syntax::ast::RangeLimits; /// **What it does:** Checks for out of bounds array indexing with a constant /// index. diff --git a/clippy_lints/src/infallible_destructuring_match.rs b/clippy_lints/src/infallible_destructuring_match.rs index ddf3e8f8aaa..e3d03c0e697 100644 --- a/clippy_lints/src/infallible_destructuring_match.rs +++ b/clippy_lints/src/infallible_destructuring_match.rs @@ -8,11 +8,11 @@ // except according to those terms. use super::utils::{get_arg_name, match_var, remove_blocks, snippet_with_applicability, span_lint_and_sugg}; -use crate::rustc::hir::*; -use crate::rustc::lint::{LateContext, LateLintPass, LintArray, LintPass}; -use crate::rustc::{declare_tool_lint, lint_array}; -use crate::rustc_errors::Applicability; use if_chain::if_chain; +use rustc::hir::*; +use rustc::lint::{LateContext, LateLintPass, LintArray, LintPass}; +use rustc::{declare_tool_lint, lint_array}; +use rustc_errors::Applicability; /// **What it does:** Checks for matches being used to destructure a single-variant enum /// or tuple struct where a `let` will suffice. diff --git a/clippy_lints/src/infinite_iter.rs b/clippy_lints/src/infinite_iter.rs index 625eca86d87..2f7c5895af8 100644 --- a/clippy_lints/src/infinite_iter.rs +++ b/clippy_lints/src/infinite_iter.rs @@ -7,10 +7,10 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -use crate::rustc::hir::*; -use crate::rustc::lint::{LateContext, LateLintPass, LintArray, LintPass}; -use crate::rustc::{declare_tool_lint, lint_array}; use crate::utils::{get_trait_def_id, higher, implements_trait, match_qpath, paths, span_lint}; +use rustc::hir::*; +use rustc::lint::{LateContext, LateLintPass, LintArray, LintPass}; +use rustc::{declare_tool_lint, lint_array}; /// **What it does:** Checks for iteration that is guaranteed to be infinite. /// diff --git a/clippy_lints/src/inherent_impl.rs b/clippy_lints/src/inherent_impl.rs index 256f080fdb9..5224b5fb867 100644 --- a/clippy_lints/src/inherent_impl.rs +++ b/clippy_lints/src/inherent_impl.rs @@ -9,13 +9,13 @@ //! lint on inherent implementations -use crate::rustc::hir::*; -use crate::rustc::lint::{LateContext, LateLintPass, LintArray, LintPass}; -use crate::rustc::{declare_tool_lint, lint_array}; -use crate::rustc_data_structures::fx::FxHashMap; -use crate::syntax_pos::Span; use crate::utils::span_lint_and_then; +use rustc::hir::*; +use rustc::lint::{LateContext, LateLintPass, LintArray, LintPass}; +use rustc::{declare_tool_lint, lint_array}; +use rustc_data_structures::fx::FxHashMap; use std::default::Default; +use syntax_pos::Span; /// **What it does:** Checks for multiple inherent implementations of a struct /// diff --git a/clippy_lints/src/inline_fn_without_body.rs b/clippy_lints/src/inline_fn_without_body.rs index 4b651dd0e1e..afa8f234023 100644 --- a/clippy_lints/src/inline_fn_without_body.rs +++ b/clippy_lints/src/inline_fn_without_body.rs @@ -9,13 +9,13 @@ //! checks for `#[inline]` on trait methods without bodies -use crate::rustc::hir::*; -use crate::rustc::lint::{LateContext, LateLintPass, LintArray, LintPass}; -use crate::rustc::{declare_tool_lint, lint_array}; -use crate::rustc_errors::Applicability; -use crate::syntax::ast::{Attribute, Name}; use crate::utils::span_lint_and_then; use crate::utils::sugg::DiagnosticBuilderExt; +use rustc::hir::*; +use rustc::lint::{LateContext, LateLintPass, LintArray, LintPass}; +use rustc::{declare_tool_lint, lint_array}; +use rustc_errors::Applicability; +use syntax::ast::{Attribute, Name}; /// **What it does:** Checks for `#[inline]` on trait methods without bodies /// diff --git a/clippy_lints/src/int_plus_one.rs b/clippy_lints/src/int_plus_one.rs index 08c8012c931..3498c1e8114 100644 --- a/clippy_lints/src/int_plus_one.rs +++ b/clippy_lints/src/int_plus_one.rs @@ -9,10 +9,10 @@ //! lint on blocks unnecessarily using >= with a + 1 or - 1 -use crate::rustc::lint::{EarlyContext, EarlyLintPass, LintArray, LintPass}; -use crate::rustc::{declare_tool_lint, lint_array}; -use crate::rustc_errors::Applicability; -use crate::syntax::ast::*; +use rustc::lint::{EarlyContext, EarlyLintPass, LintArray, LintPass}; +use rustc::{declare_tool_lint, lint_array}; +use rustc_errors::Applicability; +use syntax::ast::*; use crate::utils::{snippet_opt, span_lint_and_then}; diff --git a/clippy_lints/src/invalid_ref.rs b/clippy_lints/src/invalid_ref.rs index 5eba76bb45f..c0dcda6349b 100644 --- a/clippy_lints/src/invalid_ref.rs +++ b/clippy_lints/src/invalid_ref.rs @@ -7,12 +7,12 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -use crate::rustc::hir::*; -use crate::rustc::lint::{LateContext, LateLintPass, LintArray, LintPass}; -use crate::rustc::ty; -use crate::rustc::{declare_tool_lint, lint_array}; use crate::utils::{match_def_path, opt_def_id, paths, span_help_and_lint}; use if_chain::if_chain; +use rustc::hir::*; +use rustc::lint::{LateContext, LateLintPass, LintArray, LintPass}; +use rustc::ty; +use rustc::{declare_tool_lint, lint_array}; /// **What it does:** Checks for creation of references to zeroed or uninitialized memory. /// diff --git a/clippy_lints/src/items_after_statements.rs b/clippy_lints/src/items_after_statements.rs index ce44b7ac97c..2d8f284ea6d 100644 --- a/clippy_lints/src/items_after_statements.rs +++ b/clippy_lints/src/items_after_statements.rs @@ -9,11 +9,11 @@ //! lint when items are used after statements -use crate::rustc::lint::{EarlyContext, EarlyLintPass, LintArray, LintPass}; -use crate::rustc::{declare_tool_lint, lint_array}; -use crate::syntax::ast::*; use crate::utils::{in_macro, span_lint}; use matches::matches; +use rustc::lint::{EarlyContext, EarlyLintPass, LintArray, LintPass}; +use rustc::{declare_tool_lint, lint_array}; +use syntax::ast::*; /// **What it does:** Checks for items declared after some statement in a block. /// diff --git a/clippy_lints/src/large_enum_variant.rs b/clippy_lints/src/large_enum_variant.rs index 8c8fc5dbeda..052504cc57c 100644 --- a/clippy_lints/src/large_enum_variant.rs +++ b/clippy_lints/src/large_enum_variant.rs @@ -9,12 +9,12 @@ //! lint when there is a large size difference between variants on an enum -use crate::rustc::hir::*; -use crate::rustc::lint::{LateContext, LateLintPass, LintArray, LintPass}; -use crate::rustc::ty::layout::LayoutOf; -use crate::rustc::{declare_tool_lint, lint_array}; -use crate::rustc_errors::Applicability; use crate::utils::{snippet_opt, span_lint_and_then}; +use rustc::hir::*; +use rustc::lint::{LateContext, LateLintPass, LintArray, LintPass}; +use rustc::ty::layout::LayoutOf; +use rustc::{declare_tool_lint, lint_array}; +use rustc_errors::Applicability; /// **What it does:** Checks for large size differences between variants on /// `enum`s. diff --git a/clippy_lints/src/len_zero.rs b/clippy_lints/src/len_zero.rs index 47b0fb55934..0a5d273141d 100644 --- a/clippy_lints/src/len_zero.rs +++ b/clippy_lints/src/len_zero.rs @@ -7,16 +7,16 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -use crate::rustc::hir::def_id::DefId; -use crate::rustc::hir::*; -use crate::rustc::lint::{LateContext, LateLintPass, LintArray, LintPass}; -use crate::rustc::ty; -use crate::rustc::{declare_tool_lint, lint_array}; -use crate::rustc_data_structures::fx::FxHashSet; -use crate::rustc_errors::Applicability; -use crate::syntax::ast::{Lit, LitKind, Name}; -use crate::syntax::source_map::{Span, Spanned}; use crate::utils::{get_item_name, in_macro, snippet_with_applicability, span_lint, span_lint_and_sugg, walk_ptrs_ty}; +use rustc::hir::def_id::DefId; +use rustc::hir::*; +use rustc::lint::{LateContext, LateLintPass, LintArray, LintPass}; +use rustc::ty; +use rustc::{declare_tool_lint, lint_array}; +use rustc_data_structures::fx::FxHashSet; +use rustc_errors::Applicability; +use syntax::ast::{Lit, LitKind, Name}; +use syntax::source_map::{Span, Spanned}; /// **What it does:** Checks for getting the length of something via `.len()` /// just to compare to zero, and suggests using `.is_empty()` where applicable. @@ -148,7 +148,7 @@ fn check_trait_items(cx: &LateContext<'_, '_>, visited_trait: &Item, trait_items // fill the set with current and super traits fn fill_trait_set(traitt: DefId, set: &mut FxHashSet<DefId>, cx: &LateContext<'_, '_>) { if set.insert(traitt) { - for supertrait in crate::rustc::traits::supertrait_def_ids(cx.tcx, traitt) { + for supertrait in rustc::traits::supertrait_def_ids(cx.tcx, traitt) { fill_trait_set(supertrait, set, cx); } } diff --git a/clippy_lints/src/let_if_seq.rs b/clippy_lints/src/let_if_seq.rs index 282c4536bca..7e9f1b41d27 100644 --- a/clippy_lints/src/let_if_seq.rs +++ b/clippy_lints/src/let_if_seq.rs @@ -7,15 +7,15 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -use crate::rustc::hir; -use crate::rustc::hir::def::Def; -use crate::rustc::hir::BindingAnnotation; -use crate::rustc::lint::{LateContext, LateLintPass, LintArray, LintPass}; -use crate::rustc::{declare_tool_lint, lint_array}; -use crate::rustc_errors::Applicability; -use crate::syntax::ast; use crate::utils::{snippet, span_lint_and_then}; use if_chain::if_chain; +use rustc::hir; +use rustc::hir::def::Def; +use rustc::hir::BindingAnnotation; +use rustc::lint::{LateContext, LateLintPass, LintArray, LintPass}; +use rustc::{declare_tool_lint, lint_array}; +use rustc_errors::Applicability; +use syntax::ast; /// **What it does:** Checks for variable declarations immediately followed by a /// conditional affectation. diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs index 8ce5861a939..f52fa340fb2 100644 --- a/clippy_lints/src/lib.rs +++ b/clippy_lints/src/lib.rs @@ -212,7 +212,7 @@ pub mod zero_div_zero; pub use crate::utils::conf::Conf; mod reexport { - crate use crate::syntax::ast::{Name, NodeId}; + crate use syntax::ast::{Name, NodeId}; } pub fn register_pre_expansion_lints( diff --git a/clippy_lints/src/lifetimes.rs b/clippy_lints/src/lifetimes.rs index 9dcbf576375..32170c9a7c6 100644 --- a/clippy_lints/src/lifetimes.rs +++ b/clippy_lints/src/lifetimes.rs @@ -8,16 +8,16 @@ // except according to those terms. use crate::reexport::*; -use crate::rustc::hir::def::Def; -use crate::rustc::hir::intravisit::*; -use crate::rustc::hir::*; -use crate::rustc::lint::{in_external_macro, LateContext, LateLintPass, LintArray, LintContext, LintPass}; -use crate::rustc::{declare_tool_lint, lint_array}; -use crate::rustc_data_structures::fx::{FxHashMap, FxHashSet}; -use crate::syntax::source_map::Span; -use crate::syntax::symbol::keywords; use crate::utils::{last_path_segment, span_lint}; use matches::matches; +use rustc::hir::def::Def; +use rustc::hir::intravisit::*; +use rustc::hir::*; +use rustc::lint::{in_external_macro, LateContext, LateLintPass, LintArray, LintContext, LintPass}; +use rustc::{declare_tool_lint, lint_array}; +use rustc_data_structures::fx::{FxHashMap, FxHashSet}; +use syntax::source_map::Span; +use syntax::symbol::keywords; /// **What it does:** Checks for lifetime annotations which can be removed by /// relying on lifetime elision. diff --git a/clippy_lints/src/literal_representation.rs b/clippy_lints/src/literal_representation.rs index 470ed369564..72bd6b09fea 100644 --- a/clippy_lints/src/literal_representation.rs +++ b/clippy_lints/src/literal_representation.rs @@ -10,13 +10,13 @@ //! Lints concerned with the grouping of digits with underscores in integral or //! floating-point literal expressions. -use crate::rustc::lint::{in_external_macro, EarlyContext, EarlyLintPass, LintArray, LintContext, LintPass}; -use crate::rustc::{declare_tool_lint, lint_array}; -use crate::rustc_errors::Applicability; -use crate::syntax::ast::*; -use crate::syntax_pos; use crate::utils::{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_tool_lint, lint_array}; +use rustc_errors::Applicability; +use syntax::ast::*; +use syntax_pos; /// **What it does:** Warns if a long integral or floating-point constant does /// not contain underscores. diff --git a/clippy_lints/src/loops.rs b/clippy_lints/src/loops.rs index 8bf509844ac..d8d95cf9a23 100644 --- a/clippy_lints/src/loops.rs +++ b/clippy_lints/src/loops.rs @@ -8,31 +8,31 @@ // except according to those terms. use crate::reexport::*; -use crate::rustc::hir::def::Def; -use crate::rustc::hir::def_id; -use crate::rustc::hir::intravisit::{walk_block, walk_decl, walk_expr, walk_pat, walk_stmt, NestedVisitorMap, Visitor}; -use crate::rustc::hir::*; -use crate::rustc::lint::{in_external_macro, LateContext, LateLintPass, LintArray, LintContext, LintPass}; -use crate::rustc::middle::region; -use crate::rustc::{declare_tool_lint, lint_array}; use if_chain::if_chain; use itertools::Itertools; -// use crate::rustc::middle::region::CodeExtent; +use rustc::hir::def::Def; +use rustc::hir::def_id; +use rustc::hir::intravisit::{walk_block, walk_decl, walk_expr, walk_pat, walk_stmt, NestedVisitorMap, Visitor}; +use rustc::hir::*; +use rustc::lint::{in_external_macro, LateContext, LateLintPass, LintArray, LintContext, LintPass}; +use rustc::middle::region; +use rustc::{declare_tool_lint, lint_array}; +// use rustc::middle::region::CodeExtent; use crate::consts::{constant, Constant}; -use crate::rustc::middle::expr_use_visitor::*; -use crate::rustc::middle::mem_categorization::cmt_; -use crate::rustc::middle::mem_categorization::Categorization; -use crate::rustc::ty::subst::Subst; -use crate::rustc::ty::{self, Ty}; -use crate::rustc_data_structures::fx::{FxHashMap, FxHashSet}; -use crate::rustc_errors::Applicability; -use crate::syntax::ast; -use crate::syntax::source_map::Span; -use crate::syntax_pos::BytePos; use crate::utils::usage::mutated_variables; use crate::utils::{in_macro, sext, sugg}; +use rustc::middle::expr_use_visitor::*; +use rustc::middle::mem_categorization::cmt_; +use rustc::middle::mem_categorization::Categorization; +use rustc::ty::subst::Subst; +use rustc::ty::{self, Ty}; +use rustc_data_structures::fx::{FxHashMap, FxHashSet}; +use rustc_errors::Applicability; use std::iter::{once, Iterator}; use std::mem; +use syntax::ast; +use syntax::source_map::Span; +use syntax_pos::BytePos; use crate::utils::paths; use crate::utils::{ diff --git a/clippy_lints/src/map_clone.rs b/clippy_lints/src/map_clone.rs index d45fcc7e860..2a7177d1fb9 100644 --- a/clippy_lints/src/map_clone.rs +++ b/clippy_lints/src/map_clone.rs @@ -7,17 +7,17 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -use crate::rustc::hir; -use crate::rustc::lint::{LateContext, LateLintPass, LintArray, LintPass}; -use crate::rustc::{declare_tool_lint, lint_array}; -use crate::rustc_errors::Applicability; -use crate::syntax::ast::Ident; -use crate::syntax::source_map::Span; use crate::utils::paths; use crate::utils::{ in_macro, match_trait_method, match_type, remove_blocks, snippet_with_applicability, span_lint_and_sugg, }; use if_chain::if_chain; +use rustc::hir; +use rustc::lint::{LateContext, LateLintPass, LintArray, LintPass}; +use rustc::{declare_tool_lint, lint_array}; +use rustc_errors::Applicability; +use syntax::ast::Ident; +use syntax::source_map::Span; #[derive(Clone)] pub struct Pass; diff --git a/clippy_lints/src/map_unit_fn.rs b/clippy_lints/src/map_unit_fn.rs index e5c17beb404..eca35422de2 100644 --- a/clippy_lints/src/map_unit_fn.rs +++ b/clippy_lints/src/map_unit_fn.rs @@ -7,15 +7,15 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -use crate::rustc::hir; -use crate::rustc::lint::{LateContext, LateLintPass, LintArray, LintPass}; -use crate::rustc::ty; -use crate::rustc::{declare_tool_lint, lint_array}; -use crate::rustc_errors::Applicability; -use crate::syntax::source_map::Span; use crate::utils::paths; use crate::utils::{in_macro, iter_input_pats, match_type, method_chain_args, snippet, span_lint_and_then}; use if_chain::if_chain; +use rustc::hir; +use rustc::lint::{LateContext, LateLintPass, LintArray, LintPass}; +use rustc::ty; +use rustc::{declare_tool_lint, lint_array}; +use rustc_errors::Applicability; +use syntax::source_map::Span; #[derive(Clone)] pub struct Pass; diff --git a/clippy_lints/src/matches.rs b/clippy_lints/src/matches.rs index 3ef8d534861..00292eb9603 100644 --- a/clippy_lints/src/matches.rs +++ b/clippy_lints/src/matches.rs @@ -8,13 +8,6 @@ // except according to those terms. use crate::consts::{constant, Constant}; -use crate::rustc::hir::*; -use crate::rustc::lint::{in_external_macro, LateContext, LateLintPass, LintArray, LintContext, LintPass}; -use crate::rustc::ty::{self, Ty}; -use crate::rustc::{declare_tool_lint, lint_array}; -use crate::rustc_errors::Applicability; -use crate::syntax::ast::LitKind; -use crate::syntax::source_map::Span; use crate::utils::paths; use crate::utils::sugg::Sugg; use crate::utils::{ @@ -22,8 +15,15 @@ use crate::utils::{ snippet_with_applicability, span_lint_and_sugg, span_lint_and_then, span_note_and_lint, walk_ptrs_ty, }; use if_chain::if_chain; +use rustc::hir::*; +use rustc::lint::{in_external_macro, LateContext, LateLintPass, LintArray, LintContext, LintPass}; +use rustc::ty::{self, Ty}; +use rustc::{declare_tool_lint, lint_array}; +use rustc_errors::Applicability; use std::cmp::Ordering; use std::collections::Bound; +use syntax::ast::LitKind; +use syntax::source_map::Span; /// **What it does:** Checks for matches with a single arm where an `if let` /// will usually suffice. diff --git a/clippy_lints/src/mem_discriminant.rs b/clippy_lints/src/mem_discriminant.rs index 5c58c990dc7..0f8ccc7dedb 100644 --- a/clippy_lints/src/mem_discriminant.rs +++ b/clippy_lints/src/mem_discriminant.rs @@ -7,12 +7,12 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -use crate::rustc::hir::{Expr, ExprKind}; -use crate::rustc::lint::{LateContext, LateLintPass, LintArray, LintPass}; -use crate::rustc::{declare_tool_lint, lint_array}; -use crate::rustc_errors::Applicability; use crate::utils::{match_def_path, opt_def_id, paths, snippet, span_lint_and_then, walk_ptrs_ty_depth}; use if_chain::if_chain; +use rustc::hir::{Expr, ExprKind}; +use rustc::lint::{LateContext, LateLintPass, LintArray, LintPass}; +use rustc::{declare_tool_lint, lint_array}; +use rustc_errors::Applicability; use std::iter; diff --git a/clippy_lints/src/mem_forget.rs b/clippy_lints/src/mem_forget.rs index 066eeb70fde..d231d054610 100644 --- a/clippy_lints/src/mem_forget.rs +++ b/clippy_lints/src/mem_forget.rs @@ -7,10 +7,10 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -use crate::rustc::hir::{Expr, ExprKind}; -use crate::rustc::lint::{LateContext, LateLintPass, LintArray, LintPass}; -use crate::rustc::{declare_tool_lint, lint_array}; use crate::utils::{match_def_path, opt_def_id, paths, span_lint}; +use rustc::hir::{Expr, ExprKind}; +use rustc::lint::{LateContext, LateLintPass, LintArray, LintPass}; +use rustc::{declare_tool_lint, lint_array}; /// **What it does:** Checks for usage of `std::mem::forget(t)` where `t` is /// `Drop`. diff --git a/clippy_lints/src/mem_replace.rs b/clippy_lints/src/mem_replace.rs index 91586ae152d..0a77b7d2044 100644 --- a/clippy_lints/src/mem_replace.rs +++ b/clippy_lints/src/mem_replace.rs @@ -7,12 +7,12 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -use crate::rustc::hir::{Expr, ExprKind, MutMutable, QPath}; -use crate::rustc::lint::{LateContext, LateLintPass, LintArray, LintPass}; -use crate::rustc::{declare_tool_lint, lint_array}; -use crate::rustc_errors::Applicability; use crate::utils::{match_def_path, match_qpath, opt_def_id, paths, snippet_with_applicability, span_lint_and_sugg}; use if_chain::if_chain; +use rustc::hir::{Expr, ExprKind, MutMutable, QPath}; +use rustc::lint::{LateContext, LateLintPass, LintArray, LintPass}; +use rustc::{declare_tool_lint, lint_array}; +use rustc_errors::Applicability; /// **What it does:** Checks for `mem::replace()` on an `Option` with /// `None`. diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs index 9763392bfdf..dcd9e3ee153 100644 --- a/clippy_lints/src/methods/mod.rs +++ b/clippy_lints/src/methods/mod.rs @@ -7,15 +7,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -use crate::rustc::hir; -use crate::rustc::hir::def::Def; -use crate::rustc::lint::{in_external_macro, LateContext, LateLintPass, Lint, LintArray, LintContext, LintPass}; -use crate::rustc::ty::{self, Predicate, Ty}; -use crate::rustc::{declare_tool_lint, lint_array}; -use crate::rustc_errors::Applicability; -use crate::syntax::ast; -use crate::syntax::source_map::{BytePos, Span}; -use crate::syntax::symbol::LocalInternedString; use crate::utils::paths; use crate::utils::sugg; use crate::utils::{ @@ -27,9 +18,18 @@ use crate::utils::{ }; use if_chain::if_chain; use matches::matches; +use rustc::hir; +use rustc::hir::def::Def; +use rustc::lint::{in_external_macro, LateContext, LateLintPass, Lint, LintArray, LintContext, LintPass}; +use rustc::ty::{self, Predicate, Ty}; +use rustc::{declare_tool_lint, lint_array}; +use rustc_errors::Applicability; use std::borrow::Cow; use std::fmt; use std::iter; +use syntax::ast; +use syntax::source_map::{BytePos, Span}; +use syntax::symbol::LocalInternedString; mod unnecessary_filter_map; diff --git a/clippy_lints/src/methods/unnecessary_filter_map.rs b/clippy_lints/src/methods/unnecessary_filter_map.rs index 3ffe802201f..c5a22961db9 100644 --- a/clippy_lints/src/methods/unnecessary_filter_map.rs +++ b/clippy_lints/src/methods/unnecessary_filter_map.rs @@ -7,14 +7,14 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -use crate::rustc::hir; -use crate::rustc::hir::def::Def; -use crate::rustc::hir::intravisit::{walk_expr, NestedVisitorMap, Visitor}; -use crate::rustc::lint::LateContext; -use crate::syntax::ast; use crate::utils::paths; use crate::utils::usage::mutated_variables; use crate::utils::{match_qpath, match_trait_method, span_lint}; +use rustc::hir; +use rustc::hir::def::Def; +use rustc::hir::intravisit::{walk_expr, NestedVisitorMap, Visitor}; +use rustc::lint::LateContext; +use syntax::ast; use if_chain::if_chain; diff --git a/clippy_lints/src/minmax.rs b/clippy_lints/src/minmax.rs index dd3aa85e600..087aa94a7ec 100644 --- a/clippy_lints/src/minmax.rs +++ b/clippy_lints/src/minmax.rs @@ -8,10 +8,10 @@ // except according to those terms. use crate::consts::{constant_simple, Constant}; -use crate::rustc::hir::*; -use crate::rustc::lint::{LateContext, LateLintPass, LintArray, LintPass}; -use crate::rustc::{declare_tool_lint, lint_array}; use crate::utils::{match_def_path, opt_def_id, paths, span_lint}; +use rustc::hir::*; +use rustc::lint::{LateContext, LateLintPass, LintArray, LintPass}; +use rustc::{declare_tool_lint, lint_array}; use std::cmp::Ordering; /// **What it does:** Checks for expressions where `std::cmp::min` and `max` are diff --git a/clippy_lints/src/misc.rs b/clippy_lints/src/misc.rs index bc3e19064db..e96261bbe28 100644 --- a/clippy_lints/src/misc.rs +++ b/clippy_lints/src/misc.rs @@ -9,14 +9,6 @@ use crate::consts::{constant, Constant}; use crate::reexport::*; -use crate::rustc::hir::intravisit::FnKind; -use crate::rustc::hir::*; -use crate::rustc::lint::{LateContext, LateLintPass, LintArray, LintPass}; -use crate::rustc::ty; -use crate::rustc::{declare_tool_lint, lint_array}; -use crate::rustc_errors::Applicability; -use crate::syntax::ast::LitKind; -use crate::syntax::source_map::{ExpnFormat, Span}; use crate::utils::sugg::Sugg; use crate::utils::{ get_item_name, get_parent_expr, implements_trait, in_constant, in_macro, is_integer_literal, iter_input_pats, @@ -25,6 +17,14 @@ use crate::utils::{ }; use if_chain::if_chain; use matches::matches; +use rustc::hir::intravisit::FnKind; +use rustc::hir::*; +use rustc::lint::{LateContext, LateLintPass, LintArray, LintPass}; +use rustc::ty; +use rustc::{declare_tool_lint, lint_array}; +use rustc_errors::Applicability; +use syntax::ast::LitKind; +use syntax::source_map::{ExpnFormat, Span}; /// **What it does:** Checks for function arguments and let bindings denoted as /// `ref`. diff --git a/clippy_lints/src/misc_early.rs b/clippy_lints/src/misc_early.rs index 9319ada13f4..6b9b90e17a5 100644 --- a/clippy_lints/src/misc_early.rs +++ b/clippy_lints/src/misc_early.rs @@ -7,16 +7,16 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -use crate::rustc::lint::{in_external_macro, EarlyContext, EarlyLintPass, LintArray, LintContext, LintPass}; -use crate::rustc::{declare_tool_lint, lint_array}; -use crate::rustc_data_structures::fx::FxHashMap; -use crate::rustc_errors::Applicability; -use crate::syntax::ast::*; -use crate::syntax::source_map::Span; -use crate::syntax::visit::{walk_expr, FnKind, Visitor}; use crate::utils::{constants, snippet, snippet_opt, span_help_and_lint, span_lint, span_lint_and_then}; use if_chain::if_chain; +use rustc::lint::{in_external_macro, EarlyContext, EarlyLintPass, LintArray, LintContext, LintPass}; +use rustc::{declare_tool_lint, lint_array}; +use rustc_data_structures::fx::FxHashMap; +use rustc_errors::Applicability; use std::char; +use syntax::ast::*; +use syntax::source_map::Span; +use syntax::visit::{walk_expr, FnKind, Visitor}; /// **What it does:** Checks for structure field patterns bound to wildcards. /// diff --git a/clippy_lints/src/missing_doc.rs b/clippy_lints/src/missing_doc.rs index 6a2db0bb098..d65db03a4da 100644 --- a/clippy_lints/src/missing_doc.rs +++ b/clippy_lints/src/missing_doc.rs @@ -27,14 +27,14 @@ // [`missing_doc`]: https://github.com/rust-lang/rust/blob/d6d05904697d89099b55da3331155392f1db9c00/src/librustc_lint/builtin.rs#L246 // -use crate::rustc::hir; -use crate::rustc::lint::{LateContext, LateLintPass, LintArray, LintContext, LintPass}; -use crate::rustc::ty; -use crate::rustc::{declare_tool_lint, lint_array}; -use crate::syntax::ast; -use crate::syntax::attr; -use crate::syntax::source_map::Span; use crate::utils::{in_macro, span_lint}; +use rustc::hir; +use rustc::lint::{LateContext, LateLintPass, LintArray, LintContext, LintPass}; +use rustc::ty; +use rustc::{declare_tool_lint, lint_array}; +use syntax::ast; +use syntax::attr; +use syntax::source_map::Span; /// **What it does:** Warns if there is missing doc for any documentable item /// (public or private). diff --git a/clippy_lints/src/missing_inline.rs b/clippy_lints/src/missing_inline.rs index b76d6316600..8fb677c7cdf 100644 --- a/clippy_lints/src/missing_inline.rs +++ b/clippy_lints/src/missing_inline.rs @@ -18,12 +18,12 @@ // except according to those terms. // -use crate::rustc::hir; -use crate::rustc::lint::{LateContext, LateLintPass, LintArray, LintPass}; -use crate::rustc::{declare_tool_lint, lint_array}; -use crate::syntax::ast; -use crate::syntax::source_map::Span; use crate::utils::span_lint; +use rustc::hir; +use rustc::lint::{LateContext, LateLintPass, LintArray, LintPass}; +use rustc::{declare_tool_lint, lint_array}; +use syntax::ast; +use syntax::source_map::Span; /// **What it does:** it lints if an exported function, method, trait method with default impl, /// or trait method impl is not `#[inline]`. @@ -91,7 +91,7 @@ fn check_missing_inline_attrs(cx: &LateContext<'_, '_>, attrs: &[ast::Attribute] } fn is_executable<'a, 'tcx>(cx: &LateContext<'a, 'tcx>) -> bool { - use crate::rustc::session::config::CrateType; + use rustc::session::config::CrateType; cx.tcx.sess.crate_types.get().iter().any(|t: &CrateType| match t { CrateType::Executable => true, @@ -156,7 +156,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for MissingInline { } fn check_impl_item(&mut self, cx: &LateContext<'a, 'tcx>, impl_item: &'tcx hir::ImplItem) { - use crate::rustc::ty::{ImplContainer, TraitContainer}; + use rustc::ty::{ImplContainer, TraitContainer}; if is_executable(cx) { return; } diff --git a/clippy_lints/src/multiple_crate_versions.rs b/clippy_lints/src/multiple_crate_versions.rs index c554c8729ce..c6374afb4de 100644 --- a/clippy_lints/src/multiple_crate_versions.rs +++ b/clippy_lints/src/multiple_crate_versions.rs @@ -9,10 +9,10 @@ //! lint on multiple versions of a crate being used -use crate::rustc::lint::{EarlyContext, EarlyLintPass, LintArray, LintPass}; -use crate::rustc::{declare_tool_lint, lint_array}; -use crate::syntax::{ast::*, source_map::DUMMY_SP}; use crate::utils::span_lint; +use rustc::lint::{EarlyContext, EarlyLintPass, LintArray, LintPass}; +use rustc::{declare_tool_lint, lint_array}; +use syntax::{ast::*, source_map::DUMMY_SP}; use cargo_metadata; use itertools::Itertools; diff --git a/clippy_lints/src/mut_mut.rs b/clippy_lints/src/mut_mut.rs index 6c58f93f0d8..e1702cc373b 100644 --- a/clippy_lints/src/mut_mut.rs +++ b/clippy_lints/src/mut_mut.rs @@ -7,12 +7,12 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -use crate::rustc::hir; -use crate::rustc::hir::intravisit; -use crate::rustc::lint::{in_external_macro, LateContext, LateLintPass, LintArray, LintContext, LintPass}; -use crate::rustc::ty; -use crate::rustc::{declare_tool_lint, lint_array}; use crate::utils::{higher, span_lint}; +use rustc::hir; +use rustc::hir::intravisit; +use rustc::lint::{in_external_macro, LateContext, LateLintPass, LintArray, LintContext, LintPass}; +use rustc::ty; +use rustc::{declare_tool_lint, lint_array}; /// **What it does:** Checks for instances of `mut mut` references. /// @@ -47,7 +47,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for MutMut { } fn check_ty(&mut self, cx: &LateContext<'a, 'tcx>, ty: &'tcx hir::Ty) { - use crate::rustc::hir::intravisit::Visitor; + use rustc::hir::intravisit::Visitor; MutVisitor { cx }.visit_ty(ty); } diff --git a/clippy_lints/src/mut_reference.rs b/clippy_lints/src/mut_reference.rs index b92b3358cea..ddb8bd30137 100644 --- a/clippy_lints/src/mut_reference.rs +++ b/clippy_lints/src/mut_reference.rs @@ -7,12 +7,12 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -use crate::rustc::hir::*; -use crate::rustc::lint::{LateContext, LateLintPass, LintArray, LintPass}; -use crate::rustc::ty::subst::Subst; -use crate::rustc::ty::{self, Ty}; -use crate::rustc::{declare_tool_lint, lint_array}; use crate::utils::span_lint; +use rustc::hir::*; +use rustc::lint::{LateContext, LateLintPass, LintArray, LintPass}; +use rustc::ty::subst::Subst; +use rustc::ty::{self, Ty}; +use rustc::{declare_tool_lint, lint_array}; /// **What it does:** Detects giving a mutable reference to a function that only /// requires an immutable reference. diff --git a/clippy_lints/src/mutex_atomic.rs b/clippy_lints/src/mutex_atomic.rs index fb467d886b5..a114e691228 100644 --- a/clippy_lints/src/mutex_atomic.rs +++ b/clippy_lints/src/mutex_atomic.rs @@ -11,12 +11,12 @@ //! //! This lint is **warn** by default -use crate::rustc::hir::Expr; -use crate::rustc::lint::{LateContext, LateLintPass, LintArray, LintPass}; -use crate::rustc::ty::{self, Ty}; -use crate::rustc::{declare_tool_lint, lint_array}; -use crate::syntax::ast; use crate::utils::{match_type, paths, span_lint}; +use rustc::hir::Expr; +use rustc::lint::{LateContext, LateLintPass, LintArray, LintPass}; +use rustc::ty::{self, Ty}; +use rustc::{declare_tool_lint, lint_array}; +use syntax::ast; /// **What it does:** Checks for usages of `Mutex<X>` where an atomic will do. /// diff --git a/clippy_lints/src/needless_bool.rs b/clippy_lints/src/needless_bool.rs index 1ad7f4c5540..08408c4475c 100644 --- a/clippy_lints/src/needless_bool.rs +++ b/clippy_lints/src/needless_bool.rs @@ -11,14 +11,14 @@ //! //! This lint is **warn** by default -use crate::rustc::hir::*; -use crate::rustc::lint::{LateContext, LateLintPass, LintArray, LintPass}; -use crate::rustc::{declare_tool_lint, lint_array}; -use crate::rustc_errors::Applicability; -use crate::syntax::ast::LitKind; -use crate::syntax::source_map::Spanned; use crate::utils::sugg::Sugg; use crate::utils::{in_macro, span_lint, span_lint_and_sugg}; +use rustc::hir::*; +use rustc::lint::{LateContext, LateLintPass, LintArray, LintPass}; +use rustc::{declare_tool_lint, lint_array}; +use rustc_errors::Applicability; +use syntax::ast::LitKind; +use syntax::source_map::Spanned; /// **What it does:** Checks for expressions of the form `if c { true } else { /// false }` diff --git a/clippy_lints/src/needless_borrow.rs b/clippy_lints/src/needless_borrow.rs index dbee58c6a3e..80c9fc549d9 100644 --- a/clippy_lints/src/needless_borrow.rs +++ b/clippy_lints/src/needless_borrow.rs @@ -11,15 +11,15 @@ //! //! This lint is **warn** by default -use crate::rustc::hir::{BindingAnnotation, Expr, ExprKind, Item, MutImmutable, Pat, PatKind}; -use crate::rustc::lint::{LateContext, LateLintPass, LintArray, LintPass}; -use crate::rustc::ty; -use crate::rustc::ty::adjustment::{Adjust, Adjustment}; -use crate::rustc::{declare_tool_lint, lint_array}; -use crate::rustc_errors::Applicability; -use crate::syntax::ast::NodeId; use crate::utils::{in_macro, snippet_opt, span_lint_and_then}; use if_chain::if_chain; +use rustc::hir::{BindingAnnotation, Expr, ExprKind, Item, MutImmutable, Pat, PatKind}; +use rustc::lint::{LateContext, LateLintPass, LintArray, LintPass}; +use rustc::ty; +use rustc::ty::adjustment::{Adjust, Adjustment}; +use rustc::{declare_tool_lint, lint_array}; +use rustc_errors::Applicability; +use syntax::ast::NodeId; /// **What it does:** Checks for address of operations (`&`) that are going to /// be dereferenced immediately by the compiler. diff --git a/clippy_lints/src/needless_borrowed_ref.rs b/clippy_lints/src/needless_borrowed_ref.rs index 9b70d4b2e64..e2801a2e1e0 100644 --- a/clippy_lints/src/needless_borrowed_ref.rs +++ b/clippy_lints/src/needless_borrowed_ref.rs @@ -11,12 +11,12 @@ //! //! This lint is **warn** by default -use crate::rustc::hir::{BindingAnnotation, MutImmutable, Pat, PatKind}; -use crate::rustc::lint::{LateContext, LateLintPass, LintArray, LintPass}; -use crate::rustc::{declare_tool_lint, lint_array}; -use crate::rustc_errors::Applicability; use crate::utils::{in_macro, snippet, span_lint_and_then}; use if_chain::if_chain; +use rustc::hir::{BindingAnnotation, MutImmutable, Pat, PatKind}; +use rustc::lint::{LateContext, LateLintPass, LintArray, LintPass}; +use rustc::{declare_tool_lint, lint_array}; +use rustc_errors::Applicability; /// **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 2f1b92544b4..9044245c5a6 100644 --- a/clippy_lints/src/needless_continue.rs +++ b/clippy_lints/src/needless_continue.rs @@ -36,11 +36,11 @@ //! ``` //! //! This lint is **warn** by default. -use crate::rustc::lint::{EarlyContext, EarlyLintPass, LintArray, LintPass}; -use crate::rustc::{declare_tool_lint, lint_array}; -use crate::syntax::ast; -use crate::syntax::source_map::{original_sp, DUMMY_SP}; +use rustc::lint::{EarlyContext, EarlyLintPass, LintArray, LintPass}; +use rustc::{declare_tool_lint, lint_array}; use std::borrow::Cow; +use syntax::ast; +use syntax::source_map::{original_sp, DUMMY_SP}; use crate::utils::{in_macro, snippet, snippet_block, span_help_and_lint, trim_multiline}; diff --git a/clippy_lints/src/needless_pass_by_value.rs b/clippy_lints/src/needless_pass_by_value.rs index 26bd56c2e7b..9184a486374 100644 --- a/clippy_lints/src/needless_pass_by_value.rs +++ b/clippy_lints/src/needless_pass_by_value.rs @@ -7,20 +7,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -use crate::rustc::hir::intravisit::FnKind; -use crate::rustc::hir::*; -use crate::rustc::lint::{LateContext, LateLintPass, LintArray, LintPass}; -use crate::rustc::middle::expr_use_visitor as euv; -use crate::rustc::middle::mem_categorization as mc; -use crate::rustc::traits; -use crate::rustc::ty::{self, RegionKind, TypeFoldable}; -use crate::rustc::{declare_tool_lint, lint_array}; -use crate::rustc_data_structures::fx::{FxHashMap, FxHashSet}; -use crate::rustc_errors::Applicability; -use crate::rustc_target::spec::abi::Abi; -use crate::syntax::ast::NodeId; -use crate::syntax::errors::DiagnosticBuilder; -use crate::syntax_pos::Span; use crate::utils::ptr::get_spans; use crate::utils::{ get_trait_def_id, implements_trait, in_macro, is_copy, is_self, match_type, multispan_sugg, paths, snippet, @@ -28,7 +14,21 @@ use crate::utils::{ }; use if_chain::if_chain; use matches::matches; +use rustc::hir::intravisit::FnKind; +use rustc::hir::*; +use rustc::lint::{LateContext, LateLintPass, LintArray, LintPass}; +use rustc::middle::expr_use_visitor as euv; +use rustc::middle::mem_categorization as mc; +use rustc::traits; +use rustc::ty::{self, RegionKind, TypeFoldable}; +use rustc::{declare_tool_lint, lint_array}; +use rustc_data_structures::fx::{FxHashMap, FxHashSet}; +use rustc_errors::Applicability; +use rustc_target::spec::abi::Abi; use std::borrow::Cow; +use syntax::ast::NodeId; +use syntax::errors::DiagnosticBuilder; +use syntax_pos::Span; /// **What it does:** Checks for functions taking arguments by value, but not /// consuming them in its diff --git a/clippy_lints/src/needless_update.rs b/clippy_lints/src/needless_update.rs index a15f7924678..993aa73f6f7 100644 --- a/clippy_lints/src/needless_update.rs +++ b/clippy_lints/src/needless_update.rs @@ -7,11 +7,11 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -use crate::rustc::hir::{Expr, ExprKind}; -use crate::rustc::lint::{LateContext, LateLintPass, LintArray, LintPass}; -use crate::rustc::ty; -use crate::rustc::{declare_tool_lint, lint_array}; use crate::utils::span_lint; +use rustc::hir::{Expr, ExprKind}; +use rustc::lint::{LateContext, LateLintPass, LintArray, LintPass}; +use rustc::ty; +use rustc::{declare_tool_lint, lint_array}; /// **What it does:** Checks for needlessly including a base struct on update /// when all fields are changed anyway. 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 dd7d1478c23..6642f674da8 100644 --- a/clippy_lints/src/neg_cmp_op_on_partial_ord.rs +++ b/clippy_lints/src/neg_cmp_op_on_partial_ord.rs @@ -7,10 +7,10 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -use crate::rustc::hir::*; -use crate::rustc::lint::{in_external_macro, LateContext, LateLintPass, LintArray, LintContext, LintPass}; -use crate::rustc::{declare_tool_lint, lint_array}; use if_chain::if_chain; +use rustc::hir::*; +use rustc::lint::{in_external_macro, LateContext, LateLintPass, LintArray, LintContext, LintPass}; +use rustc::{declare_tool_lint, lint_array}; use crate::utils::{self, paths, span_lint}; diff --git a/clippy_lints/src/neg_multiply.rs b/clippy_lints/src/neg_multiply.rs index 0df21861346..55edca6cece 100644 --- a/clippy_lints/src/neg_multiply.rs +++ b/clippy_lints/src/neg_multiply.rs @@ -7,11 +7,11 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -use crate::rustc::hir::*; -use crate::rustc::lint::{LateContext, LateLintPass, LintArray, LintPass}; -use crate::rustc::{declare_tool_lint, lint_array}; -use crate::syntax::source_map::{Span, Spanned}; use if_chain::if_chain; +use rustc::hir::*; +use rustc::lint::{LateContext, LateLintPass, LintArray, LintPass}; +use rustc::{declare_tool_lint, lint_array}; +use syntax::source_map::{Span, Spanned}; use crate::consts::{self, Constant}; use crate::utils::span_lint; diff --git a/clippy_lints/src/new_without_default.rs b/clippy_lints/src/new_without_default.rs index 86c345b025c..9e4821e7031 100644 --- a/clippy_lints/src/new_without_default.rs +++ b/clippy_lints/src/new_without_default.rs @@ -7,18 +7,18 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -use crate::rustc::hir; -use crate::rustc::hir::def_id::DefId; -use crate::rustc::lint::{in_external_macro, LateContext, LateLintPass, LintArray, LintContext, LintPass}; -use crate::rustc::ty::{self, Ty}; -use crate::rustc::util::nodemap::NodeSet; -use crate::rustc::{declare_tool_lint, lint_array}; -use crate::rustc_errors::Applicability; -use crate::syntax::source_map::Span; use crate::utils::paths; use crate::utils::sugg::DiagnosticBuilderExt; use crate::utils::{get_trait_def_id, implements_trait, return_ty, same_tys, span_lint_node_and_then}; use if_chain::if_chain; +use rustc::hir; +use rustc::hir::def_id::DefId; +use rustc::lint::{in_external_macro, LateContext, LateLintPass, LintArray, LintContext, LintPass}; +use rustc::ty::{self, Ty}; +use rustc::util::nodemap::NodeSet; +use rustc::{declare_tool_lint, lint_array}; +use rustc_errors::Applicability; +use syntax::source_map::Span; /// **What it does:** Checks for types with a `fn new() -> Self` method and no /// implementation of diff --git a/clippy_lints/src/no_effect.rs b/clippy_lints/src/no_effect.rs index f30da9c909d..c2cffadf6c1 100644 --- a/clippy_lints/src/no_effect.rs +++ b/clippy_lints/src/no_effect.rs @@ -7,12 +7,12 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -use crate::rustc::hir::def::Def; -use crate::rustc::hir::{BinOpKind, BlockCheckMode, Expr, ExprKind, Stmt, StmtKind, UnsafeSource}; -use crate::rustc::lint::{LateContext, LateLintPass, LintArray, LintPass}; -use crate::rustc::{declare_tool_lint, lint_array}; -use crate::rustc_errors::Applicability; use crate::utils::{has_drop, in_macro, snippet_opt, span_lint, span_lint_and_sugg}; +use rustc::hir::def::Def; +use rustc::hir::{BinOpKind, BlockCheckMode, Expr, ExprKind, Stmt, StmtKind, UnsafeSource}; +use rustc::lint::{LateContext, LateLintPass, LintArray, LintPass}; +use rustc::{declare_tool_lint, lint_array}; +use rustc_errors::Applicability; use std::ops::Deref; /// **What it does:** Checks for statements which have no effect. diff --git a/clippy_lints/src/non_copy_const.rs b/clippy_lints/src/non_copy_const.rs index b699a53176e..57482ff4179 100644 --- a/clippy_lints/src/non_copy_const.rs +++ b/clippy_lints/src/non_copy_const.rs @@ -11,17 +11,17 @@ //! //! This lint is **deny** by default. -use crate::rustc::hir::def::Def; -use crate::rustc::hir::*; -use crate::rustc::lint::{LateContext, LateLintPass, Lint, LintArray, LintPass}; -use crate::rustc::ty::adjustment::Adjust; -use crate::rustc::ty::{self, TypeFlags}; -use crate::rustc::{declare_tool_lint, lint_array}; -use crate::rustc_errors::Applicability; -use crate::rustc_typeck::hir_ty_to_ty; -use crate::syntax_pos::{Span, DUMMY_SP}; use crate::utils::{in_constant, in_macro, is_copy, span_lint_and_then}; +use rustc::hir::def::Def; +use rustc::hir::*; +use rustc::lint::{LateContext, LateLintPass, Lint, LintArray, LintPass}; +use rustc::ty::adjustment::Adjust; +use rustc::ty::{self, TypeFlags}; +use rustc::{declare_tool_lint, lint_array}; +use rustc_errors::Applicability; +use rustc_typeck::hir_ty_to_ty; use std::ptr; +use syntax_pos::{Span, DUMMY_SP}; /// **What it does:** Checks for declaration of `const` items which is interior /// mutable (e.g. contains a `Cell`, `Mutex`, `AtomicXxxx` etc). diff --git a/clippy_lints/src/non_expressive_names.rs b/clippy_lints/src/non_expressive_names.rs index ad8006e9256..2ab7d7e62f3 100644 --- a/clippy_lints/src/non_expressive_names.rs +++ b/clippy_lints/src/non_expressive_names.rs @@ -7,14 +7,14 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -use crate::rustc::lint::{EarlyContext, EarlyLintPass, LintArray, LintPass}; -use crate::rustc::{declare_tool_lint, lint_array}; -use crate::syntax::ast::*; -use crate::syntax::attr; -use crate::syntax::source_map::Span; -use crate::syntax::symbol::LocalInternedString; -use crate::syntax::visit::{walk_block, walk_expr, walk_pat, Visitor}; use crate::utils::{span_lint, span_lint_and_then}; +use rustc::lint::{EarlyContext, EarlyLintPass, LintArray, LintPass}; +use rustc::{declare_tool_lint, lint_array}; +use syntax::ast::*; +use syntax::attr; +use syntax::source_map::Span; +use syntax::symbol::LocalInternedString; +use syntax::visit::{walk_block, walk_expr, walk_pat, Visitor}; /// **What it does:** Checks for names that are very similar and thus confusing. /// diff --git a/clippy_lints/src/ok_if_let.rs b/clippy_lints/src/ok_if_let.rs index 9f6b6265665..e060220d56b 100644 --- a/clippy_lints/src/ok_if_let.rs +++ b/clippy_lints/src/ok_if_let.rs @@ -7,11 +7,11 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -use crate::rustc::hir::*; -use crate::rustc::lint::{LateContext, LateLintPass, LintArray, LintPass}; -use crate::rustc::{declare_tool_lint, lint_array}; use crate::utils::{match_type, method_chain_args, paths, snippet, span_help_and_lint}; use if_chain::if_chain; +use rustc::hir::*; +use rustc::lint::{LateContext, LateLintPass, LintArray, LintPass}; +use rustc::{declare_tool_lint, lint_array}; /// **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 e78299bd3af..f6773dcb158 100644 --- a/clippy_lints/src/open_options.rs +++ b/clippy_lints/src/open_options.rs @@ -7,12 +7,12 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -use crate::rustc::hir::{Expr, ExprKind}; -use crate::rustc::lint::{LateContext, LateLintPass, LintArray, LintPass}; -use crate::rustc::{declare_tool_lint, lint_array}; -use crate::syntax::ast::LitKind; -use crate::syntax::source_map::{Span, Spanned}; use crate::utils::{match_type, paths, span_lint, walk_ptrs_ty}; +use rustc::hir::{Expr, ExprKind}; +use rustc::lint::{LateContext, LateLintPass, LintArray, LintPass}; +use rustc::{declare_tool_lint, lint_array}; +use syntax::ast::LitKind; +use syntax::source_map::{Span, Spanned}; /// **What it does:** Checks for duplicate open options as well as combinations /// that make no sense. diff --git a/clippy_lints/src/overflow_check_conditional.rs b/clippy_lints/src/overflow_check_conditional.rs index 7942e61c9f4..8df3ba4197f 100644 --- a/clippy_lints/src/overflow_check_conditional.rs +++ b/clippy_lints/src/overflow_check_conditional.rs @@ -7,11 +7,11 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -use crate::rustc::hir::*; -use crate::rustc::lint::{LateContext, LateLintPass, LintArray, LintPass}; -use crate::rustc::{declare_tool_lint, lint_array}; use crate::utils::{span_lint, SpanlessEq}; use if_chain::if_chain; +use rustc::hir::*; +use rustc::lint::{LateContext, LateLintPass, LintArray, LintPass}; +use rustc::{declare_tool_lint, lint_array}; /// **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 39b85b12a84..822361175d6 100644 --- a/clippy_lints/src/panic_unimplemented.rs +++ b/clippy_lints/src/panic_unimplemented.rs @@ -7,14 +7,14 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -use crate::rustc::hir::*; -use crate::rustc::lint::{LateContext, LateLintPass, LintArray, LintPass}; -use crate::rustc::{declare_tool_lint, lint_array}; -use crate::syntax::ast::LitKind; -use crate::syntax::ext::quote::rt::Span; -use crate::syntax::ptr::P; use crate::utils::{is_direct_expn_of, is_expn_of, match_def_path, opt_def_id, paths, resolve_node, span_lint}; use if_chain::if_chain; +use rustc::hir::*; +use rustc::lint::{LateContext, LateLintPass, LintArray, LintPass}; +use rustc::{declare_tool_lint, lint_array}; +use syntax::ast::LitKind; +use syntax::ext::quote::rt::Span; +use syntax::ptr::P; /// **What it does:** Checks for missing parameters in `panic!`. /// diff --git a/clippy_lints/src/partialeq_ne_impl.rs b/clippy_lints/src/partialeq_ne_impl.rs index 02935cf773d..c33367e7a3f 100644 --- a/clippy_lints/src/partialeq_ne_impl.rs +++ b/clippy_lints/src/partialeq_ne_impl.rs @@ -7,11 +7,11 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -use crate::rustc::hir::*; -use crate::rustc::lint::{LateContext, LateLintPass, LintArray, LintPass}; -use crate::rustc::{declare_tool_lint, lint_array}; use crate::utils::{is_automatically_derived, span_lint_node}; use if_chain::if_chain; +use rustc::hir::*; +use rustc::lint::{LateContext, LateLintPass, LintArray, LintPass}; +use rustc::{declare_tool_lint, lint_array}; /// **What it does:** Checks for manual re-implementations of `PartialEq::ne`. /// diff --git a/clippy_lints/src/precedence.rs b/clippy_lints/src/precedence.rs index 4f71f36528c..20a797937de 100644 --- a/clippy_lints/src/precedence.rs +++ b/clippy_lints/src/precedence.rs @@ -7,12 +7,12 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -use crate::rustc::lint::{EarlyContext, EarlyLintPass, LintArray, LintPass}; -use crate::rustc::{declare_tool_lint, lint_array}; -use crate::rustc_errors::Applicability; -use crate::syntax::ast::*; -use crate::syntax::source_map::Spanned; use crate::utils::{in_macro, snippet_with_applicability, span_lint_and_sugg}; +use rustc::lint::{EarlyContext, EarlyLintPass, LintArray, LintPass}; +use rustc::{declare_tool_lint, lint_array}; +use rustc_errors::Applicability; +use syntax::ast::*; +use syntax::source_map::Spanned; /// **What it does:** Checks for operations where precedence may be unclear /// and suggests to add parentheses. Currently it catches the following: @@ -138,7 +138,7 @@ fn is_arith_expr(expr: &Expr) -> bool { } fn is_bit_op(op: BinOpKind) -> bool { - use crate::syntax::ast::BinOpKind::*; + use syntax::ast::BinOpKind::*; match op { BitXor | BitAnd | BitOr | Shl | Shr => true, _ => false, @@ -146,7 +146,7 @@ fn is_bit_op(op: BinOpKind) -> bool { } fn is_arith_op(op: BinOpKind) -> bool { - use crate::syntax::ast::BinOpKind::*; + use syntax::ast::BinOpKind::*; match op { Add | Sub | Mul | Div | Rem => true, _ => false, diff --git a/clippy_lints/src/ptr.rs b/clippy_lints/src/ptr.rs index b2039c26300..f45bb54d191 100644 --- a/clippy_lints/src/ptr.rs +++ b/clippy_lints/src/ptr.rs @@ -9,19 +9,19 @@ //! Checks for usage of `&Vec[_]` and `&String`. -use crate::rustc::hir::QPath; -use crate::rustc::hir::*; -use crate::rustc::lint::{LateContext, LateLintPass, LintArray, LintPass}; -use crate::rustc::ty; -use crate::rustc::{declare_tool_lint, lint_array}; -use crate::rustc_errors::Applicability; -use crate::syntax::ast::NodeId; -use crate::syntax::source_map::Span; -use crate::syntax_pos::MultiSpan; use crate::utils::ptr::get_spans; use crate::utils::{match_qpath, match_type, paths, snippet_opt, span_lint, span_lint_and_then, walk_ptrs_hir_ty}; use if_chain::if_chain; +use rustc::hir::QPath; +use rustc::hir::*; +use rustc::lint::{LateContext, LateLintPass, LintArray, LintPass}; +use rustc::ty; +use rustc::{declare_tool_lint, lint_array}; +use rustc_errors::Applicability; use std::borrow::Cow; +use syntax::ast::NodeId; +use syntax::source_map::Span; +use syntax_pos::MultiSpan; /// **What it does:** This lint checks for function arguments of type `&String` /// or `&Vec` unless the references are mutable. It will also suggest you diff --git a/clippy_lints/src/ptr_offset_with_cast.rs b/clippy_lints/src/ptr_offset_with_cast.rs index 5d2714651ed..8d6bca8b689 100644 --- a/clippy_lints/src/ptr_offset_with_cast.rs +++ b/clippy_lints/src/ptr_offset_with_cast.rs @@ -7,9 +7,9 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -use crate::rustc::{declare_tool_lint, hir, lint, lint_array}; -use crate::rustc_errors::Applicability; use crate::utils; +use rustc::{declare_tool_lint, hir, lint, lint_array}; +use rustc_errors::Applicability; use std::fmt; /// **What it does:** Checks for usage of the `offset` pointer method with a `usize` casted to an diff --git a/clippy_lints/src/question_mark.rs b/clippy_lints/src/question_mark.rs index 76fb6350681..63a3a831304 100644 --- a/clippy_lints/src/question_mark.rs +++ b/clippy_lints/src/question_mark.rs @@ -7,17 +7,17 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -use crate::rustc::hir::def::Def; -use crate::rustc::hir::*; -use crate::rustc::lint::{LateContext, LateLintPass, LintArray, LintPass}; -use crate::rustc::{declare_tool_lint, lint_array}; -use crate::syntax::ptr::P; use crate::utils::sugg::Sugg; use if_chain::if_chain; +use rustc::hir::def::Def; +use rustc::hir::*; +use rustc::lint::{LateContext, LateLintPass, LintArray, LintPass}; +use rustc::{declare_tool_lint, lint_array}; +use syntax::ptr::P; -use crate::rustc_errors::Applicability; use crate::utils::paths::*; use crate::utils::{match_def_path, match_type, span_lint_and_then, SpanlessEq}; +use rustc_errors::Applicability; /// **What it does:** Checks for expressions that could be replaced by the question mark operator /// diff --git a/clippy_lints/src/ranges.rs b/clippy_lints/src/ranges.rs index d84943f1ddc..a0870ea72d0 100644 --- a/clippy_lints/src/ranges.rs +++ b/clippy_lints/src/ranges.rs @@ -7,16 +7,16 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -use crate::rustc::hir::*; -use crate::rustc::lint::{LateContext, LateLintPass, LintArray, LintPass}; -use crate::rustc::{declare_tool_lint, lint_array}; -use crate::rustc_errors::Applicability; -use crate::syntax::ast::RangeLimits; -use crate::syntax::source_map::Spanned; use crate::utils::sugg::Sugg; use crate::utils::{get_trait_def_id, higher, implements_trait, SpanlessEq}; use crate::utils::{is_integer_literal, paths, snippet, snippet_opt, span_lint, span_lint_and_then}; use if_chain::if_chain; +use rustc::hir::*; +use rustc::lint::{LateContext, LateLintPass, LintArray, LintPass}; +use rustc::{declare_tool_lint, lint_array}; +use rustc_errors::Applicability; +use syntax::ast::RangeLimits; +use syntax::source_map::Spanned; /// **What it does:** Checks for calling `.step_by(0)` on iterators, /// which never terminates. diff --git a/clippy_lints/src/redundant_clone.rs b/clippy_lints/src/redundant_clone.rs index 0d31129f30a..1983cb6cbc4 100644 --- a/clippy_lints/src/redundant_clone.rs +++ b/clippy_lints/src/redundant_clone.rs @@ -7,28 +7,28 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -use crate::rustc::hir::intravisit::FnKind; -use crate::rustc::hir::{def_id, Body, FnDecl}; -use crate::rustc::lint::{LateContext, LateLintPass, LintArray, LintPass}; -use crate::rustc::mir::{ - self, traversal, - visit::{MutatingUseContext, PlaceContext, Visitor}, - TerminatorKind, -}; -use crate::rustc::ty; -use crate::rustc::{declare_tool_lint, lint_array}; -use crate::rustc_errors::Applicability; -use crate::syntax::{ - ast::NodeId, - source_map::{BytePos, Span}, -}; use crate::utils::{ has_drop, in_macro, is_copy, match_def_path, match_type, paths, snippet_opt, span_lint_node, span_lint_node_and_then, walk_ptrs_ty_depth, }; use if_chain::if_chain; use matches::matches; +use rustc::hir::intravisit::FnKind; +use rustc::hir::{def_id, Body, FnDecl}; +use rustc::lint::{LateContext, LateLintPass, LintArray, LintPass}; +use rustc::mir::{ + self, traversal, + visit::{MutatingUseContext, PlaceContext, Visitor}, + TerminatorKind, +}; +use rustc::ty; +use rustc::{declare_tool_lint, lint_array}; +use rustc_errors::Applicability; use std::convert::TryFrom; +use syntax::{ + ast::NodeId, + source_map::{BytePos, Span}, +}; macro_rules! unwrap_or_continue { ($x:expr) => { diff --git a/clippy_lints/src/redundant_field_names.rs b/clippy_lints/src/redundant_field_names.rs index d8d80f2d128..a53df6a292a 100644 --- a/clippy_lints/src/redundant_field_names.rs +++ b/clippy_lints/src/redundant_field_names.rs @@ -7,11 +7,11 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -use crate::rustc::lint::{EarlyContext, EarlyLintPass, LintArray, LintPass}; -use crate::rustc::{declare_tool_lint, lint_array}; -use crate::rustc_errors::Applicability; -use crate::syntax::ast::*; use crate::utils::span_lint_and_sugg; +use rustc::lint::{EarlyContext, EarlyLintPass, LintArray, LintPass}; +use rustc::{declare_tool_lint, lint_array}; +use rustc_errors::Applicability; +use syntax::ast::*; /// **What it does:** Checks for fields in struct literals where shorthands /// could be used. diff --git a/clippy_lints/src/redundant_pattern_matching.rs b/clippy_lints/src/redundant_pattern_matching.rs index 4de98eb5525..bd194dd7bc3 100644 --- a/clippy_lints/src/redundant_pattern_matching.rs +++ b/clippy_lints/src/redundant_pattern_matching.rs @@ -7,13 +7,13 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -use crate::rustc::hir::*; -use crate::rustc::lint::{LateContext, LateLintPass, LintArray, LintPass}; -use crate::rustc::{declare_tool_lint, lint_array}; -use crate::rustc_errors::Applicability; -use crate::syntax::ast::LitKind; -use crate::syntax::ptr::P; use crate::utils::{match_qpath, paths, snippet, span_lint_and_then}; +use rustc::hir::*; +use rustc::lint::{LateContext, LateLintPass, LintArray, LintPass}; +use rustc::{declare_tool_lint, lint_array}; +use rustc_errors::Applicability; +use syntax::ast::LitKind; +use syntax::ptr::P; /// **What it does:** Lint for redundant pattern matching over `Result` or /// `Option` diff --git a/clippy_lints/src/reference.rs b/clippy_lints/src/reference.rs index 2e35719d466..d4145a2dd39 100644 --- a/clippy_lints/src/reference.rs +++ b/clippy_lints/src/reference.rs @@ -7,12 +7,12 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -use crate::rustc::lint::{EarlyContext, EarlyLintPass, LintArray, LintPass}; -use crate::rustc::{declare_tool_lint, lint_array}; -use crate::rustc_errors::Applicability; -use crate::syntax::ast::{Expr, ExprKind, UnOp}; use crate::utils::{snippet_with_applicability, span_lint_and_sugg}; use if_chain::if_chain; +use rustc::lint::{EarlyContext, EarlyLintPass, LintArray, LintPass}; +use rustc::{declare_tool_lint, lint_array}; +use rustc_errors::Applicability; +use syntax::ast::{Expr, ExprKind, UnOp}; /// **What it does:** Checks for usage of `*&` and `*&mut` in expressions. /// diff --git a/clippy_lints/src/regex.rs b/clippy_lints/src/regex.rs index 749d6068fe1..021237d38c0 100644 --- a/clippy_lints/src/regex.rs +++ b/clippy_lints/src/regex.rs @@ -8,16 +8,16 @@ // except according to those terms. use crate::consts::{constant, Constant}; -use crate::rustc::hir::*; -use crate::rustc::lint::{LateContext, LateLintPass, LintArray, LintPass}; -use crate::rustc::{declare_tool_lint, lint_array}; -use crate::rustc_data_structures::fx::FxHashSet; -use crate::syntax::ast::{LitKind, NodeId, StrStyle}; -use crate::syntax::source_map::{BytePos, Span}; use crate::utils::{is_expn_of, match_def_path, match_type, opt_def_id, paths, span_help_and_lint, span_lint}; use if_chain::if_chain; use regex_syntax; +use rustc::hir::*; +use rustc::lint::{LateContext, LateLintPass, LintArray, LintPass}; +use rustc::{declare_tool_lint, lint_array}; +use rustc_data_structures::fx::FxHashSet; use std::convert::TryFrom; +use syntax::ast::{LitKind, NodeId, StrStyle}; +use syntax::source_map::{BytePos, Span}; /// **What it does:** Checks [regex](https://crates.io/crates/regex) creation /// (with `Regex::new`,`RegexBuilder::new` or `RegexSet::new`) for correct diff --git a/clippy_lints/src/replace_consts.rs b/clippy_lints/src/replace_consts.rs index 0da44bc37a1..d905d3dbdf4 100644 --- a/clippy_lints/src/replace_consts.rs +++ b/clippy_lints/src/replace_consts.rs @@ -7,13 +7,13 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -use crate::rustc::hir; -use crate::rustc::hir::def::Def; -use crate::rustc::lint::{LateContext, LateLintPass, LintArray, LintPass}; -use crate::rustc::{declare_tool_lint, lint_array}; -use crate::rustc_errors::Applicability; use crate::utils::{match_def_path, span_lint_and_sugg}; use if_chain::if_chain; +use rustc::hir; +use rustc::hir::def::Def; +use rustc::lint::{LateContext, LateLintPass, LintArray, LintPass}; +use rustc::{declare_tool_lint, lint_array}; +use rustc_errors::Applicability; /// **What it does:** Checks for usage of `ATOMIC_X_INIT`, `ONCE_INIT`, and /// `uX/iX::MIN/MAX`. diff --git a/clippy_lints/src/returns.rs b/clippy_lints/src/returns.rs index c7dc6e1cde7..1ef03a77bd7 100644 --- a/clippy_lints/src/returns.rs +++ b/clippy_lints/src/returns.rs @@ -7,15 +7,15 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -use crate::rustc::lint::{in_external_macro, EarlyContext, EarlyLintPass, LintArray, LintContext, LintPass}; -use crate::rustc::{declare_tool_lint, lint_array}; -use crate::rustc_errors::Applicability; -use crate::syntax::ast; -use crate::syntax::source_map::Span; -use crate::syntax::visit::FnKind; -use crate::syntax_pos::BytePos; use crate::utils::{in_macro, match_path_ast, snippet_opt, span_lint_and_then, span_note_and_lint}; use if_chain::if_chain; +use rustc::lint::{in_external_macro, EarlyContext, EarlyLintPass, LintArray, LintContext, LintPass}; +use rustc::{declare_tool_lint, lint_array}; +use rustc_errors::Applicability; +use syntax::ast; +use syntax::source_map::Span; +use syntax::visit::FnKind; +use syntax_pos::BytePos; /// **What it does:** Checks for return statements at the end of a block. /// diff --git a/clippy_lints/src/serde_api.rs b/clippy_lints/src/serde_api.rs index a99f1398a26..d381f8c4419 100644 --- a/clippy_lints/src/serde_api.rs +++ b/clippy_lints/src/serde_api.rs @@ -7,10 +7,10 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -use crate::rustc::hir::*; -use crate::rustc::lint::{LateContext, LateLintPass, LintArray, LintPass}; -use crate::rustc::{declare_tool_lint, lint_array}; use crate::utils::{get_trait_def_id, paths, span_lint}; +use rustc::hir::*; +use rustc::lint::{LateContext, LateLintPass, LintArray, LintPass}; +use rustc::{declare_tool_lint, lint_array}; /// **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 21c4e9d30de..329e83e100b 100644 --- a/clippy_lints/src/shadow.rs +++ b/clippy_lints/src/shadow.rs @@ -8,13 +8,13 @@ // except according to those terms. use crate::reexport::*; -use crate::rustc::hir::intravisit::FnKind; -use crate::rustc::hir::*; -use crate::rustc::lint::{in_external_macro, LateContext, LateLintPass, LintArray, LintContext, LintPass}; -use crate::rustc::ty; -use crate::rustc::{declare_tool_lint, lint_array}; -use crate::syntax::source_map::Span; use crate::utils::{contains_name, higher, iter_input_pats, snippet, span_lint_and_then}; +use rustc::hir::intravisit::FnKind; +use rustc::hir::*; +use rustc::lint::{in_external_macro, LateContext, LateLintPass, LintArray, LintContext, LintPass}; +use rustc::ty; +use rustc::{declare_tool_lint, lint_array}; +use syntax::source_map::Span; /// **What it does:** Checks for bindings that shadow other bindings already in /// scope, while just changing reference level or mutability. diff --git a/clippy_lints/src/slow_vector_initialization.rs b/clippy_lints/src/slow_vector_initialization.rs index 0ec6fc0d0d1..fde679b6ed2 100644 --- a/clippy_lints/src/slow_vector_initialization.rs +++ b/clippy_lints/src/slow_vector_initialization.rs @@ -7,16 +7,16 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -use crate::rustc::hir::intravisit::{walk_block, walk_expr, walk_stmt, NestedVisitorMap, Visitor}; -use crate::rustc::hir::*; -use crate::rustc::lint::{LateContext, LateLintPass, Lint, LintArray, LintPass}; -use crate::rustc::{declare_tool_lint, lint_array}; -use crate::rustc_errors::Applicability; -use crate::syntax::ast::{LitKind, NodeId}; -use crate::syntax_pos::symbol::Symbol; 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::hir::intravisit::{walk_block, walk_expr, walk_stmt, NestedVisitorMap, Visitor}; +use rustc::hir::*; +use rustc::lint::{LateContext, LateLintPass, Lint, LintArray, LintPass}; +use rustc::{declare_tool_lint, lint_array}; +use rustc_errors::Applicability; +use syntax::ast::{LitKind, NodeId}; +use syntax_pos::symbol::Symbol; /// **What it does:** Checks slow zero-filled vector initialization /// diff --git a/clippy_lints/src/strings.rs b/clippy_lints/src/strings.rs index 05d64fbcd04..5414a1ac0de 100644 --- a/clippy_lints/src/strings.rs +++ b/clippy_lints/src/strings.rs @@ -7,13 +7,13 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -use crate::rustc::hir::*; -use crate::rustc::lint::{LateContext, LateLintPass, LintArray, LintPass}; -use crate::rustc::{declare_tool_lint, lint_array}; -use crate::rustc_errors::Applicability; -use crate::syntax::source_map::Spanned; use crate::utils::SpanlessEq; use crate::utils::{get_parent_expr, is_allowed, match_type, paths, span_lint, span_lint_and_sugg, walk_ptrs_ty}; +use rustc::hir::*; +use rustc::lint::{LateContext, LateLintPass, LintArray, LintPass}; +use rustc::{declare_tool_lint, lint_array}; +use rustc_errors::Applicability; +use syntax::source_map::Spanned; /// **What it does:** Checks for string appends of the form `x = x + y` (without /// `let`!). @@ -164,8 +164,8 @@ impl LintPass for StringLitAsBytes { impl<'a, 'tcx> LateLintPass<'a, 'tcx> for StringLitAsBytes { fn check_expr(&mut self, cx: &LateContext<'a, 'tcx>, e: &'tcx Expr) { - use crate::syntax::ast::{LitKind, StrStyle}; use crate::utils::{in_macro, snippet, snippet_with_applicability}; + use syntax::ast::{LitKind, StrStyle}; if let ExprKind::MethodCall(ref path, _, ref args) = e.node { if path.ident.name == "as_bytes" { diff --git a/clippy_lints/src/suspicious_trait_impl.rs b/clippy_lints/src/suspicious_trait_impl.rs index c54d89da705..04f8e4993f0 100644 --- a/clippy_lints/src/suspicious_trait_impl.rs +++ b/clippy_lints/src/suspicious_trait_impl.rs @@ -7,13 +7,13 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -use crate::rustc::hir; -use crate::rustc::hir::intravisit::{walk_expr, NestedVisitorMap, Visitor}; -use crate::rustc::lint::{LateContext, LateLintPass, LintArray, LintPass}; -use crate::rustc::{declare_tool_lint, lint_array}; -use crate::syntax::ast; use crate::utils::{get_trait_def_id, span_lint}; use if_chain::if_chain; +use rustc::hir; +use rustc::hir::intravisit::{walk_expr, NestedVisitorMap, Visitor}; +use rustc::lint::{LateContext, LateLintPass, LintArray, LintPass}; +use rustc::{declare_tool_lint, lint_array}; +use syntax::ast; /// **What it does:** Lints for suspicious operations in impls of arithmetic operators, e.g. /// subtracting elements in an Add impl. diff --git a/clippy_lints/src/swap.rs b/clippy_lints/src/swap.rs index a93ff124052..4c4fda26253 100644 --- a/clippy_lints/src/swap.rs +++ b/clippy_lints/src/swap.rs @@ -7,17 +7,17 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -use crate::rustc::hir::*; -use crate::rustc::lint::{LateContext, LateLintPass, LintArray, LintPass}; -use crate::rustc::ty; -use crate::rustc::{declare_tool_lint, lint_array}; -use crate::rustc_errors::Applicability; use crate::utils::sugg::Sugg; use crate::utils::{ differing_macro_contexts, match_type, paths, snippet, span_lint_and_then, walk_ptrs_ty, SpanlessEq, }; use if_chain::if_chain; use matches::matches; +use rustc::hir::*; +use rustc::lint::{LateContext, LateLintPass, LintArray, LintPass}; +use rustc::ty; +use rustc::{declare_tool_lint, lint_array}; +use rustc_errors::Applicability; /// **What it does:** Checks for manual swapping. /// diff --git a/clippy_lints/src/temporary_assignment.rs b/clippy_lints/src/temporary_assignment.rs index c25b0cf7661..a454b6fd997 100644 --- a/clippy_lints/src/temporary_assignment.rs +++ b/clippy_lints/src/temporary_assignment.rs @@ -7,11 +7,11 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -use crate::rustc::hir::{Expr, ExprKind}; -use crate::rustc::lint::{LateContext, LateLintPass, LintArray, LintPass}; -use crate::rustc::{declare_tool_lint, lint_array}; use crate::utils::is_adjusted; use crate::utils::span_lint; +use rustc::hir::{Expr, ExprKind}; +use rustc::lint::{LateContext, LateLintPass, LintArray, LintPass}; +use rustc::{declare_tool_lint, lint_array}; /// **What it does:** Checks for construction of a structure or tuple just to /// assign a value in it. diff --git a/clippy_lints/src/transmute.rs b/clippy_lints/src/transmute.rs index ec6439aef95..be3475f6703 100644 --- a/clippy_lints/src/transmute.rs +++ b/clippy_lints/src/transmute.rs @@ -7,16 +7,16 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -use crate::rustc::hir::*; -use crate::rustc::lint::{LateContext, LateLintPass, LintArray, LintPass}; -use crate::rustc::ty::{self, Ty}; -use crate::rustc::{declare_tool_lint, lint_array}; -use crate::rustc_errors::Applicability; -use crate::syntax::ast; use crate::utils::{last_path_segment, match_def_path, paths, snippet, span_lint, span_lint_and_then}; use crate::utils::{opt_def_id, sugg}; use if_chain::if_chain; +use rustc::hir::*; +use rustc::lint::{LateContext, LateLintPass, LintArray, LintPass}; +use rustc::ty::{self, Ty}; +use rustc::{declare_tool_lint, lint_array}; +use rustc_errors::Applicability; use std::borrow::Cow; +use syntax::ast; /// **What it does:** Checks for transmutes that can't ever be correct on any /// architecture. diff --git a/clippy_lints/src/trivially_copy_pass_by_ref.rs b/clippy_lints/src/trivially_copy_pass_by_ref.rs index 9a7a5958b62..efa6c0486eb 100644 --- a/clippy_lints/src/trivially_copy_pass_by_ref.rs +++ b/clippy_lints/src/trivially_copy_pass_by_ref.rs @@ -9,21 +9,21 @@ use std::cmp; -use crate::rustc::hir; -use crate::rustc::hir::intravisit::FnKind; -use crate::rustc::hir::*; -use crate::rustc::lint::{LateContext, LateLintPass, LintArray, LintPass}; -use crate::rustc::session::config::Config as SessionConfig; -use crate::rustc::ty::{self, FnSig}; -use crate::rustc::{declare_tool_lint, lint_array}; -use crate::rustc_errors::Applicability; -use crate::rustc_target::abi::LayoutOf; -use crate::rustc_target::spec::abi::Abi; -use crate::syntax::ast::NodeId; -use crate::syntax_pos::Span; use crate::utils::{in_macro, is_copy, is_self_ty, snippet, span_lint_and_sugg}; use if_chain::if_chain; use matches::matches; +use rustc::hir; +use rustc::hir::intravisit::FnKind; +use rustc::hir::*; +use rustc::lint::{LateContext, LateLintPass, LintArray, LintPass}; +use rustc::session::config::Config as SessionConfig; +use rustc::ty::{self, FnSig}; +use rustc::{declare_tool_lint, lint_array}; +use rustc_errors::Applicability; +use rustc_target::abi::LayoutOf; +use rustc_target::spec::abi::Abi; +use syntax::ast::NodeId; +use syntax_pos::Span; /// **What it does:** Checks for functions taking arguments by reference, where /// the argument type is `Copy` and small enough to be more efficient to always diff --git a/clippy_lints/src/types.rs b/clippy_lints/src/types.rs index dfa4cfdcf94..f4ca8209d67 100644 --- a/clippy_lints/src/types.rs +++ b/clippy_lints/src/types.rs @@ -12,19 +12,6 @@ use crate::consts::{constant, Constant}; use crate::reexport::*; -use crate::rustc::hir; -use crate::rustc::hir::intravisit::{walk_body, walk_expr, walk_ty, FnKind, NestedVisitorMap, Visitor}; -use crate::rustc::hir::*; -use crate::rustc::lint::{in_external_macro, LateContext, LateLintPass, LintArray, LintContext, LintPass}; -use crate::rustc::ty::layout::LayoutOf; -use crate::rustc::ty::{self, Ty, TyCtxt, TypeckTables}; -use crate::rustc::{declare_tool_lint, lint_array}; -use crate::rustc_errors::Applicability; -use crate::rustc_target::spec::abi::Abi; -use crate::rustc_typeck::hir_ty_to_ty; -use crate::syntax::ast::{FloatTy, IntTy, UintTy}; -use crate::syntax::errors::DiagnosticBuilder; -use crate::syntax::source_map::Span; use crate::utils::paths; use crate::utils::{ clip, comparisons, differing_macro_contexts, higher, in_constant, in_macro, int_bits, last_path_segment, @@ -33,9 +20,22 @@ use crate::utils::{ AbsolutePathBuffer, }; use if_chain::if_chain; +use rustc::hir; +use rustc::hir::intravisit::{walk_body, walk_expr, walk_ty, FnKind, NestedVisitorMap, Visitor}; +use rustc::hir::*; +use rustc::lint::{in_external_macro, LateContext, LateLintPass, LintArray, LintContext, LintPass}; +use rustc::ty::layout::LayoutOf; +use rustc::ty::{self, Ty, TyCtxt, TypeckTables}; +use rustc::{declare_tool_lint, lint_array}; +use rustc_errors::Applicability; +use rustc_target::spec::abi::Abi; +use rustc_typeck::hir_ty_to_ty; use std::borrow::Cow; use std::cmp::Ordering; use std::collections::BTreeMap; +use syntax::ast::{FloatTy, IntTy, UintTy}; +use syntax::errors::DiagnosticBuilder; +use syntax::source_map::Span; /// Handles all the linting of funky types pub struct TypePass; @@ -646,7 +646,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for UnitArg { } fn is_questionmark_desugar_marked_call(expr: &Expr) -> bool { - use crate::syntax_pos::hygiene::CompilerDesugaringKind; + use syntax_pos::hygiene::CompilerDesugaringKind; if let ExprKind::Call(ref callee, _) = expr.node { callee.span.is_compiler_desugaring(CompilerDesugaringKind::QuestionMark) } else { @@ -1112,7 +1112,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for CastPass { let (cast_from, cast_to) = (cx.tables.expr_ty(ex), cx.tables.expr_ty(expr)); lint_fn_to_numeric_cast(cx, expr, ex, cast_from, cast_to); if let ExprKind::Lit(ref lit) = ex.node { - use crate::syntax::ast::{LitIntType, LitKind}; + use syntax::ast::{LitIntType, LitKind}; match lit.node { LitKind::Int(_, LitIntType::Unsuffixed) | LitKind::FloatUnsuffixed(_) => {}, _ => { @@ -1460,7 +1460,7 @@ impl LintPass for CharLitAsU8 { impl<'a, 'tcx> LateLintPass<'a, 'tcx> for CharLitAsU8 { fn check_expr(&mut self, cx: &LateContext<'a, 'tcx>, expr: &'tcx Expr) { - use crate::syntax::ast::{LitKind, UintTy}; + use syntax::ast::{LitKind, UintTy}; if let ExprKind::Cast(ref e, _) = expr.node { if let ExprKind::Lit(ref l) = e.node { @@ -1734,8 +1734,8 @@ impl Ord for FullInt { } fn numeric_cast_precast_bounds<'a>(cx: &LateContext<'_, '_>, expr: &'a Expr) -> Option<(FullInt, FullInt)> { - use crate::syntax::ast::{IntTy, UintTy}; use std::*; + use syntax::ast::{IntTy, UintTy}; if let ExprKind::Cast(ref cast_exp, _) = expr.node { let pre_cast_ty = cx.tables.expr_ty(cast_exp); @@ -1937,7 +1937,7 @@ impl LintPass for ImplicitHasher { impl<'a, 'tcx> LateLintPass<'a, 'tcx> for ImplicitHasher { #[allow(clippy::cast_possible_truncation)] fn check_item(&mut self, cx: &LateContext<'a, 'tcx>, item: &'tcx Item) { - use crate::syntax_pos::BytePos; + use syntax_pos::BytePos; fn suggestion<'a, 'tcx>( cx: &LateContext<'a, 'tcx>, diff --git a/clippy_lints/src/unicode.rs b/clippy_lints/src/unicode.rs index 723565b3a9b..a38fe4a5aa9 100644 --- a/clippy_lints/src/unicode.rs +++ b/clippy_lints/src/unicode.rs @@ -7,12 +7,12 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -use crate::rustc::hir::*; -use crate::rustc::lint::{LateContext, LateLintPass, LintArray, LintPass}; -use crate::rustc::{declare_tool_lint, lint_array}; -use crate::syntax::ast::{LitKind, NodeId}; -use crate::syntax::source_map::Span; use crate::utils::{is_allowed, snippet, span_help_and_lint}; +use rustc::hir::*; +use rustc::lint::{LateContext, LateLintPass, LintArray, LintPass}; +use rustc::{declare_tool_lint, lint_array}; +use syntax::ast::{LitKind, NodeId}; +use syntax::source_map::Span; use unicode_normalization::UnicodeNormalization; /// **What it does:** Checks for the Unicode zero-width space in the code. diff --git a/clippy_lints/src/unsafe_removed_from_name.rs b/clippy_lints/src/unsafe_removed_from_name.rs index ce07e48eaf0..626b1c31013 100644 --- a/clippy_lints/src/unsafe_removed_from_name.rs +++ b/clippy_lints/src/unsafe_removed_from_name.rs @@ -7,12 +7,12 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -use crate::rustc::lint::{EarlyContext, EarlyLintPass, LintArray, LintPass}; -use crate::rustc::{declare_tool_lint, lint_array}; -use crate::syntax::ast::*; -use crate::syntax::source_map::Span; -use crate::syntax::symbol::LocalInternedString; use crate::utils::span_lint; +use rustc::lint::{EarlyContext, EarlyLintPass, LintArray, LintPass}; +use rustc::{declare_tool_lint, lint_array}; +use syntax::ast::*; +use syntax::source_map::Span; +use syntax::symbol::LocalInternedString; /// **What it does:** Checks for imports that remove "unsafe" from an item's /// name. diff --git a/clippy_lints/src/unused_io_amount.rs b/clippy_lints/src/unused_io_amount.rs index af2d742b2db..43f980c72c4 100644 --- a/clippy_lints/src/unused_io_amount.rs +++ b/clippy_lints/src/unused_io_amount.rs @@ -7,10 +7,10 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -use crate::rustc::hir; -use crate::rustc::lint::{LateContext, LateLintPass, LintArray, LintPass}; -use crate::rustc::{declare_tool_lint, lint_array}; use crate::utils::{is_try, match_qpath, match_trait_method, paths, span_lint}; +use rustc::hir; +use rustc::lint::{LateContext, LateLintPass, LintArray, LintPass}; +use rustc::{declare_tool_lint, lint_array}; /// **What it does:** Checks for unused written/read amount. /// diff --git a/clippy_lints/src/unused_label.rs b/clippy_lints/src/unused_label.rs index bebbce8e73e..766431c3687 100644 --- a/clippy_lints/src/unused_label.rs +++ b/clippy_lints/src/unused_label.rs @@ -7,15 +7,15 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -use crate::rustc::hir; -use crate::rustc::hir::intravisit::{walk_expr, walk_fn, FnKind, NestedVisitorMap, Visitor}; -use crate::rustc::lint::{LateContext, LateLintPass, LintArray, LintPass}; -use crate::rustc::{declare_tool_lint, lint_array}; -use crate::rustc_data_structures::fx::FxHashMap; -use crate::syntax::ast; -use crate::syntax::source_map::Span; -use crate::syntax::symbol::LocalInternedString; use crate::utils::{in_macro, span_lint}; +use rustc::hir; +use rustc::hir::intravisit::{walk_expr, walk_fn, FnKind, NestedVisitorMap, Visitor}; +use rustc::lint::{LateContext, LateLintPass, LintArray, LintPass}; +use rustc::{declare_tool_lint, lint_array}; +use rustc_data_structures::fx::FxHashMap; +use syntax::ast; +use syntax::source_map::Span; +use syntax::symbol::LocalInternedString; /// **What it does:** Checks for unused labels. /// diff --git a/clippy_lints/src/unwrap.rs b/clippy_lints/src/unwrap.rs index c65406a1954..b61b3b975f5 100644 --- a/clippy_lints/src/unwrap.rs +++ b/clippy_lints/src/unwrap.rs @@ -7,15 +7,15 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -use crate::rustc::lint::{LateContext, LateLintPass, LintArray, LintPass}; -use crate::rustc::{declare_tool_lint, lint_array}; use if_chain::if_chain; +use rustc::lint::{LateContext, LateLintPass, LintArray, LintPass}; +use rustc::{declare_tool_lint, lint_array}; -use crate::rustc::hir::intravisit::*; -use crate::rustc::hir::*; -use crate::syntax::ast::NodeId; -use crate::syntax::source_map::Span; use crate::utils::{in_macro, match_type, paths, span_lint_and_then, usage::is_potentially_mutated}; +use rustc::hir::intravisit::*; +use rustc::hir::*; +use syntax::ast::NodeId; +use syntax::source_map::Span; /// **What it does:** Checks for calls of `unwrap[_err]()` that cannot fail. /// diff --git a/clippy_lints/src/use_self.rs b/clippy_lints/src/use_self.rs index d4e03c097f7..653b6630b3c 100644 --- a/clippy_lints/src/use_self.rs +++ b/clippy_lints/src/use_self.rs @@ -7,16 +7,16 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -use crate::rustc::hir::intravisit::{walk_path, walk_ty, NestedVisitorMap, Visitor}; -use crate::rustc::hir::*; -use crate::rustc::lint::{LateContext, LateLintPass, LintArray, LintPass}; -use crate::rustc::ty; -use crate::rustc::{declare_tool_lint, lint_array}; -use crate::rustc_errors::Applicability; -use crate::syntax::ast::NodeId; -use crate::syntax_pos::symbol::keywords::SelfUpper; use crate::utils::{in_macro, span_lint_and_sugg}; use if_chain::if_chain; +use rustc::hir::intravisit::{walk_path, walk_ty, NestedVisitorMap, Visitor}; +use rustc::hir::*; +use rustc::lint::{LateContext, LateLintPass, LintArray, LintPass}; +use rustc::ty; +use rustc::{declare_tool_lint, lint_array}; +use rustc_errors::Applicability; +use syntax::ast::NodeId; +use syntax_pos::symbol::keywords::SelfUpper; /// **What it does:** Checks for unnecessary repetition of structure name when a /// replacement with `Self` is applicable. diff --git a/clippy_lints/src/utils/author.rs b/clippy_lints/src/utils/author.rs index 9eb543db6d4..e13c64b5c78 100644 --- a/clippy_lints/src/utils/author.rs +++ b/clippy_lints/src/utils/author.rs @@ -10,14 +10,14 @@ //! A group of attributes that can be attached to Rust code in order //! to generate a clippy lint detecting said code automatically. -use crate::rustc::hir; -use crate::rustc::hir::intravisit::{NestedVisitorMap, Visitor}; -use crate::rustc::hir::{BindingAnnotation, DeclKind, Expr, ExprKind, Pat, PatKind, QPath, Stmt, StmtKind, TyKind}; -use crate::rustc::lint::{LateContext, LateLintPass, LintArray, LintPass}; -use crate::rustc::{declare_tool_lint, lint_array}; -use crate::rustc_data_structures::fx::FxHashMap; -use crate::syntax::ast::{Attribute, LitKind, DUMMY_NODE_ID}; use crate::utils::get_attr; +use rustc::hir; +use rustc::hir::intravisit::{NestedVisitorMap, Visitor}; +use rustc::hir::{BindingAnnotation, DeclKind, Expr, ExprKind, Pat, PatKind, QPath, Stmt, StmtKind, TyKind}; +use rustc::lint::{LateContext, LateLintPass, LintArray, LintPass}; +use rustc::{declare_tool_lint, lint_array}; +use rustc_data_structures::fx::FxHashMap; +use syntax::ast::{Attribute, LitKind, DUMMY_NODE_ID}; /// **What it does:** Generates clippy code that detects the offending pattern /// diff --git a/clippy_lints/src/utils/comparisons.rs b/clippy_lints/src/utils/comparisons.rs index 05636e3234b..8b6a97a505c 100644 --- a/clippy_lints/src/utils/comparisons.rs +++ b/clippy_lints/src/utils/comparisons.rs @@ -11,7 +11,7 @@ #![deny(clippy::missing_docs_in_private_items)] -use crate::rustc::hir::{BinOpKind, Expr}; +use rustc::hir::{BinOpKind, Expr}; #[derive(PartialEq, Eq, Debug, Copy, Clone)] /// Represent a normalized comparison operator. diff --git a/clippy_lints/src/utils/conf.rs b/clippy_lints/src/utils/conf.rs index 35fcc08b518..da3a256a83d 100644 --- a/clippy_lints/src/utils/conf.rs +++ b/clippy_lints/src/utils/conf.rs @@ -11,12 +11,12 @@ #![deny(clippy::missing_docs_in_private_items)] -use crate::syntax::{ast, source_map}; use lazy_static::lazy_static; use std::default::Default; use std::io::Read; use std::sync::Mutex; use std::{env, fmt, fs, io, path}; +use syntax::{ast, source_map}; use toml; /// Get the configuration file from arguments. diff --git a/clippy_lints/src/utils/higher.rs b/clippy_lints/src/utils/higher.rs index 992a3321c70..214b3dc10e6 100644 --- a/clippy_lints/src/utils/higher.rs +++ b/clippy_lints/src/utils/higher.rs @@ -12,11 +12,11 @@ #![deny(clippy::missing_docs_in_private_items)] -use crate::rustc::lint::LateContext; -use crate::rustc::{hir, ty}; -use crate::syntax::ast; use crate::utils::{is_expn_of, match_def_path, match_qpath, opt_def_id, paths, resolve_node}; use if_chain::if_chain; +use rustc::lint::LateContext; +use rustc::{hir, ty}; +use syntax::ast; /// Convert a hir binary operator to the corresponding `ast` type. pub fn binop(op: hir::BinOpKind) -> ast::BinOpKind { diff --git a/clippy_lints/src/utils/hir_utils.rs b/clippy_lints/src/utils/hir_utils.rs index d7a57945658..79c9de13571 100644 --- a/clippy_lints/src/utils/hir_utils.rs +++ b/clippy_lints/src/utils/hir_utils.rs @@ -8,14 +8,14 @@ // except according to those terms. use crate::consts::{constant_context, constant_simple}; -use crate::rustc::hir::*; -use crate::rustc::lint::LateContext; -use crate::rustc::ty::TypeckTables; -use crate::syntax::ast::Name; -use crate::syntax::ptr::P; use crate::utils::differing_macro_contexts; +use rustc::hir::*; +use rustc::lint::LateContext; +use rustc::ty::TypeckTables; use std::collections::hash_map::DefaultHasher; use std::hash::{Hash, Hasher}; +use syntax::ast::Name; +use syntax::ptr::P; /// Type used to check whether two ast are the same. This is different from the /// operator diff --git a/clippy_lints/src/utils/inspector.rs b/clippy_lints/src/utils/inspector.rs index b9a58c51706..e4710b6a7a4 100644 --- a/clippy_lints/src/utils/inspector.rs +++ b/clippy_lints/src/utils/inspector.rs @@ -9,12 +9,12 @@ //! checks for attributes -use crate::rustc::hir; -use crate::rustc::hir::print; -use crate::rustc::lint::{LateContext, LateLintPass, LintArray, LintPass}; -use crate::rustc::{declare_tool_lint, lint_array}; -use crate::syntax::ast::Attribute; use crate::utils::get_attr; +use rustc::hir; +use rustc::hir::print; +use rustc::lint::{LateContext, LateLintPass, LintArray, LintPass}; +use rustc::{declare_tool_lint, lint_array}; +use syntax::ast::Attribute; /// **What it does:** Dumps every ast/hir node which has the `#[clippy::dump]` /// attribute diff --git a/clippy_lints/src/utils/internal_lints.rs b/clippy_lints/src/utils/internal_lints.rs index 144e2693b47..3705ab91ac2 100644 --- a/clippy_lints/src/utils/internal_lints.rs +++ b/clippy_lints/src/utils/internal_lints.rs @@ -7,21 +7,21 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -use crate::rustc::hir; -use crate::rustc::hir::def::Def; -use crate::rustc::hir::intravisit::{walk_expr, NestedVisitorMap, Visitor}; -use crate::rustc::hir::*; -use crate::rustc::lint::{EarlyContext, EarlyLintPass, LateContext, LateLintPass, LintArray, LintPass}; -use crate::rustc::{declare_tool_lint, lint_array}; -use crate::rustc_data_structures::fx::{FxHashMap, FxHashSet}; -use crate::rustc_errors::Applicability; -use crate::syntax::ast::{Crate as AstCrate, Ident, ItemKind, Name}; -use crate::syntax::source_map::Span; -use crate::syntax::symbol::LocalInternedString; use crate::utils::{ match_def_path, match_type, paths, span_help_and_lint, span_lint, span_lint_and_sugg, walk_ptrs_ty, }; use if_chain::if_chain; +use rustc::hir; +use rustc::hir::def::Def; +use rustc::hir::intravisit::{walk_expr, NestedVisitorMap, Visitor}; +use rustc::hir::*; +use rustc::lint::{EarlyContext, EarlyLintPass, LateContext, LateLintPass, LintArray, LintPass}; +use rustc::{declare_tool_lint, lint_array}; +use rustc_data_structures::fx::{FxHashMap, FxHashSet}; +use rustc_errors::Applicability; +use syntax::ast::{Crate as AstCrate, Ident, ItemKind, Name}; +use syntax::source_map::Span; +use syntax::symbol::LocalInternedString; /// **What it does:** Checks for various things we like to keep tidy in clippy. /// diff --git a/clippy_lints/src/utils/mod.rs b/clippy_lints/src/utils/mod.rs index cb4a656d1ff..2c0af12818e 100644 --- a/clippy_lints/src/utils/mod.rs +++ b/clippy_lints/src/utils/mod.rs @@ -8,35 +8,35 @@ // except according to those terms. use crate::reexport::*; -use crate::rustc::hir; -use crate::rustc::hir::def::Def; -use crate::rustc::hir::def_id::{DefId, CRATE_DEF_INDEX}; -use crate::rustc::hir::intravisit::{NestedVisitorMap, Visitor}; -use crate::rustc::hir::Node; -use crate::rustc::hir::*; -use crate::rustc::lint::{LateContext, Level, Lint, LintContext}; -use crate::rustc::session::Session; -use crate::rustc::traits; -use crate::rustc::ty::{ +use if_chain::if_chain; +use matches::matches; +use rustc::hir; +use rustc::hir::def::Def; +use rustc::hir::def_id::{DefId, CRATE_DEF_INDEX}; +use rustc::hir::intravisit::{NestedVisitorMap, Visitor}; +use rustc::hir::Node; +use rustc::hir::*; +use rustc::lint::{LateContext, Level, Lint, LintContext}; +use rustc::session::Session; +use rustc::traits; +use rustc::ty::{ self, layout::{self, IntegerExt}, subst::Kind, Binder, Ty, TyCtxt, }; -use crate::rustc_errors::{Applicability, CodeSuggestion, Substitution, SubstitutionPart}; -use crate::syntax::ast::{self, LitKind}; -use crate::syntax::attr; -use crate::syntax::errors::DiagnosticBuilder; -use crate::syntax::source_map::{Span, DUMMY_SP}; -use crate::syntax::symbol; -use crate::syntax::symbol::{keywords, Symbol}; -use if_chain::if_chain; -use matches::matches; +use rustc_errors::{Applicability, CodeSuggestion, Substitution, SubstitutionPart}; use std::borrow::Cow; use std::env; use std::mem; use std::rc::Rc; use std::str::FromStr; +use syntax::ast::{self, LitKind}; +use syntax::attr; +use syntax::errors::DiagnosticBuilder; +use syntax::source_map::{Span, DUMMY_SP}; +use syntax::symbol; +use syntax::symbol::{keywords, Symbol}; pub mod camel_case; diff --git a/clippy_lints/src/utils/ptr.rs b/clippy_lints/src/utils/ptr.rs index 854da37f4d2..3f589c3b687 100644 --- a/clippy_lints/src/utils/ptr.rs +++ b/clippy_lints/src/utils/ptr.rs @@ -7,13 +7,13 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -use crate::rustc::hir::intravisit::{walk_expr, NestedVisitorMap, Visitor}; -use crate::rustc::hir::*; -use crate::rustc::lint::LateContext; -use crate::syntax::ast::Name; -use crate::syntax::source_map::Span; use crate::utils::{get_pat_name, match_var, snippet}; +use rustc::hir::intravisit::{walk_expr, NestedVisitorMap, Visitor}; +use rustc::hir::*; +use rustc::lint::LateContext; use std::borrow::Cow; +use syntax::ast::Name; +use syntax::source_map::Span; pub fn get_spans( cx: &LateContext<'_, '_>, diff --git a/clippy_lints/src/utils/sugg.rs b/clippy_lints/src/utils/sugg.rs index f087b73bef4..a8bc0f3fca1 100644 --- a/clippy_lints/src/utils/sugg.rs +++ b/clippy_lints/src/utils/sugg.rs @@ -10,22 +10,22 @@ //! Contains utility functions to generate suggestions. #![deny(clippy::missing_docs_in_private_items)] -use crate::rustc::hir; -use crate::rustc::lint::{EarlyContext, LateContext, LintContext}; -use crate::rustc_errors; -use crate::rustc_errors::Applicability; -use crate::syntax::ast; -use crate::syntax::parse::token; -use crate::syntax::print::pprust::token_to_string; -use crate::syntax::source_map::{CharPos, Span}; -use crate::syntax::util::parser::AssocOp; -use crate::syntax_pos::{BytePos, Pos}; use crate::utils::{higher, in_macro, snippet, snippet_opt}; use matches::matches; +use rustc::hir; +use rustc::lint::{EarlyContext, LateContext, LintContext}; +use rustc_errors; +use rustc_errors::Applicability; use std; use std::borrow::Cow; use std::convert::TryInto; use std::fmt::Display; +use syntax::ast; +use syntax::parse::token; +use syntax::print::pprust::token_to_string; +use syntax::source_map::{CharPos, Span}; +use syntax::util::parser::AssocOp; +use syntax_pos::{BytePos, Pos}; /// A helper type to build suggestion correctly handling parenthesis. pub enum Sugg<'a> { @@ -122,7 +122,7 @@ impl<'a> Sugg<'a> { /// Prepare a suggestion from an expression. pub fn ast(cx: &EarlyContext<'_>, expr: &ast::Expr, default: &'a str) -> Self { - use crate::syntax::ast::RangeLimits; + use syntax::ast::RangeLimits; let snippet = snippet(cx, expr.span, default); @@ -407,7 +407,7 @@ enum Associativity { /// they are considered /// associative. fn associativity(op: &AssocOp) -> Associativity { - use crate::syntax::util::parser::AssocOp::*; + use syntax::util::parser::AssocOp::*; match *op { ObsoleteInPlace | Assign | AssignOp(_) => Associativity::Right, @@ -420,7 +420,7 @@ fn associativity(op: &AssocOp) -> Associativity { /// Convert a `hir::BinOp` to the corresponding assigning binary operator. fn hirbinop2assignop(op: hir::BinOp) -> AssocOp { - use crate::syntax::parse::token::BinOpToken::*; + use syntax::parse::token::BinOpToken::*; AssocOp::AssignOp(match op.node { hir::BinOpKind::Add => Plus, @@ -447,8 +447,8 @@ fn hirbinop2assignop(op: hir::BinOp) -> AssocOp { /// Convert an `ast::BinOp` to the corresponding assigning binary operator. fn astbinop2assignop(op: ast::BinOp) -> AssocOp { - use crate::syntax::ast::BinOpKind::*; - use crate::syntax::parse::token::BinOpToken; + use syntax::ast::BinOpKind::*; + use syntax::parse::token::BinOpToken; AssocOp::AssignOp(match op.node { Add => BinOpToken::Plus, diff --git a/clippy_lints/src/utils/usage.rs b/clippy_lints/src/utils/usage.rs index 31aa4b6fb5a..e4d3fa29996 100644 --- a/clippy_lints/src/utils/usage.rs +++ b/clippy_lints/src/utils/usage.rs @@ -7,17 +7,17 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -use crate::rustc::lint::LateContext; +use rustc::lint::LateContext; -use crate::rustc::hir::def::Def; -use crate::rustc::hir::*; -use crate::rustc::middle::expr_use_visitor::*; -use crate::rustc::middle::mem_categorization::cmt_; -use crate::rustc::middle::mem_categorization::Categorization; -use crate::rustc::ty; -use crate::rustc_data_structures::fx::FxHashSet; -use crate::syntax::ast::NodeId; -use crate::syntax::source_map::Span; +use rustc::hir::def::Def; +use rustc::hir::*; +use rustc::middle::expr_use_visitor::*; +use rustc::middle::mem_categorization::cmt_; +use rustc::middle::mem_categorization::Categorization; +use rustc::ty; +use rustc_data_structures::fx::FxHashSet; +use syntax::ast::NodeId; +use syntax::source_map::Span; /// Returns a set of mutated local variable ids or None if mutations could not be determined. pub fn mutated_variables<'a, 'tcx: 'a>(expr: &'tcx Expr, cx: &'a LateContext<'a, 'tcx>) -> Option<FxHashSet<NodeId>> { diff --git a/clippy_lints/src/vec.rs b/clippy_lints/src/vec.rs index 7d09c20db27..2f259bf8bca 100644 --- a/clippy_lints/src/vec.rs +++ b/clippy_lints/src/vec.rs @@ -8,14 +8,14 @@ // except according to those terms. use crate::consts::constant; -use crate::rustc::hir::*; -use crate::rustc::lint::{LateContext, LateLintPass, LintArray, LintPass}; -use crate::rustc::ty::{self, Ty}; -use crate::rustc::{declare_tool_lint, lint_array}; -use crate::rustc_errors::Applicability; -use crate::syntax::source_map::Span; use crate::utils::{higher, is_copy, snippet_with_applicability, span_lint_and_sugg}; use if_chain::if_chain; +use rustc::hir::*; +use rustc::lint::{LateContext, LateLintPass, LintArray, LintPass}; +use rustc::ty::{self, Ty}; +use rustc::{declare_tool_lint, lint_array}; +use rustc_errors::Applicability; +use syntax::source_map::Span; /// **What it does:** Checks for usage of `&vec![..]` when using `&[..]` would /// be possible. diff --git a/clippy_lints/src/wildcard_dependencies.rs b/clippy_lints/src/wildcard_dependencies.rs index 6de391d882f..38bce9da932 100644 --- a/clippy_lints/src/wildcard_dependencies.rs +++ b/clippy_lints/src/wildcard_dependencies.rs @@ -7,10 +7,10 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -use crate::rustc::lint::{EarlyContext, EarlyLintPass, LintArray, LintPass}; -use crate::rustc::{declare_tool_lint, lint_array}; -use crate::syntax::{ast::*, source_map::DUMMY_SP}; use crate::utils::span_lint; +use rustc::lint::{EarlyContext, EarlyLintPass, LintArray, LintPass}; +use rustc::{declare_tool_lint, lint_array}; +use syntax::{ast::*, source_map::DUMMY_SP}; use cargo_metadata; use if_chain::if_chain; diff --git a/clippy_lints/src/write.rs b/clippy_lints/src/write.rs index d226c6559c3..6531e71a9fa 100644 --- a/clippy_lints/src/write.rs +++ b/clippy_lints/src/write.rs @@ -7,14 +7,14 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -use crate::rustc::lint::{EarlyContext, EarlyLintPass, LintArray, LintPass}; -use crate::rustc::{declare_tool_lint, lint_array}; -use crate::rustc_errors::Applicability; -use crate::syntax::ast::*; -use crate::syntax::parse::{parser, token}; -use crate::syntax::tokenstream::{ThinTokenStream, TokenStream}; use crate::utils::{snippet_with_applicability, span_lint, span_lint_and_sugg}; +use rustc::lint::{EarlyContext, EarlyLintPass, LintArray, LintPass}; +use rustc::{declare_tool_lint, lint_array}; +use rustc_errors::Applicability; use std::borrow::Cow; +use syntax::ast::*; +use syntax::parse::{parser, token}; +use syntax::tokenstream::{ThinTokenStream, TokenStream}; /// **What it does:** This lint warns when you use `println!("")` to /// print a newline. @@ -271,7 +271,7 @@ impl EarlyLintPass for Pass { /// (Some("string to write: {}"), Some(buf)) /// ``` fn check_tts<'a>(cx: &EarlyContext<'a>, tts: &ThinTokenStream, is_write: bool) -> (Option<String>, Option<Expr>) { - use crate::fmt_macros::*; + use fmt_macros::*; let tts = TokenStream::from(tts.clone()); let mut parser = parser::Parser::new(&cx.sess.parse_sess, tts, None, false, false); let mut expr: Option<Expr> = None; diff --git a/clippy_lints/src/zero_div_zero.rs b/clippy_lints/src/zero_div_zero.rs index 20a92012520..93606e378d9 100644 --- a/clippy_lints/src/zero_div_zero.rs +++ b/clippy_lints/src/zero_div_zero.rs @@ -8,11 +8,11 @@ // except according to those terms. use crate::consts::{constant_simple, Constant}; -use crate::rustc::hir::*; -use crate::rustc::lint::{LateContext, LateLintPass, LintArray, LintPass}; -use crate::rustc::{declare_tool_lint, lint_array}; use crate::utils::span_help_and_lint; use if_chain::if_chain; +use rustc::hir::*; +use rustc::lint::{LateContext, LateLintPass, LintArray, LintPass}; +use rustc::{declare_tool_lint, lint_array}; /// **What it does:** Checks for `0.0 / 0.0`. /// diff --git a/tests/matches.rs b/tests/matches.rs index fb5dbf5d84d..00e2f043cbb 100644 --- a/tests/matches.rs +++ b/tests/matches.rs @@ -15,8 +15,8 @@ use std::collections::Bound; #[test] fn test_overlapping() { - use crate::syntax::source_map::DUMMY_SP; use clippy_lints::matches::overlapping; + use syntax::source_map::DUMMY_SP; let sp = |s, e| clippy_lints::matches::SpannedRange { span: DUMMY_SP, |