Address review

mati865 · mati865 · commit 92f099835851 · 2018-06-28T16:20:31.000+02:00
diff --git a/clippy_lints/src/blacklisted_name.rs b/clippy_lints/src/blacklisted_name.rs
@@ -41,7 +41,7 @@ impl LintPass for BlackListedName {
 
 impl<'a, 'tcx> LateLintPass<'a, 'tcx> for BlackListedName {
     fn check_pat(&mut self, cx: &LateContext<'a, 'tcx>, pat: &'tcx Pat) {
-        if let PatKind::Binding(_, _, ref ident, _) = pat.node {
+        if let PatKind::Binding(_, _, ident, _) = pat.node {
             if self.blacklist.iter().any(|s| ident.name == *s) {
                 span_lint(
                     cx,
diff --git a/clippy_lints/src/booleans.rs b/clippy_lints/src/booleans.rs
@@ -203,7 +203,7 @@ impl<'a, 'tcx, 'v> SuggestContext<'a, 'tcx, 'v> {
                 METHODS_WITH_NEGATION
                     .iter().cloned()
                     .flat_map(|(a, b)| vec![(a, b), (b, a)])
-                    .find(|&(a, _)| a == path.ident.name.as_str())
+                    .find(|&(a, _)| a == path.ident.as_str())
                     .and_then(|(_, neg_method)| Some(format!("{}.{}()", self.snip(&args[0])?, neg_method)))
             },
             _ => None,
diff --git a/clippy_lints/src/copies.rs b/clippy_lints/src/copies.rs
@@ -269,8 +269,8 @@ fn bindings<'a, 'tcx>(cx: &LateContext<'a, 'tcx>, pat: &Pat) -> HashMap<LocalInt
             PatKind::TupleStruct(_, ref pats, _) => for pat in pats {
                 bindings_impl(cx, pat, map);
             },
-            PatKind::Binding(_, _, ref ident, ref as_pat) => {
-                if let Entry::Vacant(v) = map.entry(ident.name.as_str()) {
+            PatKind::Binding(_, _, ident, ref as_pat) => {
+                if let Entry::Vacant(v) = map.entry(ident.as_str()) {
                     v.insert(cx.tables.pat_ty(pat));
                 }
                 if let Some(ref as_pat) = *as_pat {
diff --git a/clippy_lints/src/duration_subsec.rs b/clippy_lints/src/duration_subsec.rs
@@ -43,7 +43,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for DurationSubsec {
             if match_type(cx, walk_ptrs_ty(cx.tables.expr_ty(&args[0])), &paths::DURATION);
             if let Some((Constant::Int(divisor), _)) = constant(cx, cx.tables, right);
             then {
-                let suggested_fn = match (method_path.ident.name.as_str().as_ref(), divisor) {
+                let suggested_fn = match (method_path.ident.as_str().as_ref(), divisor) {
                     ("subsec_micros", 1_000) => "subsec_millis",
                     ("subsec_nanos", 1_000) => "subsec_micros",
                     ("subsec_nanos", 1_000_000) => "subsec_millis",
diff --git a/clippy_lints/src/enum_variants.rs b/clippy_lints/src/enum_variants.rs
@@ -121,7 +121,7 @@ impl LintPass for EnumVariantNames {
 }
 
 fn var2str(var: &Variant) -> LocalInternedString {
-    var.node.ident.name.as_str()
+    var.node.ident.as_str()
 }
 
 /// Returns the number of chars that match from the start
@@ -245,7 +245,7 @@ impl EarlyLintPass for EnumVariantNames {
     }
 
     fn check_item(&mut self, cx: &EarlyContext, item: &Item) {
-        let item_name = item.ident.name.as_str();
+        let item_name = item.ident.as_str();
         let item_name_chars = item_name.chars().count();
         let item_camel = to_camel_case(&item_name);
         if !in_macro(item.span) {
diff --git a/clippy_lints/src/identity_conversion.rs b/clippy_lints/src/identity_conversion.rs
@@ -56,7 +56,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for IdentityConversion {
             },
 
             ExprMethodCall(ref name, .., ref args) => {
-                if match_trait_method(cx, e, &paths::INTO[..]) && &*name.ident.name.as_str() == "into" {
+                if match_trait_method(cx, e, &paths::INTO[..]) && &*name.ident.as_str() == "into" {
                     let a = cx.tables.expr_ty(e);
                     let b = cx.tables.expr_ty(&args[0]);
                     if same_tys(cx, a, b) {
diff --git a/clippy_lints/src/let_if_seq.rs b/clippy_lints/src/let_if_seq.rs
@@ -67,7 +67,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for LetIfSeq {
                 if let Some(expr) = it.peek();
                 if let hir::StmtDecl(ref decl, _) = stmt.node;
                 if let hir::DeclLocal(ref decl) = decl.node;
-                if let hir::PatKind::Binding(mode, canonical_id, ref ident, None) = decl.pat.node;
+                if let hir::PatKind::Binding(mode, canonical_id, ident, None) = decl.pat.node;
                 if let hir::StmtExpr(ref if_, _) = expr.node;
                 if let hir::ExprIf(ref cond, ref then, ref else_) = if_.node;
                 if !used_in_expr(cx, canonical_id, cond);
diff --git a/clippy_lints/src/loops.rs b/clippy_lints/src/loops.rs
@@ -985,7 +985,7 @@ fn check_for_loop_range<'a, 'tcx>(
     }) = higher::range(cx, arg)
     {
         // the var must be a single name
-        if let PatKind::Binding(_, canonical_id, ref ident, _) = pat.node {
+        if let PatKind::Binding(_, canonical_id, ident, _) = pat.node {
             let mut visitor = VarVisitor {
                 cx,
                 var: canonical_id,
@@ -1206,7 +1206,7 @@ fn check_for_loop_arg(cx: &LateContext, pat: &Pat, arg: &Expr, expr: &Expr) {
     if let ExprMethodCall(ref method, _, ref args) = arg.node {
         // just the receiver, no arguments
         if args.len() == 1 {
-            let method_name = &*method.ident.name.as_str();
+            let method_name = &*method.ident.as_str();
             // check for looping over x.iter() or x.iter_mut(), could use &x or &mut x
             if method_name == "iter" || method_name == "iter_mut" {
                 if is_ref_iterable_type(cx, &args[0]) {
@@ -1520,7 +1520,7 @@ fn check_for_mutation(cx: &LateContext, body: &Expr, bound_ids: &[Option<NodeId>
 fn pat_is_wild<'tcx>(pat: &'tcx PatKind, body: &'tcx Expr) -> bool {
     match *pat {
         PatKind::Wild => true,
-        PatKind::Binding(_, _, ident, None) if ident.name.as_str().starts_with('_') => {
+        PatKind::Binding(_, _, ident, None) if ident.as_str().starts_with('_') => {
             let mut visitor = UsedVisitor {
                 var: ident.name,
                 used: false,
@@ -1933,7 +1933,7 @@ impl<'a, 'tcx> Visitor<'tcx> for InitializeVisitor<'a, 'tcx> {
         // Look for declarations of the variable
         if let DeclLocal(ref local) = decl.node {
             if local.pat.id == self.var_id {
-                if let PatKind::Binding(_, _, ref ident, _) = local.pat.node {
+                if let PatKind::Binding(_, _, ident, _) = local.pat.node {
                     self.name = Some(ident.name);
 
                     self.state = if let Some(ref init) = local.init {
diff --git a/clippy_lints/src/matches.rs b/clippy_lints/src/matches.rs
@@ -270,7 +270,7 @@ fn check_single_match_opt_like(cx: &LateContext, ex: &Expr, arms: &[Arm], expr:
             }
             print::to_string(print::NO_ANN, |s| s.print_qpath(path, false))
         },
-        PatKind::Binding(BindingAnnotation::Unannotated, _, ident, None) => ident.name.to_string(),
+        PatKind::Binding(BindingAnnotation::Unannotated, _, ident, None) => ident.to_string(),
         PatKind::Path(ref path) => print::to_string(print::NO_ANN, |s| s.print_qpath(path, false)),
         _ => return,
     };
@@ -552,7 +552,7 @@ fn is_ref_some_arm(arm: &Arm) -> Option<BindingAnnotation> {
     if_chain! {
         if let PatKind::TupleStruct(ref path, ref pats, _) = arm.pats[0].node;
         if pats.len() == 1 && match_qpath(path, &paths::OPTION_SOME);
-        if let PatKind::Binding(rb, _, ref ident, _) = pats[0].node;
+        if let PatKind::Binding(rb, _, ident, _) = pats[0].node;
         if rb == BindingAnnotation::Ref || rb == BindingAnnotation::RefMut;
         if let ExprCall(ref e, ref args) = remove_blocks(&arm.body).node;
         if let ExprPath(ref some_path) = e.node;
diff --git a/clippy_lints/src/methods.rs b/clippy_lints/src/methods.rs
@@ -771,8 +771,8 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Pass {
                     lint_unnecessary_fold(cx, expr, arglists[0]);
                 }
 
-                lint_or_fun_call(cx, expr, *method_span, &method_call.ident.name.as_str(), args);
-                lint_expect_fun_call(cx, expr, *method_span, &method_call.ident.name.as_str(), args);
+                lint_or_fun_call(cx, expr, *method_span, &method_call.ident.as_str(), args);
+                lint_expect_fun_call(cx, expr, *method_span, &method_call.ident.as_str(), args);
 
                 let self_ty = cx.tables.expr_ty_adjusted(&args[0]);
                 if args.len() == 1 && method_call.ident.name == "clone" {
@@ -890,7 +890,7 @@ fn lint_or_fun_call(cx: &LateContext, expr: &hir::Expr, method_span: Span, name:
 
         if name == "unwrap_or" {
             if let hir::ExprPath(ref qpath) = fun.node {
-                let path = &*last_path_segment(qpath).ident.name.as_str();
+                let path = &*last_path_segment(qpath).ident.as_str();
 
                 if ["default", "new"].contains(&path) {
                     let arg_ty = cx.tables.expr_ty(arg);
diff --git a/clippy_lints/src/misc.rs b/clippy_lints/src/misc.rs
@@ -379,7 +379,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Pass {
         }
         let binding = match expr.node {
             ExprPath(ref qpath) => {
-                let binding = last_path_segment(qpath).ident.name.as_str();
+                let binding = last_path_segment(qpath).ident.as_str();
                 if binding.starts_with('_') &&
                     !binding.starts_with("__") &&
                     binding != "_result" && // FIXME: #944
@@ -417,7 +417,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Pass {
     }
 
     fn check_pat(&mut self, cx: &LateContext<'a, 'tcx>, pat: &'tcx Pat) {
-        if let PatKind::Binding(_, _, ref ident, Some(ref right)) = pat.node {
+        if let PatKind::Binding(_, _, ident, Some(ref right)) = pat.node {
             if right.node == PatKind::Wild {
                 span_lint(
                     cx,
diff --git a/clippy_lints/src/misc_early.rs b/clippy_lints/src/misc_early.rs
@@ -190,7 +190,7 @@ impl EarlyLintPass for MiscEarly {
     fn check_generics(&mut self, cx: &EarlyContext, gen: &Generics) {
         for param in &gen.params {
             if let GenericParamKind::Type { .. } = param.kind {
-                let name = param.ident.name.as_str();
+                let name = param.ident.as_str();
                 if constants::BUILTIN_TYPES.contains(&&*name) {
                     span_lint(
                         cx,
@@ -268,7 +268,7 @@ impl EarlyLintPass for MiscEarly {
 
         for arg in &decl.inputs {
             if let PatKind::Ident(_, ident, None) = arg.pat.node {
-                let arg_name = ident.name.to_string();
+                let arg_name = ident.to_string();
 
                 if arg_name.starts_with('_') {
                     if let Some(correspondence) = registered_names.get(&arg_name[1..]) {
diff --git a/clippy_lints/src/mut_reference.rs b/clippy_lints/src/mut_reference.rs
@@ -48,7 +48,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for UnnecessaryMutPassed {
                 let def_id = cx.tables.type_dependent_defs()[e.hir_id].def_id();
                 let substs = cx.tables.node_substs(e.hir_id);
                 let method_type = cx.tcx.type_of(def_id).subst(cx.tcx, substs);
-                check_arguments(cx, arguments, method_type, &path.ident.name.as_str())
+                check_arguments(cx, arguments, method_type, &path.ident.as_str())
             },
             _ => (),
         }
diff --git a/clippy_lints/src/needless_pass_by_value.rs b/clippy_lints/src/needless_pass_by_value.rs
@@ -153,7 +153,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for NeedlessPassByValue {
             // Ignore `self`s.
             if idx == 0 {
                 if let PatKind::Binding(_, _, ident, ..) = arg.pat.node {
-                    if ident.name.as_str() == "self" {
+                    if ident.as_str() == "self" {
                         continue;
                     }
                 }
diff --git a/clippy_lints/src/open_options.rs b/clippy_lints/src/open_options.rs
@@ -87,7 +87,7 @@ fn get_open_options(cx: &LateContext, argument: &Expr, options: &mut Vec<(OpenOp
                 _ => Argument::Unknown,
             };
 
-            match &*path.ident.name.as_str() {
+            match &*path.ident.as_str() {
                 "create" => {
                     options.push((OpenOption::Create, argument_option));
                 },
diff --git a/clippy_lints/src/ranges.rs b/clippy_lints/src/ranges.rs
@@ -89,7 +89,7 @@ impl LintPass for Pass {
 impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Pass {
     fn check_expr(&mut self, cx: &LateContext<'a, 'tcx>, expr: &'tcx Expr) {
         if let ExprMethodCall(ref path, _, ref args) = expr.node {
-            let name = path.ident.name.as_str();
+            let name = path.ident.as_str();
 
             // Range with step_by(0).
             if name == "step_by" && args.len() == 2 && has_step_by(cx, &args[0]) {
diff --git a/clippy_lints/src/returns.rs b/clippy_lints/src/returns.rs
@@ -114,7 +114,7 @@ impl ReturnPass {
             if let Some(ref initexpr) = local.init;
             if let ast::PatKind::Ident(_, ident, _) = local.pat.node;
             if let ast::ExprKind::Path(_, ref path) = retexpr.node;
-            if match_path_ast(path, &[&ident.name.as_str()]);
+            if match_path_ast(path, &[&ident.as_str()]);
             if !in_external_macro(cx, initexpr.span);
             then {
                     span_note_and_lint(cx,
diff --git a/clippy_lints/src/serde_api.rs b/clippy_lints/src/serde_api.rs
@@ -36,7 +36,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Serde {
                     let mut seen_str = None;
                     let mut seen_string = None;
                     for item in items {
-                        match &*item.ident.name.as_str() {
+                        match &*item.ident.as_str() {
                             "visit_str" => seen_str = Some(item.span),
                             "visit_string" => seen_string = Some(item.span),
                             _ => {},
diff --git a/clippy_lints/src/shadow.rs b/clippy_lints/src/shadow.rs
@@ -164,7 +164,7 @@ fn check_pat<'a, 'tcx>(
 ) {
     // TODO: match more stuff / destructuring
     match pat.node {
-        PatKind::Binding(_, _, ref ident, ref inner) => {
+        PatKind::Binding(_, _, ident, ref inner) => {
             let name = ident.name;
             if is_binding(cx, pat.hir_id) {
                 let mut new_binding = true;
@@ -378,5 +378,5 @@ fn is_self_shadow(name: Name, expr: &Expr) -> bool {
 }
 
 fn path_eq_name(name: Name, path: &Path) -> bool {
-    !path.is_global() && path.segments.len() == 1 && path.segments[0].ident.name.as_str() == name.as_str()
+    !path.is_global() && path.segments.len() == 1 && path.segments[0].ident.as_str() == name.as_str()
 }
diff --git a/clippy_lints/src/swap.rs b/clippy_lints/src/swap.rs
@@ -64,7 +64,7 @@ fn check_manual_swap(cx: &LateContext, block: &Block) {
             if let StmtDecl(ref tmp, _) = w[0].node;
             if let DeclLocal(ref tmp) = tmp.node;
             if let Some(ref tmp_init) = tmp.init;
-            if let PatKind::Binding(_, _, ref ident, None) = tmp.pat.node;
+            if let PatKind::Binding(_, _, ident, None) = tmp.pat.node;
 
             // foo() = bar();
             if let StmtSemi(ref first, _) = w[1].node;
@@ -76,7 +76,7 @@ fn check_manual_swap(cx: &LateContext, block: &Block) {
             if let ExprPath(QPath::Resolved(None, ref rhs2)) = rhs2.node;
             if rhs2.segments.len() == 1;
 
-            if ident.name.as_str() == rhs2.segments[0].ident.name.as_str();
+            if ident.as_str() == rhs2.segments[0].ident.as_str();
             if SpanlessEq::new(cx).ignore_fn().eq_expr(tmp_init, lhs1);
             if SpanlessEq::new(cx).ignore_fn().eq_expr(rhs1, lhs2);
             then {
diff --git a/clippy_lints/src/unused_io_amount.rs b/clippy_lints/src/unused_io_amount.rs
@@ -57,7 +57,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for UnusedIoAmount {
                 }
             },
 
-            hir::ExprMethodCall(ref path, _, ref args) => match &*path.ident.name.as_str() {
+            hir::ExprMethodCall(ref path, _, ref args) => match &*path.ident.as_str() {
                 "expect" | "unwrap" | "unwrap_or" | "unwrap_or_else" => {
                     check_method_call(cx, &args[0], expr);
                 },
@@ -71,7 +71,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for UnusedIoAmount {
 
 fn check_method_call(cx: &LateContext, call: &hir::Expr, expr: &hir::Expr) {
     if let hir::ExprMethodCall(ref path, _, _) = call.node {
-        let symbol = &*path.ident.name.as_str();
+        let symbol = &*path.ident.as_str();
         if match_trait_method(cx, call, &paths::IO_READ) && symbol == "read" {
             span_lint(
                 cx,
diff --git a/clippy_lints/src/unused_label.rs b/clippy_lints/src/unused_label.rs
@@ -70,10 +70,10 @@ impl<'a, 'tcx: 'a> Visitor<'tcx> for UnusedLabelVisitor<'a, 'tcx> {
     fn visit_expr(&mut self, expr: &'tcx hir::Expr) {
         match expr.node {
             hir::ExprBreak(destination, _) | hir::ExprContinue(destination) => if let Some(label) = destination.label {
-                self.labels.remove(&label.ident.name.as_str());
+                self.labels.remove(&label.ident.as_str());
             },
             hir::ExprLoop(_, Some(label), _) | hir::ExprWhile(_, _, Some(label)) => {
-                self.labels.insert(label.ident.name.as_str(), expr.span);
+                self.labels.insert(label.ident.as_str(), expr.span);
             },
             _ => (),
         }
diff --git a/clippy_lints/src/unwrap.rs b/clippy_lints/src/unwrap.rs
@@ -95,7 +95,7 @@ fn collect_unwrap_info<'a, 'tcx: 'a>(
             if let Expr_::ExprPath(QPath::Resolved(None, path)) = &args[0].node;
             let ty = cx.tables.expr_ty(&args[0]);
             if match_type(cx, ty, &paths::OPTION) || match_type(cx, ty, &paths::RESULT);
-            let name = method_name.ident.name.as_str();
+            let name = method_name.ident.as_str();
             if ["is_some", "is_none", "is_ok", "is_err"].contains(&&*name);
             then {
                 assert!(args.len() == 1);
@@ -142,7 +142,7 @@ impl<'a, 'tcx: 'a> Visitor<'tcx> for UnwrappableVariablesVisitor<'a, 'tcx> {
             if_chain! {
                 if let Expr_::ExprMethodCall(ref method_name, _, ref args) = expr.node;
                 if let Expr_::ExprPath(QPath::Resolved(None, ref path)) = args[0].node;
-                if ["unwrap", "unwrap_err"].contains(&&*method_name.ident.name.as_str());
+                if ["unwrap", "unwrap_err"].contains(&&*method_name.ident.as_str());
                 let call_to_unwrap = method_name.ident.name == "unwrap";
                 if let Some(unwrappable) = self.unwrappables.iter()
                     .find(|u| u.ident.def == path.def);
diff --git a/clippy_lints/src/utils/author.rs b/clippy_lints/src/utils/author.rs
@@ -395,7 +395,7 @@ impl<'tcx> Visitor<'tcx> for PrintVisitor {
                 let obj_pat = self.next("object");
                 let field_name_pat = self.next("field_name");
                 println!("Field(ref {}, ref {}) = {};", obj_pat, field_name_pat, current);
-                println!("    if {}.node.as_str() == {:?}", field_name_pat, field_ident.name.as_str());
+                println!("    if {}.node.as_str() == {:?}", field_name_pat, field_ident.as_str());
                 self.current = obj_pat;
                 self.visit_expr(object);
             },
@@ -503,7 +503,7 @@ impl<'tcx> Visitor<'tcx> for PrintVisitor {
                 } else {
                     println!("Binding({}, _, {}, None) = {};", anno_pat, name_pat, current);
                 }
-                println!("    if {}.node.as_str() == \"{}\";", name_pat, ident.name.as_str());
+                println!("    if {}.node.as_str() == \"{}\";", name_pat, ident.as_str());
             }
             PatKind::Struct(ref path, ref fields, ignore) => {
                 let path_pat = self.next("path");
@@ -671,7 +671,7 @@ fn print_path(path: &QPath, first: &mut bool) {
             } else {
                 print!(", ");
             }
-            print!("{:?}", segment.ident.name.as_str());
+            print!("{:?}", segment.ident.as_str());
         },
         QPath::TypeRelative(ref ty, ref segment) => match ty.node {
             hir::Ty_::TyPath(ref inner_path) => {
@@ -681,7 +681,7 @@ fn print_path(path: &QPath, first: &mut bool) {
                 } else {
                     print!(", ");
                 }
-                print!("{:?}", segment.ident.name.as_str());
+                print!("{:?}", segment.ident.as_str());
             },
             ref other => print!("/* unimplemented: {:?}*/", other),
         },
diff --git a/clippy_lints/src/utils/hir_utils.rs b/clippy_lints/src/utils/hir_utils.rs
diff --git a/clippy_lints/src/utils/inspector.rs b/clippy_lints/src/utils/inspector.rs
diff --git a/clippy_lints/src/utils/internal_lints.rs b/clippy_lints/src/utils/internal_lints.rs
diff --git a/clippy_lints/src/utils/mod.rs b/clippy_lints/src/utils/mod.rs

Original file line number	Diff line number	Diff line change
`@@ -121,7 +121,7 @@ impl LintPass for EnumVariantNames {`
`121`	`121`	`}`
`122`	`122`
`123`	`123`	`fn var2str(var: &Variant) -> LocalInternedString {`
`124`		`- var.node.ident.name.as_str()`
	`124`	`+ var.node.ident.as_str()`
`125`	`125`	`}`
`126`	`126`
`127`	`127`	`/// Returns the number of chars that match from the start`
`@@ -245,7 +245,7 @@ impl EarlyLintPass for EnumVariantNames {`
`245`	`245`	`}`
`246`	`246`
`247`	`247`	`fn check_item(&mut self, cx: &EarlyContext, item: &Item) {`
`248`		`- let item_name = item.ident.name.as_str();`
	`248`	`+ let item_name = item.ident.as_str();`
`249`	`249`	`let item_name_chars = item_name.chars().count();`
`250`	`250`	`let item_camel = to_camel_case(&item_name);`
`251`	`251`	`if !in_macro(item.span) {`