Auto merge of #3596 - xfix:remove-crate-from-paths, r=flip1995

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

diff --git a/clippy_lints/src/non_expressive_names.rs b/clippy_lints/src/non_expressive_names.rs
index daccc4bde03cc78025af46a1f1da45a190967068..2ab7d7e62f33dec62c41ceeff368f8ee28b0899f 100644 (file)
--- a/clippy_lints/src/non_expressive_names.rs
+++ b/clippy_lints/src/non_expressive_names.rs
@@ -1,11 +1,20 @@
-use rustc::lint::*;
-use rustc::{declare_lint, lint_array};
-use syntax::source_map::Span;
-use syntax::symbol::LocalInternedString;
+// Copyright 2014-2018 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+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};
-use crate::utils::{span_lint, span_lint_and_then};
 
 /// **What it does:** Checks for names that are very similar and thus confusing.
 ///
@@ -106,9 +115,11 @@ impl<'a, 'tcx: 'a, 'b> Visitor<'tcx> for SimilarNamesNameVisitor<'a, 'tcx, 'b> {
     fn visit_pat(&mut self, pat: &'tcx Pat) {
         match pat.node {
             PatKind::Ident(_, ident, _) => self.check_name(ident.span, ident.name),
-            PatKind::Struct(_, ref fields, _) => for field in fields {
-                if !field.node.is_shorthand {
-                    self.visit_pat(&field.node.pat);
+            PatKind::Struct(_, ref fields, _) => {
+                for field in fields {
+                    if !field.node.is_shorthand {
+                        self.visit_pat(&field.node.pat);
+                    }
                 }
             },
             _ => walk_pat(self, pat),
@@ -145,7 +156,10 @@ fn check_short_name(&mut self, c: char, span: Span) {
                 self.0.cx,
                 MANY_SINGLE_CHAR_NAMES,
                 span,
-                &format!("{}th binding whose name is just one char", self.0.single_char_names.len()),
+                &format!(
+                    "{}th binding whose name is just one char",
+                    self.0.single_char_names.len()
+                ),
             );
         }
     }
@@ -187,26 +201,19 @@ fn check_name(&mut self, span: Span, name: Name) {
             } else {
                 let mut interned_chars = interned_name.chars();
                 let mut existing_chars = existing_name.interned.chars();
-                let first_i = interned_chars
-                    .next()
-                    .expect("we know we have at least one char");
-                let first_e = existing_chars
-                    .next()
-                    .expect("we know we have at least one char");
+                let first_i = interned_chars.next().expect("we know we have at least one char");
+                let first_e = existing_chars.next().expect("we know we have at least one char");
                 let eq_or_numeric = |(a, b): (char, char)| a == b || a.is_numeric() && b.is_numeric();
 
                 if eq_or_numeric((first_i, first_e)) {
-                    let last_i = interned_chars
-                        .next_back()
-                        .expect("we know we have at least two chars");
-                    let last_e = existing_chars
-                        .next_back()
-                        .expect("we know we have at least two chars");
+                    let last_i = interned_chars.next_back().expect("we know we have at least two chars");
+                    let last_e = existing_chars.next_back().expect("we know we have at least two chars");
                     if eq_or_numeric((last_i, last_e)) {
                         if interned_chars
                             .zip(existing_chars)
                             .filter(|&ie| !eq_or_numeric(ie))
-                            .count() != 1
+                            .count()
+                            != 1
                         {
                             continue;
                         }
@@ -217,7 +224,8 @@ fn check_name(&mut self, span: Span, name: Name) {
                         let second_last_e = existing_chars
                             .next_back()
                             .expect("we know we have at least three chars");
-                        if !eq_or_numeric((second_last_i, second_last_e)) || second_last_i == '_'
+                        if !eq_or_numeric((second_last_i, second_last_e))
+                            || second_last_i == '_'
                             || !interned_chars.zip(existing_chars).all(eq_or_numeric)
                         {
                             // allowed similarity foo_x, foo_y
@@ -227,13 +235,10 @@ fn check_name(&mut self, span: Span, name: Name) {
                         split_at = interned_name.char_indices().rev().next().map(|(i, _)| i);
                     }
                 } else {
-                    let second_i = interned_chars
-                        .next()
-                        .expect("we know we have at least two chars");
-                    let second_e = existing_chars
-                        .next()
-                        .expect("we know we have at least two chars");
-                    if !eq_or_numeric((second_i, second_e)) || second_i == '_'
+                    let second_i = interned_chars.next().expect("we know we have at least two chars");
+                    let second_e = existing_chars.next().expect("we know we have at least two chars");
+                    if !eq_or_numeric((second_i, second_e))
+                        || second_i == '_'
                         || !interned_chars.zip(existing_chars).all(eq_or_numeric)
                     {
                         // allowed similarity x_foo, y_foo