Rustup

Author: mati865

clippy_lints/src/attrs.rs

@@ -195,13 +195,13 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for AttrPass {
 
     fn check_impl_item(&mut self, cx: &LateContext<'a, 'tcx>, item: &'tcx ImplItem) {
         if is_relevant_impl(cx.tcx, item) {
-            check_attrs(cx, item.span, item.name, &item.attrs)
+            check_attrs(cx, item.span, item.ident.name, &item.attrs)
         }
     }
 
     fn check_trait_item(&mut self, cx: &LateContext<'a, 'tcx>, item: &'tcx TraitItem) {
         if is_relevant_trait(cx.tcx, item) {
-            check_attrs(cx, item.span, item.name, &item.attrs)
+            check_attrs(cx, item.span, item.ident.name, &item.attrs)
         }
     }
 }

clippy_lints/src/blacklisted_name.rs

@@ -41,13 +41,13 @@ 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 self.blacklist.iter().any(|s| ident.node == *s) {
+        if let PatKind::Binding(_, _, ident, _) = pat.node {
+            if self.blacklist.iter().any(|s| ident.name == *s) {
                 span_lint(
                     cx,
                     BLACKLISTED_NAME,
                     ident.span,
-                    &format!("use of a blacklisted/placeholder name `{}`", ident.node),
+                    &format!("use of a blacklisted/placeholder name `{}`", ident.name),
                 );
             }
         }

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.name.as_str())
+                    .find(|&(a, _)| a == path.ident.as_str())
                     .and_then(|(_, neg_method)| Some(format!("{}.{}()", self.snip(&args[0])?, neg_method)))
             },
             _ => None,

clippy_lints/src/bytecount.rs

@@ -39,10 +39,10 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for ByteCount {
     fn check_expr(&mut self, cx: &LateContext, expr: &Expr) {
         if_chain! {
             if let ExprMethodCall(ref count, _, ref count_args) = expr.node;
-            if count.name == "count";
+            if count.ident.name == "count";
             if count_args.len() == 1;
             if let ExprMethodCall(ref filter, _, ref filter_args) = count_args[0].node;
-            if filter.name == "filter";
+            if filter.ident.name == "filter";
             if filter_args.len() == 2;
             if let ExprClosure(_, _, body_id, _, _) = filter_args[1].node;
             then {
@@ -68,7 +68,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for ByteCount {
                         }
                         let haystack = if let ExprMethodCall(ref path, _, ref args) =
                                 filter_args[0].node {
-                            let p = path.name;
+                            let p = path.ident.name;
                             if (p == "iter" || p == "iter_mut") && args.len() == 1 {
                                 &args[0]
                             } else {
@@ -104,7 +104,7 @@ fn get_path_name(expr: &Expr) -> Option<Name> {
         } else {
             None
         },
-        ExprPath(ref qpath) => single_segment_path(qpath).map(|ps| ps.name),
+        ExprPath(ref qpath) => single_segment_path(qpath).map(|ps| ps.ident.name),
         _ => None,
     }
 }

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.node.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 {

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.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",

clippy_lints/src/entry.rs

@@ -90,7 +90,7 @@ fn check_cond<'a, 'tcx, 'b>(
     if_chain! {
         if let ExprMethodCall(ref path, _, ref params) = check.node;
         if params.len() >= 2;
-        if path.name == "contains_key";
+        if path.ident.name == "contains_key";
         if let ExprAddrOf(_, ref key) = params[1].node;
         then {
             let map = &params[0];
@@ -125,7 +125,7 @@ impl<'a, 'tcx, 'b> Visitor<'tcx> for InsertVisitor<'a, 'tcx, 'b> {
         if_chain! {
             if let ExprMethodCall(ref path, _, ref params) = expr.node;
             if params.len() == 3;
-            if path.name == "insert";
+            if path.ident.name == "insert";
             if get_item_name(self.cx, self.map) == get_item_name(self.cx, &params[0]);
             if SpanlessEq::new(self.cx).eq_expr(self.key, &params[1]);
             then {

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) {

clippy_lints/src/eta_reduction.rs

@@ -78,7 +78,7 @@ fn check_closure(cx: &LateContext, expr: &Expr) {
                             // If it's a proper path, it can't be a local variable
                             return;
                         }
-                        if p.segments[0].name != ident.node {
+                        if p.segments[0].ident.name != ident.name {
                             // The two idents should be the same
                             return;
                         }

clippy_lints/src/explicit_write.rs

@@ -36,12 +36,12 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Pass {
         if_chain! {
             // match call to unwrap
             if let ExprMethodCall(ref unwrap_fun, _, ref unwrap_args) = expr.node;
-            if unwrap_fun.name == "unwrap";
+            if unwrap_fun.ident.name == "unwrap";
             // match call to write_fmt
             if unwrap_args.len() > 0;
             if let ExprMethodCall(ref write_fun, _, ref write_args) =
                 unwrap_args[0].node;
-            if write_fun.name == "write_fmt";
+            if write_fun.ident.name == "write_fmt";
             // match calls to std::io::stdout() / std::io::stderr ()
             if write_args.len() > 0;
             if let ExprCall(ref dest_fun, _) = write_args[0].node;