Rustup to *1.10.0-nightly (9c6904c 2016-05-18)*

mcarton · mcarton · commit b4502dae7bcc · 2016-05-19T23:14:34.000+02:00
diff --git a/src/blacklisted_name.rs b/src/blacklisted_name.rs
@@ -35,11 +35,11 @@ impl LintPass for BlackListedName {
 impl LateLintPass for BlackListedName {
     fn check_pat(&mut self, cx: &LateContext, pat: &Pat) {
         if let PatKind::Ident(_, ref ident, _) = pat.node {
-            if self.blacklist.iter().any(|s| s == &*ident.node.name.as_str()) {
+            if self.blacklist.iter().any(|s| s == &*ident.node.as_str()) {
                 span_lint(cx,
                           BLACKLISTED_NAME,
                           pat.span,
-                          &format!("use of a blacklisted/placeholder name `{}`", ident.node.name));
+                          &format!("use of a blacklisted/placeholder name `{}`", ident.node));
             }
         }
     }
diff --git a/src/copies.rs b/src/copies.rs
@@ -193,7 +193,7 @@ fn bindings<'a, 'tcx>(cx: &LateContext<'a, 'tcx>, pat: &Pat) -> HashMap<Interned
                 }
             }
             PatKind::Ident(_, ref ident, ref as_pat) => {
-                if let Entry::Vacant(v) = map.entry(ident.node.name.as_str()) {
+                if let Entry::Vacant(v) = map.entry(ident.node.as_str()) {
                     v.insert(cx.tcx.pat_ty(pat));
                 }
                 if let Some(ref as_pat) = *as_pat {
diff --git a/src/eta_reduction.rs b/src/eta_reduction.rs
@@ -77,7 +77,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].identifier != ident.node {
+                            if p.segments[0].name != ident.node {
                                 // The two idents should be the same
                                 return;
                             }
diff --git a/src/loops.rs b/src/loops.rs
@@ -286,7 +286,7 @@ impl LateLintPass for LoopsPass {
                 if let Some(lhs_constructor) = path.segments.last() {
                     if method_name.node.as_str() == "next" &&
                        match_trait_method(cx, match_expr, &paths::ITERATOR) &&
-                       lhs_constructor.identifier.name.as_str() == "Some" &&
+                       lhs_constructor.name.as_str() == "Some" &&
                        !is_iterator_used_after_while_let(cx, iter_expr) {
                         let iterator = snippet(cx, method_args[0].span, "_");
                         let loop_var = snippet(cx, pat_args[0].span, "_");
@@ -333,7 +333,7 @@ fn check_for_loop_range(cx: &LateContext, pat: &Pat, arg: &Expr, body: &Expr, ex
         if let PatKind::Ident(_, ref ident, _) = pat.node {
             let mut visitor = VarVisitor {
                 cx: cx,
-                var: ident.node.name,
+                var: ident.node,
                 indexed: HashMap::new(),
                 nonindex: false,
             };
@@ -378,9 +378,9 @@ fn check_for_loop_range(cx: &LateContext, pat: &Pat, arg: &Expr, body: &Expr, ex
                               expr.span,
                               &format!("the loop variable `{}` is used to index `{}`. Consider using `for ({}, \
                                         item) in {}.iter().enumerate(){}{}` or similar iterators",
-                                       ident.node.name,
+                                       ident.node,
                                        indexed,
-                                       ident.node.name,
+                                       ident.node,
                                        indexed,
                                        take,
                                        skip));
@@ -396,7 +396,7 @@ fn check_for_loop_range(cx: &LateContext, pat: &Pat, arg: &Expr, body: &Expr, ex
                               expr.span,
                               &format!("the loop variable `{}` is only used to index `{}`. \
                                         Consider using `for item in {}` or similar iterators",
-                                       ident.node.name,
+                                       ident.node,
                                        indexed,
                                        repl));
                 }
@@ -412,7 +412,7 @@ fn is_len_call(expr: &Expr, var: &Name) -> bool {
         method.node.as_str() == "len",
         let ExprPath(_, ref path) = len_args[0].node,
         path.segments.len() == 1,
-        &path.segments[0].identifier.name == var
+        &path.segments[0].name == var
     ], {
         return true;
     }}
@@ -613,7 +613,7 @@ fn check_for_loop_over_map_kv(cx: &LateContext, pat: &Pat, arg: &Expr, body: &Ex
 fn pat_is_wild(pat: &PatKind, body: &Expr) -> bool {
     match *pat {
         PatKind::Wild => true,
-        PatKind::Ident(_, ident, None) if ident.node.name.as_str().starts_with('_') => {
+        PatKind::Ident(_, ident, None) if ident.node.as_str().starts_with('_') => {
             let mut visitor = UsedVisitor {
                 var: ident.node,
                 used: false,
@@ -626,14 +626,14 @@ fn pat_is_wild(pat: &PatKind, body: &Expr) -> bool {
 }
 
 struct UsedVisitor {
-    var: Ident, // var to look for
+    var: ast::Name, // var to look for
     used: bool, // has the var been used otherwise?
 }
 
 impl<'a> Visitor<'a> for UsedVisitor {
     fn visit_expr(&mut self, expr: &Expr) {
         if let ExprPath(None, ref path) = expr.node {
-            if path.segments.len() == 1 && path.segments[0].identifier == self.var {
+            if path.segments.len() == 1 && path.segments[0].name == self.var {
                 self.used = true;
                 return;
             }
@@ -653,7 +653,7 @@ struct VarVisitor<'v, 't: 'v> {
 impl<'v, 't> Visitor<'v> for VarVisitor<'v, 't> {
     fn visit_expr(&mut self, expr: &'v Expr) {
         if let ExprPath(None, ref path) = expr.node {
-            if path.segments.len() == 1 && path.segments[0].identifier.name == self.var {
+            if path.segments.len() == 1 && path.segments[0].name == self.var {
                 // we are referencing our variable! now check if it's as an index
                 if_let_chain! {
                     [
@@ -667,11 +667,11 @@ impl<'v, 't> Visitor<'v> for VarVisitor<'v, 't> {
                             match def.base_def {
                                 Def::Local(..) | Def::Upvar(..) => {
                                     let extent = self.cx.tcx.region_maps.var_scope(def.base_def.var_id());
-                                    self.indexed.insert(seqvar.segments[0].identifier.name, Some(extent));
+                                    self.indexed.insert(seqvar.segments[0].name, Some(extent));
                                     return;  // no need to walk further
                                 }
                                 Def::Static(..) | Def::Const(..) => {
-                                    self.indexed.insert(seqvar.segments[0].identifier.name, None);
+                                    self.indexed.insert(seqvar.segments[0].name, None);
                                     return;  // no need to walk further
                                 }
                                 _ => (),
@@ -885,7 +885,7 @@ impl<'v, 't> Visitor<'v> for InitializeVisitor<'v, 't> {
         if let DeclLocal(ref local) = decl.node {
             if local.pat.id == self.var_id {
                 if let PatKind::Ident(_, ref ident, _) = local.pat.node {
-                    self.name = Some(ident.node.name);
+                    self.name = Some(ident.node);
 
                     self.state = if let Some(ref init) = local.init {
                         if is_integer_literal(init, 0) {
diff --git a/src/map_clone.rs b/src/map_clone.rs
@@ -1,5 +1,6 @@
 use rustc::lint::*;
 use rustc::hir::*;
+use syntax::ast;
 use utils::{is_adjusted, match_path, match_trait_method, match_type, paths, snippet,
             span_help_and_lint, walk_ptrs_ty, walk_ptrs_ty_depth};
 
@@ -52,7 +53,7 @@ impl LateLintPass for MapClonePass {
                                     if clone_call.node.as_str() == "clone" &&
                                         clone_args.len() == 1 &&
                                         match_trait_method(cx, closure_expr, &paths::CLONE_TRAIT) &&
-                                        expr_eq_ident(&clone_args[0], arg_ident)
+                                        expr_eq_name(&clone_args[0], arg_ident)
                                     {
                                         span_help_and_lint(cx, MAP_CLONE, expr.span, &format!(
                                             "you seem to be using .map() to clone the contents of an {}, consider \
@@ -82,11 +83,11 @@ impl LateLintPass for MapClonePass {
     }
 }
 
-fn expr_eq_ident(expr: &Expr, id: Ident) -> bool {
+fn expr_eq_name(expr: &Expr, id: ast::Name) -> bool {
     match expr.node {
         ExprPath(None, ref path) => {
             let arg_segment = [PathSegment {
-                                   identifier: id,
+                                   name: id,
                                    parameters: PathParameters::none(),
                                }];
             !path.global && path.segments[..] == arg_segment
@@ -105,18 +106,18 @@ fn get_type_name(cx: &LateContext, expr: &Expr, arg: &Expr) -> Option<&'static s
     }
 }
 
-fn get_arg_name(pat: &Pat) -> Option<Ident> {
+fn get_arg_name(pat: &Pat) -> Option<ast::Name> {
     match pat.node {
-        PatKind::Ident(_, ident, None) => Some(ident.node),
+        PatKind::Ident(_, name, None) => Some(name.node),
         PatKind::Ref(ref subpat, _) => get_arg_name(subpat),
         _ => None,
     }
 }
 
-fn only_derefs(cx: &LateContext, expr: &Expr, id: Ident) -> bool {
+fn only_derefs(cx: &LateContext, expr: &Expr, id: ast::Name) -> bool {
     match expr.node {
         ExprUnary(UnDeref, ref subexpr) if !is_adjusted(cx, subexpr) => only_derefs(cx, subexpr, id),
-        _ => expr_eq_ident(expr, id),
+        _ => expr_eq_name(expr, id),
     }
 }
 
diff --git a/src/methods.rs b/src/methods.rs
@@ -473,7 +473,6 @@ fn lint_or_fun_call(cx: &LateContext, expr: &hir::Expr, name: &str, args: &[P<hi
                 let path: &str = &path.segments
                                       .last()
                                       .expect("A path must have at least one segment")
-                                      .identifier
                                       .name
                                       .as_str();
 
@@ -811,7 +810,7 @@ fn lint_chars_next(cx: &LateContext, expr: &hir::Expr, chain: &hir::Expr, other:
         let hir::ExprCall(ref fun, ref arg_char) = other.node,
         arg_char.len() == 1,
         let hir::ExprPath(None, ref path) = fun.node,
-        path.segments.len() == 1 && path.segments[0].identifier.name.as_str() == "Some"
+        path.segments.len() == 1 && path.segments[0].name.as_str() == "Some"
     ], {
         let self_ty = walk_ptrs_ty(cx.tcx.expr_ty_adjusted(&args[0][0]));
 
diff --git a/src/misc.rs b/src/misc.rs
@@ -8,8 +8,10 @@ use rustc_const_eval::EvalHint::ExprTypeChecked;
 use rustc_const_eval::eval_const_expr_partial;
 use syntax::codemap::{Span, Spanned, ExpnFormat};
 use syntax::ptr::P;
-use utils::{get_item_name, match_path, snippet, get_parent_expr, span_lint};
-use utils::{span_lint_and_then, walk_ptrs_ty, is_integer_literal, implements_trait};
+use utils::{
+    get_item_name, get_parent_expr, implements_trait, is_integer_literal, match_path, snippet,
+    span_lint, span_lint_and_then, walk_ptrs_ty
+};
 
 /// **What it does:** This lint checks for function arguments and let bindings denoted as `ref`.
 ///
@@ -118,7 +120,7 @@ impl LateLintPass for CmpNan {
 
 fn check_nan(cx: &LateContext, path: &Path, span: Span) {
     path.segments.last().map(|seg| {
-        if seg.identifier.name.as_str() == "NAN" {
+        if seg.name.as_str() == "NAN" {
             span_lint(cx,
                       CMP_NAN,
                       span,
@@ -350,8 +352,8 @@ impl LateLintPass for PatternPass {
                           REDUNDANT_PATTERN,
                           pat.span,
                           &format!("the `{} @ _` pattern can be written as just `{}`",
-                                   ident.node.name,
-                                   ident.node.name));
+                                   ident.node,
+                                   ident.node));
             }
         }
     }
@@ -387,32 +389,40 @@ impl LateLintPass for UsedUnderscoreBinding {
     #[cfg_attr(rustfmt, rustfmt_skip)]
     fn check_expr(&mut self, cx: &LateContext, expr: &Expr) {
         if in_attributes_expansion(cx, expr) {
-    // Don't lint things expanded by #[derive(...)], etc
+            // Don't lint things expanded by #[derive(...)], etc
             return;
         }
-        let needs_lint = match expr.node {
+        let binding = match expr.node {
             ExprPath(_, ref path) => {
-                let ident = path.segments
+                let segment = path.segments
                                 .last()
                                 .expect("path should always have at least one segment")
-                                .identifier;
-                ident.name.as_str().starts_with('_') &&
-                !ident.name.as_str().starts_with("__") &&
-                ident.name != ident.unhygienic_name &&
-                is_used(cx, expr) // not in bang macro
+                                .name;
+                if segment.as_str().starts_with('_') &&
+                   !segment.as_str().starts_with("__") &&
+                   segment != segment.unhygienize() && // not in bang macro
+                   is_used(cx, expr) {
+                    Some(segment.as_str())
+                } else {
+                    None
+                }
             }
             ExprField(_, spanned) => {
                 let name = spanned.node.as_str();
-                name.starts_with('_') && !name.starts_with("__")
+                if name.starts_with('_') && !name.starts_with("__") {
+                    Some(name)
+                } else {
+                    None
+                }
             }
-            _ => false,
+            _ => None,
         };
-        if needs_lint {
+        if let Some(binding) = binding {
             span_lint(cx,
                       USED_UNDERSCORE_BINDING,
                       expr.span,
-                      "used binding which is prefixed with an underscore. A leading underscore signals that a \
-                       binding will not be used.");
+                      &format!("used binding `{}` which is prefixed with an underscore. A leading \
+                                underscore signals that a binding will not be used.", binding));
         }
     }
 }
@@ -431,8 +441,8 @@ fn is_used(cx: &LateContext, expr: &Expr) -> bool {
     }
 }
 
-/// Test whether an expression is in a macro expansion (e.g. something generated by #[derive(...)]
-/// or the like)
+/// Test whether an expression is in a macro expansion (e.g. something generated by
+/// `#[derive(...)`] or the like).
 fn in_attributes_expansion(cx: &LateContext, expr: &Expr) -> bool {
     cx.sess().codemap().with_expn_info(expr.span.expn_id, |info_opt| {
         info_opt.map_or(false, |info| {
diff --git a/src/overflow_check_conditional.rs b/src/overflow_check_conditional.rs
@@ -31,7 +31,7 @@ impl LateLintPass for OverflowCheckConditional {
         let Expr_::ExprPath(_,ref path1) = ident1.node,
         let Expr_::ExprPath(_, ref path2) = ident2.node,
         let Expr_::ExprPath(_, ref path3) = second.node,
-        (&path1.segments[0]).identifier == (&path3.segments[0]).identifier || (&path2.segments[0]).identifier == (&path3.segments[0]).identifier,
+        &path1.segments[0] == &path3.segments[0] || &path2.segments[0] == &path3.segments[0],
         cx.tcx.expr_ty(ident1).is_integral(),
         cx.tcx.expr_ty(ident2).is_integral()
         ], {
@@ -53,7 +53,7 @@ impl LateLintPass for OverflowCheckConditional {
         let Expr_::ExprPath(_,ref path1) = ident1.node,
         let Expr_::ExprPath(_, ref path2) = ident2.node,
         let Expr_::ExprPath(_, ref path3) = first.node,
-        (&path1.segments[0]).identifier == (&path3.segments[0]).identifier || (&path2.segments[0]).identifier == (&path3.segments[0]).identifier,
+        &path1.segments[0] == &path3.segments[0] || &path2.segments[0] == &path3.segments[0],
         cx.tcx.expr_ty(ident1).is_integral(),
         cx.tcx.expr_ty(ident2).is_integral()
         ], {
diff --git a/src/shadow.rs b/src/shadow.rs
@@ -66,7 +66,7 @@ fn check_fn(cx: &LateContext, decl: &FnDecl, block: &Block) {
     let mut bindings = Vec::new();
     for arg in &decl.inputs {
         if let PatKind::Ident(_, ident, _) = arg.pat.node {
-            bindings.push((ident.node.unhygienic_name, ident.span))
+            bindings.push((ident.node, ident.span))
         }
     }
     check_block(cx, block, &mut bindings);
@@ -120,7 +120,7 @@ fn check_pat(cx: &LateContext, pat: &Pat, init: &Option<&Expr>, span: Span, bind
     // TODO: match more stuff / destructuring
     match pat.node {
         PatKind::Ident(_, ref ident, ref inner) => {
-            let name = ident.node.unhygienic_name;
+            let name = ident.node;
             if is_binding(cx, pat) {
                 let mut new_binding = true;
                 for tup in bindings.iter_mut() {
@@ -326,7 +326,7 @@ fn is_self_shadow(name: Name, expr: &Expr) -> bool {
 }
 
 fn path_eq_name(name: Name, path: &Path) -> bool {
-    !path.global && path.segments.len() == 1 && path.segments[0].identifier.unhygienic_name == name
+    !path.global && path.segments.len() == 1 && path.segments[0].name == name
 }
 
 struct ContainsSelf {
@@ -335,8 +335,8 @@ struct ContainsSelf {
 }
 
 impl<'v> Visitor<'v> for ContainsSelf {
-    fn visit_ident(&mut self, _: Span, ident: Ident) {
-        if self.name == ident.unhygienic_name {
+    fn visit_name(&mut self, _: Span, name: Name) {
+        if self.name == name {
             self.result = true;
         }
     }
diff --git a/src/swap.rs b/src/swap.rs
@@ -75,7 +75,7 @@ fn check_manual_swap(cx: &LateContext, block: &Block) {
             let ExprPath(None, ref rhs2) = rhs2.node,
             rhs2.segments.len() == 1,
 
-            tmp_name.node.name.as_str() == rhs2.segments[0].identifier.name.as_str(),
+            tmp_name.node.as_str() == rhs2.segments[0].name.as_str(),
             SpanlessEq::new(cx).ignore_fn().eq_expr(tmp_init, lhs1),
             SpanlessEq::new(cx).ignore_fn().eq_expr(rhs1, lhs2)
         ], {
diff --git a/src/unsafe_removed_from_name.rs b/src/unsafe_removed_from_name.rs
@@ -41,7 +41,7 @@ impl LateLintPass for UnsafeNameRemoval {
                         path.segments
                             .last()
                             .expect("use paths cannot be empty")
-                            .identifier.name,
+                            .name,
                         *name,
                         cx, &item.span
                         );
diff --git a/src/unused_label.rs b/src/unused_label.rs
@@ -65,10 +65,10 @@ impl<'v> Visitor<'v> for UnusedLabelVisitor {
     fn visit_expr(&mut self, expr: &hir::Expr) {
         match expr.node {
             hir::ExprBreak(Some(label)) | hir::ExprAgain(Some(label)) => {
-                self.labels.remove(&label.node.name.as_str());
+                self.labels.remove(&label.node.as_str());
             }
             hir::ExprLoop(_, Some(label)) | hir::ExprWhile(_, _, Some(label)) => {
-                self.labels.insert(label.name.as_str(), expr.span);
+                self.labels.insert(label.as_str(), expr.span);
             }
             _ => (),
         }
diff --git a/src/utils/hir.rs b/src/utils/hir.rs
diff --git a/src/utils/mod.rs b/src/utils/mod.rs

Original file line number	Diff line number	Diff line change
`@@ -35,11 +35,11 @@ impl LintPass for BlackListedName {`
`35`	`35`	`impl LateLintPass for BlackListedName {`
`36`	`36`	`fn check_pat(&mut self, cx: &LateContext, pat: &Pat) {`
`37`	`37`	`if let PatKind::Ident(_, ref ident, _) = pat.node {`
`38`		`- if self.blacklist.iter().any(\|s\| s == &*ident.node.name.as_str()) {`
	`38`	`+ if self.blacklist.iter().any(\|s\| s == &*ident.node.as_str()) {`
`39`	`39`	`span_lint(cx,`
`40`	`40`	`BLACKLISTED_NAME,`
`41`	`41`	`pat.span,`
`42`		- &format!("use of a blacklisted/placeholder name `{}`", ident.node.name));
	`42`	+ &format!("use of a blacklisted/placeholder name `{}`", ident.node));
`43`	`43`	`}`
`44`	`44`	`}`
`45`	`45`	`}`
Original file line number	Diff line number	Diff line change
`@@ -193,7 +193,7 @@ fn bindings<'a, 'tcx>(cx: &LateContext<'a, 'tcx>, pat: &Pat) -> HashMap<Interned`
`193`	`193`	`}`
`194`	`194`	`}`
`195`	`195`	`PatKind::Ident(_, ref ident, ref as_pat) => {`
`196`		`- if let Entry::Vacant(v) = map.entry(ident.node.name.as_str()) {`
	`196`	`+ if let Entry::Vacant(v) = map.entry(ident.node.as_str()) {`
`197`	`197`	`v.insert(cx.tcx.pat_ty(pat));`
`198`	`198`	`}`
`199`	`199`	`if let Some(ref as_pat) = *as_pat {`
Original file line number	Diff line number	Diff line change
`@@ -77,7 +77,7 @@ fn check_closure(cx: &LateContext, expr: &Expr) {`
`77`	`77`	`// If it's a proper path, it can't be a local variable`
`78`	`78`	`return;`
`79`	`79`	`}`
`80`		`- if p.segments[0].identifier != ident.node {`
	`80`	`+ if p.segments[0].name != ident.node {`
`81`	`81`	`// The two idents should be the same`
`82`	`82`	`return;`
`83`	`83`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1,5 +1,6 @@`
`1`	`1`	`use rustc::lint::*;`
`2`	`2`	`use rustc::hir::*;`
	`3`	`+use syntax::ast;`
`3`	`4`	`use utils::{is_adjusted, match_path, match_trait_method, match_type, paths, snippet,`
`4`	`5`	`span_help_and_lint, walk_ptrs_ty, walk_ptrs_ty_depth};`
`5`	`6`
`@@ -52,7 +53,7 @@ impl LateLintPass for MapClonePass {`
`52`	`53`	`if clone_call.node.as_str() == "clone" &&`
`53`	`54`	`clone_args.len() == 1 &&`
`54`	`55`	`match_trait_method(cx, closure_expr, &paths::CLONE_TRAIT) &&`
`55`		`- expr_eq_ident(&clone_args[0], arg_ident)`
	`56`	`+ expr_eq_name(&clone_args[0], arg_ident)`
`56`	`57`	`{`
`57`	`58`	`span_help_and_lint(cx, MAP_CLONE, expr.span, &format!(`
`58`	`59`	`"you seem to be using .map() to clone the contents of an {}, consider \`
`@@ -82,11 +83,11 @@ impl LateLintPass for MapClonePass {`
`82`	`83`	`}`
`83`	`84`	`}`
`84`	`85`
`85`		`-fn expr_eq_ident(expr: &Expr, id: Ident) -> bool {`
	`86`	`+fn expr_eq_name(expr: &Expr, id: ast::Name) -> bool {`
`86`	`87`	`match expr.node {`
`87`	`88`	`ExprPath(None, ref path) => {`
`88`	`89`	`let arg_segment = [PathSegment {`
`89`		`- identifier: id,`
	`90`	`+ name: id,`
`90`	`91`	`parameters: PathParameters::none(),`
`91`	`92`	`}];`
`92`	`93`	`!path.global && path.segments[..] == arg_segment`
`@@ -105,18 +106,18 @@ fn get_type_name(cx: &LateContext, expr: &Expr, arg: &Expr) -> Option<&'static s`
`105`	`106`	`}`
`106`	`107`	`}`
`107`	`108`
`108`		`-fn get_arg_name(pat: &Pat) -> Option<Ident> {`
	`109`	`+fn get_arg_name(pat: &Pat) -> Option<ast::Name> {`
`109`	`110`	`match pat.node {`
`110`		`- PatKind::Ident(_, ident, None) => Some(ident.node),`
	`111`	`+ PatKind::Ident(_, name, None) => Some(name.node),`
`111`	`112`	`PatKind::Ref(ref subpat, _) => get_arg_name(subpat),`
`112`	`113`	`_ => None,`
`113`	`114`	`}`
`114`	`115`	`}`
`115`	`116`
`116`		`-fn only_derefs(cx: &LateContext, expr: &Expr, id: Ident) -> bool {`
	`117`	`+fn only_derefs(cx: &LateContext, expr: &Expr, id: ast::Name) -> bool {`
`117`	`118`	`match expr.node {`
`118`	`119`	`ExprUnary(UnDeref, ref subexpr) if !is_adjusted(cx, subexpr) => only_derefs(cx, subexpr, id),`
`119`		`- _ => expr_eq_ident(expr, id),`
	`120`	`+ _ => expr_eq_name(expr, id),`
`120`	`121`	`}`
`121`	`122`	`}`
`122`	`123`
Original file line number	Diff line number	Diff line change
`@@ -66,7 +66,7 @@ fn check_fn(cx: &LateContext, decl: &FnDecl, block: &Block) {`
`66`	`66`	`let mut bindings = Vec::new();`
`67`	`67`	`for arg in &decl.inputs {`
`68`	`68`	`if let PatKind::Ident(_, ident, _) = arg.pat.node {`
`69`		`- bindings.push((ident.node.unhygienic_name, ident.span))`
	`69`	`+ bindings.push((ident.node, ident.span))`
`70`	`70`	`}`
`71`	`71`	`}`
`72`	`72`	`check_block(cx, block, &mut bindings);`
`@@ -120,7 +120,7 @@ fn check_pat(cx: &LateContext, pat: &Pat, init: &Option<&Expr>, span: Span, bind`
`120`	`120`	`// TODO: match more stuff / destructuring`
`121`	`121`	`match pat.node {`
`122`	`122`	`PatKind::Ident(_, ref ident, ref inner) => {`
`123`		`- let name = ident.node.unhygienic_name;`
	`123`	`+ let name = ident.node;`
`124`	`124`	`if is_binding(cx, pat) {`
`125`	`125`	`let mut new_binding = true;`
`126`	`126`	`for tup in bindings.iter_mut() {`
`@@ -326,7 +326,7 @@ fn is_self_shadow(name: Name, expr: &Expr) -> bool {`
`326`	`326`	`}`
`327`	`327`
`328`	`328`	`fn path_eq_name(name: Name, path: &Path) -> bool {`
`329`		`- !path.global && path.segments.len() == 1 && path.segments[0].identifier.unhygienic_name == name`
	`329`	`+ !path.global && path.segments.len() == 1 && path.segments[0].name == name`
`330`	`330`	`}`
`331`	`331`
`332`	`332`	`struct ContainsSelf {`
`@@ -335,8 +335,8 @@ struct ContainsSelf {`
`335`	`335`	`}`
`336`	`336`
`337`	`337`	`impl<'v> Visitor<'v> for ContainsSelf {`
`338`		`- fn visit_ident(&mut self, _: Span, ident: Ident) {`
`339`		`- if self.name == ident.unhygienic_name {`
	`338`	`+ fn visit_name(&mut self, _: Span, name: Name) {`
	`339`	`+ if self.name == name {`
`340`	`340`	`self.result = true;`
`341`	`341`	`}`
`342`	`342`	`}`
Original file line number	Diff line number	Diff line change
`@@ -65,10 +65,10 @@ impl<'v> Visitor<'v> for UnusedLabelVisitor {`
`65`	`65`	`fn visit_expr(&mut self, expr: &hir::Expr) {`
`66`	`66`	`match expr.node {`
`67`	`67`	`hir::ExprBreak(Some(label)) \| hir::ExprAgain(Some(label)) => {`
`68`		`- self.labels.remove(&label.node.name.as_str());`
	`68`	`+ self.labels.remove(&label.node.as_str());`
`69`	`69`	`}`
`70`	`70`	`hir::ExprLoop(_, Some(label)) \| hir::ExprWhile(_, _, Some(label)) => {`
`71`		`- self.labels.insert(label.name.as_str(), expr.span);`
	`71`	`+ self.labels.insert(label.as_str(), expr.span);`
`72`	`72`	`}`
`73`	`73`	`_ => (),`
`74`	`74`	`}`