Rustfmt all the things

clippy_lints/src/approx_const.rs

@@ -1,5 +1,6 @@
 use crate::utils::span_lint;
 use crate::utils::sym;
+use lazy_static::lazy_static;
 use rustc::hir::*;
 use rustc::lint::{LateContext, LateLintPass, LintArray, LintPass};
 use rustc::{declare_lint_pass, declare_tool_lint};
@@ -7,7 +8,6 @@ use std::f64::consts as f64;
 use syntax::ast::{FloatTy, LitKind};
 use syntax::symbol;
 use syntax::symbol::Symbol;
-use lazy_static::lazy_static;
 
 declare_clippy_lint! {
     /// **What it does:** Checks for floating point literals that approximate

clippy_lints/src/assertions_on_constants.rs

@@ -5,8 +5,8 @@ use rustc::{declare_lint_pass, declare_tool_lint};
 use syntax_pos::Span;
 
 use crate::consts::{constant, Constant};
-use crate::utils::{in_macro_or_desugar, is_direct_expn_of, span_help_and_lint};
 use crate::utils::sym;
+use crate::utils::{in_macro_or_desugar, is_direct_expn_of, span_help_and_lint};
 
 declare_clippy_lint! {
     /// **What it does:** Checks for `assert!(true)` and `assert!(false)` calls.

clippy_lints/src/attrs.rs

@@ -1,11 +1,11 @@
 //! checks for attributes
 
 use crate::reexport::*;
-use crate::utils::{
-    in_macro_or_desugar, is_present_in_source, last_line_of_span, paths, snippet_opt, span_lint, span_lint_and_sugg,
-    span_lint_and_then, without_block_comments, match_def_path
-};
 use crate::utils::sym;
+use crate::utils::{
+    in_macro_or_desugar, is_present_in_source, last_line_of_span, match_def_path, 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::{
@@ -245,7 +245,9 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Attributes {
                                     for lint in lint_list {
                                         match item.node {
                                             ItemKind::Use(..) => {
-                                                if is_word(lint, *sym::unused_imports) || is_word(lint, *sym::deprecated) {
+                                                if is_word(lint, *sym::unused_imports)
+                                                    || is_word(lint, *sym::deprecated)
+                                                {
                                                     return;
                                                 }
                                             },

clippy_lints/src/booleans.rs

@@ -1,8 +1,9 @@
+use crate::utils::sym;
 use crate::utils::{
     get_trait_def_id, implements_trait, in_macro, in_macro_or_desugar, match_type, paths, snippet_opt,
     span_lint_and_then, SpanlessEq,
 };
-use crate::utils::sym;
+use lazy_static::lazy_static;
 use rustc::hir::intravisit::*;
 use rustc::hir::*;
 use rustc::lint::{LateContext, LateLintPass, LintArray, LintPass};
@@ -12,7 +13,6 @@ use rustc_errors::Applicability;
 use syntax::ast::LitKind;
 use syntax::source_map::{dummy_spanned, Span, DUMMY_SP};
 use syntax::symbol::Symbol;
-use lazy_static::lazy_static;
 
 declare_clippy_lint! {
     /// **What it does:** Checks for boolean expressions that can be written more

clippy_lints/src/bytecount.rs

@@ -1,8 +1,8 @@
+use crate::utils::sym;
 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 crate::utils::sym;
 use if_chain::if_chain;
 use rustc::hir::*;
 use rustc::lint::{LateContext, LateLintPass, LintArray, LintPass};

clippy_lints/src/dbg_macro.rs

@@ -1,5 +1,5 @@
-use crate::utils::{snippet_opt, span_help_and_lint, span_lint_and_sugg};
 use crate::utils::sym;
+use crate::utils::{snippet_opt, span_help_and_lint, span_lint_and_sugg};
 use rustc::lint::{EarlyContext, EarlyLintPass, LintArray, LintPass};
 use rustc::{declare_lint_pass, declare_tool_lint};
 use rustc_errors::Applicability;

clippy_lints/src/default_trait_access.rs

@@ -5,7 +5,7 @@ use rustc::ty;
 use rustc::{declare_lint_pass, declare_tool_lint};
 use rustc_errors::Applicability;
 
-use crate::utils::{any_parent_is_automatically_derived, paths, span_lint_and_sugg, match_def_path};
+use crate::utils::{any_parent_is_automatically_derived, match_def_path, paths, span_lint_and_sugg};
 
 declare_clippy_lint! {
     /// **What it does:** Checks for literal calls to `Default::default()`.

clippy_lints/src/drop_bounds.rs

@@ -1,4 +1,4 @@
-use crate::utils::{paths, span_lint, match_def_path};
+use crate::utils::{match_def_path, paths, span_lint};
 use if_chain::if_chain;
 use rustc::hir::*;
 use rustc::lint::{LateLintPass, LintArray, LintPass};

clippy_lints/src/drop_forget_ref.rs

@@ -1,4 +1,4 @@
-use crate::utils::{is_copy, paths, span_note_and_lint, match_def_path};
+use crate::utils::{is_copy, match_def_path, paths, span_note_and_lint};
 use if_chain::if_chain;
 use rustc::hir::*;
 use rustc::lint::{LateContext, LateLintPass, LintArray, LintPass};

clippy_lints/src/entry.rs

@@ -1,5 +1,5 @@
-use crate::utils::SpanlessEq;
 use crate::utils::sym;
+use crate::utils::SpanlessEq;
 use crate::utils::{get_item_name, higher, match_type, paths, snippet, span_lint_and_then, walk_ptrs_ty};
 use if_chain::if_chain;
 use rustc::hir::intravisit::{walk_expr, NestedVisitorMap, Visitor};

clippy_lints/src/explicit_write.rs

@@ -1,5 +1,5 @@
-use crate::utils::{is_expn_of, resolve_node, span_lint, span_lint_and_sugg, match_def_path};
 use crate::utils::sym;
+use crate::utils::{is_expn_of, match_def_path, paths, resolve_node, span_lint, span_lint_and_sugg};
 use if_chain::if_chain;
 use rustc::hir::*;
 use rustc::lint::{LateContext, LateLintPass, LintArray, LintPass};
@@ -42,11 +42,10 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for ExplicitWrite {
             if write_args.len() > 0;
             if let ExprKind::Call(ref dest_fun, _) = write_args[0].node;
             if let ExprKind::Path(ref qpath) = dest_fun.node;
-            if let Some(dest_fun_id) =
+            if let Some(dest_fun_id) = resolve_node(cx, qpath, dest_fun.hir_id).opt_def_id();
-                resolve_node(cx, qpath, dest_fun.hir_id).opt_def_id();
+            if let Some(dest_name) = if match_def_path(cx, dest_fun_id, &*paths::STDOUT) {
-            if let Some(dest_name) = if match_def_path(cx, dest_fun_id, &[*sym::std, *sym::io, *sym::stdio, *sym::stdout]) {
                 Some("stdout")
-            } else if match_def_path(cx, dest_fun_id, &[*sym::std, *sym::io, *sym::stdio, *sym::stderr]) {
+            } else if match_def_path(cx, dest_fun_id, &*paths::STDERR) {
                 Some("stderr")
             } else {
                 None

clippy_lints/src/fallible_impl_from.rs

@@ -1,13 +1,13 @@
 use crate::utils::paths::{BEGIN_PANIC, BEGIN_PANIC_FMT, FROM_TRAIT, OPTION, RESULT};
-use crate::utils::{is_expn_of, method_chain_args, span_lint_and_then, walk_ptrs_ty, match_def_path};
 use crate::utils::sym;
+use crate::utils::{is_expn_of, match_def_path, method_chain_args, span_lint_and_then, walk_ptrs_ty};
 use if_chain::if_chain;
 use rustc::hir;
 use rustc::lint::{LateContext, LateLintPass, LintArray, LintPass};
 use rustc::ty::{self, Ty};
 use rustc::{declare_lint_pass, declare_tool_lint};
-use syntax_pos::Span;
 use syntax::symbol::Symbol;
+use syntax_pos::Span;
 
 declare_clippy_lint! {
     /// **What it does:** Checks for impls of `From<..>` that contain `panic!()` or `unwrap()`

clippy_lints/src/format.rs

@@ -1,8 +1,8 @@
 use crate::utils::paths;
 use crate::utils::sym;
 use crate::utils::{
-    in_macro_or_desugar, is_expn_of, last_path_segment, match_type, resolve_node, snippet, span_lint_and_then,
+    in_macro_or_desugar, is_expn_of, last_path_segment, match_def_path, match_type, resolve_node, snippet,
-    walk_ptrs_ty, match_def_path,
+    span_lint_and_then, walk_ptrs_ty,
 };
 use if_chain::if_chain;
 use rustc::hir::*;

clippy_lints/src/identity_conversion.rs

@@ -1,6 +1,6 @@
 use crate::utils::{
-    in_macro_or_desugar, match_trait_method, same_tys, snippet, snippet_with_macro_callsite, span_lint_and_then,
+    in_macro_or_desugar, match_def_path, match_trait_method, same_tys, snippet, snippet_with_macro_callsite,
-    match_def_path,
+    span_lint_and_then,
 };
 use crate::utils::{paths, resolve_node};
 use rustc::hir::*;

clippy_lints/src/implicit_return.rs

@@ -1,5 +1,5 @@
-use crate::utils::{in_macro_or_desugar, is_expn_of, snippet_opt, span_lint_and_then};
 use crate::utils::sym;
+use crate::utils::{in_macro_or_desugar, is_expn_of, snippet_opt, span_lint_and_then};
 use rustc::hir::{intravisit::FnKind, Body, ExprKind, FnDecl, HirId, MatchSource};
 use rustc::lint::{LateContext, LateLintPass, LintArray, LintPass};
 use rustc::{declare_lint_pass, declare_tool_lint};

clippy_lints/src/infinite_iter.rs

@@ -2,10 +2,10 @@ use rustc::hir::*;
 use rustc::lint::{LateContext, LateLintPass, LintArray, LintPass};
 use rustc::{declare_lint_pass, declare_tool_lint};
 
-use crate::utils::{get_trait_def_id, higher, implements_trait, match_qpath, match_type, paths, span_lint};
 use crate::utils::sym;
-use syntax::symbol::Symbol;
+use crate::utils::{get_trait_def_id, higher, implements_trait, match_qpath, match_type, paths, span_lint};
 use lazy_static::lazy_static;
+use syntax::symbol::Symbol;
 
 declare_clippy_lint! {
     /// **What it does:** Checks for iteration that is guaranteed to be infinite.

clippy_lints/src/invalid_ref.rs

@@ -1,4 +1,4 @@
-use crate::utils::{paths, span_help_and_lint, match_def_path};
+use crate::utils::{match_def_path, paths, span_help_and_lint};
 use if_chain::if_chain;
 use rustc::hir::*;
 use rustc::lint::{LateContext, LateLintPass, LintArray, LintPass};

clippy_lints/src/len_zero.rs

@@ -1,7 +1,7 @@
+use crate::utils::sym;
 use crate::utils::{
     get_item_name, in_macro_or_desugar, snippet_with_applicability, span_lint, span_lint_and_sugg, walk_ptrs_ty,
 };
-use crate::utils::sym;
 use rustc::hir::def_id::DefId;
 use rustc::hir::*;
 use rustc::lint::{LateContext, LateLintPass, LintArray, LintPass};
@@ -141,7 +141,8 @@ fn check_trait_items(cx: &LateContext<'_, '_>, visited_trait: &Item, trait_items
         }
     }
 
-    if cx.access_levels.is_exported(visited_trait.hir_id) && trait_items.iter().any(|i| is_named_self(cx, i, *sym::len)) {
+    if cx.access_levels.is_exported(visited_trait.hir_id) && trait_items.iter().any(|i| is_named_self(cx, i, *sym::len))
+    {
         let mut current_and_super_traits = FxHashSet::default();
         let visited_trait_def_id = cx.tcx.hir().local_def_id_from_hir_id(visited_trait.hir_id);
         fill_trait_set(visited_trait_def_id, &mut current_and_super_traits, cx);

clippy_lints/src/lifetimes.rs

@@ -476,7 +476,9 @@ struct BodyLifetimeChecker {
 impl<'tcx> Visitor<'tcx> for BodyLifetimeChecker {
     // for lifetimes as parameters of generics
     fn visit_lifetime(&mut self, lifetime: &'tcx Lifetime) {
-        if lifetime.name.ident().name != keywords::Invalid.name() && lifetime.name.ident().name != syntax::symbol::keywords::StaticLifetime.name() {
+        if lifetime.name.ident().name != keywords::Invalid.name()
+            && lifetime.name.ident().name != syntax::symbol::keywords::StaticLifetime.name()
+        {
             self.lifetimes_used_in_body = true;
         }
     }

clippy_lints/src/loops.rs

@@ -10,9 +10,9 @@ use rustc::middle::region;
 use rustc::{declare_lint_pass, declare_tool_lint};
 // use rustc::middle::region::CodeExtent;
 use crate::consts::{constant, Constant};
+use crate::utils::sym;
 use crate::utils::usage::mutated_variables;
 use crate::utils::{in_macro_or_desugar, sext, sugg};
-use crate::utils::sym;
 use rustc::middle::expr_use_visitor::*;
 use rustc::middle::mem_categorization::cmt_;
 use rustc::middle::mem_categorization::Categorization;
@@ -594,7 +594,10 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Loops {
     fn check_stmt(&mut self, cx: &LateContext<'a, 'tcx>, stmt: &'tcx Stmt) {
         if let StmtKind::Semi(ref expr) = stmt.node {
             if let ExprKind::MethodCall(ref method, _, ref args) = expr.node {
-                if args.len() == 1 && method.ident.name == *sym::collect && match_trait_method(cx, expr, &*paths::ITERATOR) {
+                if args.len() == 1
+                    && method.ident.name == *sym::collect
+                    && match_trait_method(cx, expr, &*paths::ITERATOR)
+                {
                     span_lint(
                         cx,
                         UNUSED_COLLECT,

clippy_lints/src/matches.rs

@@ -1,7 +1,7 @@
 use crate::consts::{constant, Constant};
 use crate::utils::paths;
-use crate::utils::sym;
 use crate::utils::sugg::Sugg;
+use crate::utils::sym;
 use crate::utils::{
     expr_block, in_macro_or_desugar, is_allowed, is_expn_of, match_qpath, match_type, multispan_sugg, remove_blocks,
     snippet, snippet_with_applicability, span_lint_and_sugg, span_lint_and_then, span_note_and_lint, walk_ptrs_ty,

clippy_lints/src/mem_discriminant.rs

@@ -1,4 +1,4 @@
-use crate::utils::{paths, snippet, span_lint_and_then, walk_ptrs_ty_depth, match_def_path};
+use crate::utils::{match_def_path, 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};

clippy_lints/src/mem_forget.rs

@@ -1,4 +1,4 @@
-use crate::utils::{paths, span_lint, match_def_path};
+use crate::utils::{match_def_path, paths, span_lint};
 use rustc::hir::{Expr, ExprKind};
 use rustc::lint::{LateContext, LateLintPass, LintArray, LintPass};
 use rustc::{declare_lint_pass, declare_tool_lint};

clippy_lints/src/mem_replace.rs

@@ -1,4 +1,4 @@
-use crate::utils::{match_qpath, paths, snippet_with_applicability, span_lint_and_sugg, match_def_path};
+use crate::utils::{match_def_path, match_qpath, 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};

clippy_lints/src/methods/mod.rs

@@ -6,6 +6,7 @@ use std::fmt;
 use std::iter;
 
 use if_chain::if_chain;
+use lazy_static::lazy_static;
 use matches::matches;
 use rustc::hir;
 use rustc::hir::def::{DefKind, Res};
@@ -16,18 +17,16 @@ use rustc_errors::Applicability;
 use syntax::ast;
 use syntax::source_map::{BytePos, Span};
 use syntax::symbol::{LocalInternedString, Symbol};
-use lazy_static::lazy_static;
 
 use crate::utils::paths;
 use crate::utils::sugg;
 use crate::utils::sym;
 use crate::utils::{
     get_arg_name, get_parent_expr, get_trait_def_id, has_iter_method, implements_trait, in_macro, is_copy,
-    is_ctor_function, is_expn_of, is_self, is_self_ty, iter_input_pats, last_path_segment, match_path, match_qpath,
+    is_ctor_function, is_expn_of, is_self, is_self_ty, iter_input_pats, last_path_segment, match_def_path, match_path,
-    match_trait_method, match_type, match_var, method_calls, method_chain_args, remove_blocks, return_ty, same_tys,
+    match_qpath, match_trait_method, match_type, match_var, method_calls, method_chain_args, remove_blocks, return_ty,
-    single_segment_path, snippet, snippet_with_applicability, snippet_with_macro_callsite, span_lint,
+    same_tys, single_segment_path, snippet, snippet_with_applicability, snippet_with_macro_callsite, span_lint,
     span_lint_and_sugg, span_lint_and_then, span_note_and_lint, walk_ptrs_ty, walk_ptrs_ty_depth, SpanlessEq,
-    match_def_path,
 };
 
 declare_clippy_lint! {
@@ -1068,7 +1067,8 @@ fn lint_or_fun_call(cx: &LateContext<'_, '_>, expr: &hir::Expr, method_span: Spa
 
                 if ["default", "new"].contains(&path) {
                     let arg_ty = cx.tables.expr_ty(arg);
-                    let default_trait_id = if let Some(default_trait_id) = get_trait_def_id(cx, &*paths::DEFAULT_TRAIT) {
+                    let default_trait_id = if let Some(default_trait_id) = get_trait_def_id(cx, &*paths::DEFAULT_TRAIT)
+                    {
                         default_trait_id
                     } else {
                         return false;
@@ -2216,15 +2216,33 @@ fn lint_chars_cmp_with_unwrap<'a, 'tcx>(
 
 /// Checks for the `CHARS_NEXT_CMP` lint with `unwrap()`.
 fn lint_chars_next_cmp_with_unwrap<'a, 'tcx>(cx: &LateContext<'a, 'tcx>, info: &BinaryExprInfo<'_>) -> bool {
-    lint_chars_cmp_with_unwrap(cx, info, &[*sym::chars, *sym::next, *sym::unwrap], CHARS_NEXT_CMP, "starts_with")
+    lint_chars_cmp_with_unwrap(
+        cx,
+        info,
+        &[*sym::chars, *sym::next, *sym::unwrap],
+        CHARS_NEXT_CMP,
+        "starts_with",
+    )
 }
 
 /// Checks for the `CHARS_LAST_CMP` lint with `unwrap()`.
 fn lint_chars_last_cmp_with_unwrap<'a, 'tcx>(cx: &LateContext<'a, 'tcx>, info: &BinaryExprInfo<'_>) -> bool {
-    if lint_chars_cmp_with_unwrap(cx, info, &[*sym::chars, *sym::last, *sym::unwrap], CHARS_LAST_CMP, "ends_with") {
+    if lint_chars_cmp_with_unwrap(
+        cx,
+        info,
+        &[*sym::chars, *sym::last, *sym::unwrap],
+        CHARS_LAST_CMP,
+        "ends_with",
+    ) {
         true
     } else {
-        lint_chars_cmp_with_unwrap(cx, info, &[*sym::chars, *sym::next_back, *sym::unwrap], CHARS_LAST_CMP, "ends_with")
+        lint_chars_cmp_with_unwrap(
+            cx,
+            info,
+            &[*sym::chars, *sym::next_back, *sym::unwrap],
+            CHARS_LAST_CMP,
+            "ends_with",
+        )
     }
 }
 
@@ -2288,10 +2306,7 @@ fn lint_asref(cx: &LateContext<'_, '_>, expr: &hir::Expr, call_name: &str, as_re
     }
 }
 
-fn ty_has_iter_method(
+fn ty_has_iter_method(cx: &LateContext<'_, '_>, self_ref_ty: Ty<'_>) -> Option<(&'static Lint, Symbol, &'static str)> {
-    cx: &LateContext<'_, '_>,
-    self_ref_ty: Ty<'_>,
-) -> Option<(&'static Lint, Symbol, &'static str)> {
     if let Some(ty_name) = has_iter_method(cx, self_ref_ty) {
         let lint = if ty_name == *sym::array || ty_name == *sym::PathBuf {
             INTO_ITER_ON_ARRAY

clippy_lints/src/minmax.rs

@@ -1,5 +1,5 @@
 use crate::consts::{constant_simple, Constant};
-use crate::utils::{paths, span_lint, match_def_path};
+use crate::utils::{match_def_path, paths, span_lint};
 use rustc::hir::*;
 use rustc::lint::{LateContext, LateLintPass, LintArray, LintPass};
 use rustc::{declare_lint_pass, declare_tool_lint};

clippy_lints/src/misc.rs

@@ -505,7 +505,8 @@ fn check_to_owned(cx: &LateContext<'_, '_>, expr: &Expr, other: &Expr) {
         },
         ExprKind::Call(ref path, ref v) if v.len() == 1 => {
             if let ExprKind::Path(ref path) = path.node {
-                if match_qpath(path, &[*sym::String, *sym::from_str]) || match_qpath(path, &[*sym::String, *sym::from]) {
+                if match_qpath(path, &[*sym::String, *sym::from_str]) || match_qpath(path, &[*sym::String, *sym::from])
+                {
                     (cx.tables.expr_ty_adjusted(&v[0]), snippet(cx, v[0].span, ".."))
                 } else {
                     return;

clippy_lints/src/missing_doc.rs

@@ -5,8 +5,8 @@
 // [`missing_doc`]: https://github.com/rust-lang/rust/blob/d6d05904697d89099b55da3331155392f1db9c00/src/librustc_lint/builtin.rs#L246
 //
 
-use crate::utils::{in_macro_or_desugar, span_lint};
 use crate::utils::sym;
+use crate::utils::{in_macro_or_desugar, span_lint};
 use if_chain::if_chain;
 use rustc::hir;
 use rustc::lint::{LateContext, LateLintPass, LintArray, LintContext, LintPass};

clippy_lints/src/needless_borrow.rs

@@ -2,8 +2,8 @@
 //!
 //! This lint is **warn** by default
 
-use crate::utils::{in_macro_or_desugar, snippet_opt, span_lint_and_then};
 use crate::utils::sym;
+use crate::utils::{in_macro_or_desugar, snippet_opt, span_lint_and_then};
 use if_chain::if_chain;
 use rustc::hir::{BindingAnnotation, Expr, ExprKind, HirId, Item, MutImmutable, Pat, PatKind};
 use rustc::lint::{LateContext, LateLintPass, LintArray, LintPass};

clippy_lints/src/new_without_default.rs

@@ -1,6 +1,6 @@
 use crate::utils::paths;
-use crate::utils::sym;
 use crate::utils::sugg::DiagnosticBuilderExt;
+use crate::utils::sym;
 use crate::utils::{get_trait_def_id, implements_trait, return_ty, same_tys, span_lint_hir_and_then};
 use if_chain::if_chain;
 use rustc::hir;

clippy_lints/src/non_expressive_names.rs

@@ -1,5 +1,5 @@
-use crate::utils::{span_lint, span_lint_and_then};
 use crate::utils::sym;
+use crate::utils::{span_lint, span_lint_and_then};
 use rustc::lint::{EarlyContext, EarlyLintPass, LintArray, LintPass};
 use rustc::{declare_tool_lint, impl_lint_pass};
 use syntax::ast::*;

clippy_lints/src/ok_if_let.rs

@@ -1,5 +1,5 @@
-use crate::utils::{match_type, method_chain_args, paths, snippet, span_help_and_lint};
 use crate::utils::sym;
+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};

clippy_lints/src/open_options.rs

@@ -1,5 +1,5 @@
-use crate::utils::{match_type, paths, span_lint, walk_ptrs_ty};
 use crate::utils::sym;
+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_lint_pass, declare_tool_lint};

clippy_lints/src/panic_unimplemented.rs

@@ -1,5 +1,5 @@
-use crate::utils::{is_direct_expn_of, is_expn_of, paths, resolve_node, span_lint, match_def_path};
 use crate::utils::sym;
+use crate::utils::{is_direct_expn_of, is_expn_of, match_def_path, paths, resolve_node, span_lint};
 use if_chain::if_chain;
 use rustc::hir::*;
 use rustc::lint::{LateContext, LateLintPass, LintArray, LintPass};

clippy_lints/src/partialeq_ne_impl.rs

@@ -1,5 +1,5 @@
-use crate::utils::{is_automatically_derived, span_lint_hir};
 use crate::utils::sym;
+use crate::utils::{is_automatically_derived, span_lint_hir};
 use if_chain::if_chain;
 use rustc::hir::*;
 use rustc::lint::{LateContext, LateLintPass, LintArray, LintPass};

clippy_lints/src/path_buf_push_overwrite.rs

@@ -1,5 +1,5 @@
-use crate::utils::{match_type, paths, span_lint_and_sugg, walk_ptrs_ty};
 use crate::utils::sym;
+use crate::utils::{match_type, paths, span_lint_and_sugg, walk_ptrs_ty};
 use if_chain::if_chain;
 use rustc::hir::*;
 use rustc::lint::{LateContext, LateLintPass, LintArray, LintPass};

clippy_lints/src/ptr.rs

@@ -194,7 +194,12 @@ fn check_fn(cx: &LateContext<'_, '_>, decl: &FnDecl, fn_id: HirId, opt_body_id:
                     );
                 }
             } else if match_type(cx, ty, &*paths::STRING) {
-                if let Some(spans) = get_spans(cx, opt_body_id, idx, &[(*sym::clone, ".to_string()"), (*sym::as_str, "")]) {
+                if let Some(spans) = get_spans(
+                    cx,
+                    opt_body_id,
+                    idx,
+                    &[(*sym::clone, ".to_string()"), (*sym::as_str, "")],
+                ) {
                     span_lint_and_then(
                         cx,
                         PTR_ARG,

clippy_lints/src/question_mark.rs

@@ -7,9 +7,9 @@ use rustc_errors::Applicability;
 use syntax::ptr::P;
 
 use crate::utils::paths::*;
-use crate::utils::sym;
 use crate::utils::sugg::Sugg;
-use crate::utils::{higher, match_type, span_lint_and_then, SpanlessEq, match_def_path};
+use crate::utils::sym;
+use crate::utils::{higher, match_def_path, match_type, span_lint_and_then, SpanlessEq};
 
 declare_clippy_lint! {
     /// **What it does:** Checks for expressions that could be replaced by the question mark operator.

clippy_lints/src/ranges.rs

@@ -213,7 +213,8 @@ fn has_step_by(cx: &LateContext<'_, '_>, expr: &Expr) -> bool {
     // can't be called on a borrowed range.
     let ty = cx.tables.expr_ty_adjusted(expr);
 
-    get_trait_def_id(cx, &*paths::ITERATOR).map_or(false, |iterator_trait| implements_trait(cx, ty, iterator_trait, &[]))
+    get_trait_def_id(cx, &*paths::ITERATOR)
+        .map_or(false, |iterator_trait| implements_trait(cx, ty, iterator_trait, &[]))
 }
 
 fn y_plus_one(expr: &Expr) -> Option<&Expr> {

clippy_lints/src/redundant_clone.rs

@@ -1,6 +1,6 @@
 use crate::utils::{
-    has_drop, in_macro_or_desugar, is_copy, match_type, paths, snippet_opt, span_lint_hir, span_lint_hir_and_then,
+    has_drop, in_macro_or_desugar, is_copy, match_def_path, match_type, paths, snippet_opt, span_lint_hir,
-    walk_ptrs_ty_depth, match_def_path,
+    span_lint_hir_and_then, walk_ptrs_ty_depth,
 };
 use if_chain::if_chain;
 use matches::matches;
@@ -96,7 +96,8 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for RedundantClone {
 
             let from_borrow = match_def_path(cx, fn_def_id, &*paths::CLONE_TRAIT_METHOD)
                 || match_def_path(cx, fn_def_id, &*paths::TO_OWNED_METHOD)
-                || (match_def_path(cx, fn_def_id, &*paths::TO_STRING_METHOD) && match_type(cx, arg_ty, &*paths::STRING));
+                || (match_def_path(cx, fn_def_id, &*paths::TO_STRING_METHOD)
+                    && match_type(cx, arg_ty, &*paths::STRING));
 
             let from_deref = !from_borrow
                 && (match_def_path(cx, fn_def_id, &*paths::PATH_TO_PATH_BUF)

clippy_lints/src/regex.rs

@@ -1,6 +1,6 @@
 use crate::consts::{constant, Constant};
-use crate::utils::{is_expn_of, match_type, paths, span_help_and_lint, span_lint, match_def_path};
 use crate::utils::sym;
+use crate::utils::{is_expn_of, match_def_path, match_type, paths, span_help_and_lint, span_lint};
 use if_chain::if_chain;
 use regex_syntax;
 use rustc::hir::*;

clippy_lints/src/replace_consts.rs

@@ -1,13 +1,13 @@
-use crate::utils::{span_lint_and_sugg, match_def_path};
 use crate::utils::sym;
+use crate::utils::{match_def_path, span_lint_and_sugg};
 use if_chain::if_chain;
+use lazy_static::lazy_static;
 use rustc::hir;
 use rustc::hir::def::{DefKind, Res};
 use rustc::lint::{LateContext, LateLintPass, LintArray, LintPass};
 use rustc::{declare_lint_pass, declare_tool_lint};
 use rustc_errors::Applicability;
 use syntax::symbol::Symbol;
-use lazy_static::lazy_static;
 
 declare_clippy_lint! {
     /// **What it does:** Checks for usage of `ATOMIC_X_INIT`, `ONCE_INIT`, and

clippy_lints/src/returns.rs

@@ -7,8 +7,8 @@ use syntax::source_map::Span;
 use syntax::visit::FnKind;
 use syntax_pos::BytePos;
 
-use crate::utils::{in_macro_or_desugar, match_path_ast, snippet_opt, span_lint_and_then, span_note_and_lint};
 use crate::utils::sym;
+use crate::utils::{in_macro_or_desugar, match_path_ast, snippet_opt, span_lint_and_then, span_note_and_lint};
 
 declare_clippy_lint! {
     /// **What it does:** Checks for return statements at the end of a block.

clippy_lints/src/slow_vector_initialization.rs

@@ -1,6 +1,6 @@
 use crate::utils::sugg::Sugg;
-use crate::utils::{get_enclosing_block, match_qpath, span_lint_and_then, SpanlessEq};
 use crate::utils::sym;
+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::*;

clippy_lints/src/strings.rs

@@ -4,8 +4,8 @@ use rustc::{declare_lint_pass, declare_tool_lint};
 use rustc_errors::Applicability;
 use syntax::source_map::Spanned;
 
-use crate::utils::SpanlessEq;
 use crate::utils::sym;
+use crate::utils::SpanlessEq;
 use crate::utils::{get_parent_expr, is_allowed, match_type, paths, span_lint, span_lint_and_sugg, walk_ptrs_ty};
 
 declare_clippy_lint! {

clippy_lints/src/suspicious_trait_impl.rs

@@ -1,5 +1,5 @@
-use crate::utils::{get_trait_def_id, span_lint, trait_ref_of_method};
 use crate::utils::sym;
+use crate::utils::{get_trait_def_id, span_lint, trait_ref_of_method};
 use if_chain::if_chain;
 use rustc::hir;
 use rustc::hir::intravisit::{walk_expr, NestedVisitorMap, Visitor};

clippy_lints/src/transmute.rs

@@ -1,4 +1,4 @@
-use crate::utils::{last_path_segment, paths, snippet, span_lint, span_lint_and_then, sugg, match_def_path};
+use crate::utils::{last_path_segment, match_def_path, paths, snippet, span_lint, span_lint_and_then, sugg};
 use if_chain::if_chain;
 use rustc::hir::*;
 use rustc::lint::{LateContext, LateLintPass, LintArray, LintPass};

clippy_lints/src/transmuting_null.rs

@@ -1,5 +1,5 @@
 use crate::consts::{constant_context, Constant};
-use crate::utils::{paths, match_qpath, span_lint};
+use crate::utils::{match_qpath, paths, span_lint};
 use if_chain::if_chain;
 use rustc::hir::{Expr, ExprKind};
 use rustc::lint::{in_external_macro, LateContext, LateLintPass, LintArray, LintContext, LintPass};

clippy_lints/src/trivially_copy_pass_by_ref.rs

@@ -1,7 +1,7 @@
 use std::cmp;
 
-use crate::utils::{in_macro_or_desugar, is_copy, is_self_ty, snippet, span_lint_and_sugg};
 use crate::utils::sym;
+use crate::utils::{in_macro_or_desugar, is_copy, is_self_ty, snippet, span_lint_and_sugg};
 use if_chain::if_chain;
 use matches::matches;
 use rustc::hir;

clippy_lints/src/types.rs

@@ -22,12 +22,12 @@ use syntax::symbol::Symbol;
 
 use crate::consts::{constant, Constant};
 use crate::utils::paths;
+use crate::utils::sym;
 use crate::utils::{
     clip, comparisons, differing_macro_contexts, higher, in_constant, in_macro_or_desugar, int_bits, last_path_segment,
-    match_path, multispan_sugg, same_tys, sext, snippet, snippet_opt, snippet_with_applicability, span_help_and_lint,
+    match_def_path, match_path, multispan_sugg, same_tys, sext, snippet, snippet_opt, snippet_with_applicability,
-    span_lint, span_lint_and_sugg, span_lint_and_then, unsext, match_def_path,
+    span_help_and_lint, span_lint, span_lint_and_sugg, span_lint_and_then, unsext,
 };
-use crate::utils::sym;
 
 declare_clippy_lint! {
     /// **What it does:** Checks for use of `Box<Vec<_>>` anywhere in the code.

clippy_lints/src/unwrap.rs

@@ -2,10 +2,10 @@ use if_chain::if_chain;
 use rustc::lint::{LateContext, LateLintPass, LintArray, LintPass};
 use rustc::{declare_lint_pass, declare_tool_lint};
 
+use crate::utils::sym;
 use crate::utils::{
     higher::if_block, in_macro_or_desugar, match_type, paths, span_lint_and_then, usage::is_potentially_mutated,
 };
-use crate::utils::sym;
 use rustc::hir::intravisit::*;
 use rustc::hir::*;
 use syntax::source_map::Span;

clippy_lints/src/utils/conf.rs

@@ -2,8 +2,8 @@
 
 #![deny(clippy::missing_docs_in_private_items)]
 
-use lazy_static::lazy_static;
 use crate::utils::sym;
+use lazy_static::lazy_static;
 use std::default::Default;
 use std::io::Read;
 use std::sync::Mutex;

clippy_lints/src/utils/higher.rs

@@ -3,8 +3,8 @@
 
 #![deny(clippy::missing_docs_in_private_items)]
 
-use crate::utils::{is_expn_of, match_def_path, match_qpath, paths, resolve_node};
 use crate::utils::sym;
+use crate::utils::{is_expn_of, match_def_path, match_qpath, paths, resolve_node};
 use if_chain::if_chain;
 use rustc::lint::LateContext;
 use rustc::{hir, ty};
@@ -102,7 +102,8 @@ pub fn range<'a, 'b, 'tcx>(cx: &LateContext<'a, 'tcx>, expr: &'b hir::Expr) -> O
         },
         hir::ExprKind::Call(ref path, ref args) => {
             if let hir::ExprKind::Path(ref path) = path.node {
-                if match_qpath(path, &*paths::RANGE_INCLUSIVE_STD_NEW) || match_qpath(path, &*paths::RANGE_INCLUSIVE_NEW)
+                if match_qpath(path, &*paths::RANGE_INCLUSIVE_STD_NEW)
+                    || match_qpath(path, &*paths::RANGE_INCLUSIVE_NEW)
                 {
                     Some(Range {
                         start: Some(&args[0]),
@@ -129,7 +130,8 @@ pub fn range<'a, 'b, 'tcx>(cx: &LateContext<'a, 'tcx>, expr: &'b hir::Expr) -> O
                     end: Some(get_field(*sym::end, fields)?),
                     limits: ast::RangeLimits::HalfOpen,
                 })
-            } else if match_qpath(path, &*paths::RANGE_TO_INCLUSIVE_STD) || match_qpath(path, &*paths::RANGE_TO_INCLUSIVE)
+            } else if match_qpath(path, &*paths::RANGE_TO_INCLUSIVE_STD)
+                || match_qpath(path, &*paths::RANGE_TO_INCLUSIVE)
             {
                 Some(Range {
                     start: None,

clippy_lints/src/utils/internal_lints.rs

@@ -1,4 +1,4 @@
-use crate::utils::{match_type, match_def_path, paths, span_help_and_lint, span_lint, walk_ptrs_ty};
+use crate::utils::{match_def_path, match_type, paths, span_help_and_lint, span_lint, walk_ptrs_ty};
 use if_chain::if_chain;
 use rustc::hir;
 use rustc::hir::def::{DefKind, Res};

clippy_lints/src/utils/paths.rs

@@ -4,8 +4,8 @@
 #![allow(default_hash_types)] // we just look at symbol names, which is good enough everywhere else
 
 use super::sym::{self, *};
-use syntax::symbol::Symbol;
 use lazy_static::lazy_static;
+use syntax::symbol::Symbol;
 
 lazy_static! {
     pub static ref ANY_TRAIT: [Symbol; 3] = [*std, *any, *Any];
@@ -105,6 +105,8 @@ pub static ref SLICE_INTO_VEC: [Symbol; 4] = [*alloc, *slice, *impl_slice_t, *in
     pub static ref SLICE_ITER: [Symbol; 3] = [*core, *slice, *Iter];
     pub static ref STD_MEM_TRANSMUTE: [Symbol; 3] = [*std, *mem, *transmute];
     pub static ref STD_PTR_NULL: [Symbol; 3] = [*std, *ptr, *null];
+    pub static ref STDERR: [Symbol; 4] = [*std, *io, *stdio, *stderr];
+    pub static ref STDOUT: [Symbol; 4] = [*std, *io, *stdio, *stdout];
     pub static ref STRING: [Symbol; 3] = [*alloc, *string, *sym::String];
     pub static ref TO_OWNED: [Symbol; 3] = [*alloc, *borrow, *sym::ToOwned];
     pub static ref TO_OWNED_METHOD: [Symbol; 4] = [*alloc, *borrow, *sym::ToOwned, *to_owned];

clippy_lints/src/utils/ptr.rs

@@ -1,5 +1,5 @@
-use crate::utils::{get_pat_name, match_var, snippet};
 use crate::utils::sym;
+use crate::utils::{get_pat_name, match_var, snippet};
 use rustc::hir::intravisit::{walk_expr, NestedVisitorMap, Visitor};
 use rustc::hir::*;
 use rustc::lint::LateContext;

clippy_lints/src/utils/sym.rs

@@ -1,7 +1,7 @@
 #![allow(default_hash_types, non_upper_case_globals)]
 
-use syntax::symbol::Symbol;
 use lazy_static::lazy_static;
+use syntax::symbol::Symbol;
 
 macro_rules! symbols_simple {
     ($($ident:ident,)*) => {
@@ -26,17 +26,17 @@ macro_rules! symbols_init {
 // exists because concat_idents is flaky
 pub mod assign {
     pub(crate) use super::AddAssign as Add;
-    pub(crate) use super::SubAssign as Sub;
-    pub(crate) use super::MulAssign as Mul;
-    pub(crate) use super::DivAssign as Div;
-    pub(crate) use super::RemAssign as Rem;
     pub(crate) use super::AndAssign as And;
-    pub(crate) use super::OrAssign as Or;
     pub(crate) use super::BitAndAssign as BitAnd;
     pub(crate) use super::BitOrAssign as BitOr;
     pub(crate) use super::BitXorAssign as BitXor;
-    pub(crate) use super::ShrAssign as Shr;
+    pub(crate) use super::DivAssign as Div;
+    pub(crate) use super::MulAssign as Mul;
+    pub(crate) use super::OrAssign as Or;
+    pub(crate) use super::RemAssign as Rem;
     pub(crate) use super::ShlAssign as Shl;
+    pub(crate) use super::ShrAssign as Shr;
+    pub(crate) use super::SubAssign as Sub;
 }
 
 symbols_simple! {
@@ -387,7 +387,6 @@ symbols_simple! {
     zip,
 }
 
-
 symbols_init! {
     impl_slice_t: "<impl [T]>",
     empty_symbol: "",