Auto merge of #52911 - Mark-Simulacrum:visibility-hirid, r=oli-obk

bors · bors · commit e90dc6f80d76 · 2018-08-07T19:10:17.000Z
Add HirId to VisibilityKind::Restricted

I'm not confident that these changes are correct -- mostly just tried to copy previous PRs.

Specifically, it's unclear to me if/how to remove the NodeId now that we have HirIds in more structs; is that a all-at-once change that'll happen later?
diff --git a/src/librustc/hir/intravisit.rs b/src/librustc/hir/intravisit.rs
@@ -353,10 +353,10 @@ pub trait Visitor<'v> : Sized {
     fn visit_lifetime(&mut self, lifetime: &'v Lifetime) {
         walk_lifetime(self, lifetime)
     }
-    fn visit_qpath(&mut self, qpath: &'v QPath, id: NodeId, span: Span) {
+    fn visit_qpath(&mut self, qpath: &'v QPath, id: HirId, span: Span) {
         walk_qpath(self, qpath, id, span)
     }
-    fn visit_path(&mut self, path: &'v Path, _id: NodeId) {
+    fn visit_path(&mut self, path: &'v Path, _id: HirId) {
         walk_path(self, path)
     }
     fn visit_path_segment(&mut self, path_span: Span, path_segment: &'v PathSegment) {
@@ -456,7 +456,7 @@ pub fn walk_trait_ref<'v, V>(visitor: &mut V, trait_ref: &'v TraitRef)
     where V: Visitor<'v>
 {
     visitor.visit_id(trait_ref.ref_id);
-    visitor.visit_path(&trait_ref.path, trait_ref.ref_id)
+    visitor.visit_path(&trait_ref.path, trait_ref.hir_ref_id)
 }
 
 pub fn walk_item<'v, V: Visitor<'v>>(visitor: &mut V, item: &'v Item) {
@@ -471,7 +471,7 @@ pub fn walk_item<'v, V: Visitor<'v>>(visitor: &mut V, item: &'v Item) {
         }
         ItemKind::Use(ref path, _) => {
             visitor.visit_id(item.id);
-            visitor.visit_path(path, item.id);
+            visitor.visit_path(path, item.hir_id);
         }
         ItemKind::Static(ref typ, _, body) |
         ItemKind::Const(ref typ, body) => {
@@ -602,7 +602,7 @@ pub fn walk_ty<'v, V: Visitor<'v>>(visitor: &mut V, typ: &'v Ty) {
             visitor.visit_fn_decl(&function_declaration.decl);
         }
         TyKind::Path(ref qpath) => {
-            visitor.visit_qpath(qpath, typ.id, typ.span);
+            visitor.visit_qpath(qpath, typ.hir_id, typ.span);
         }
         TyKind::Array(ref ty, ref length) => {
             visitor.visit_ty(ty);
@@ -621,7 +621,7 @@ pub fn walk_ty<'v, V: Visitor<'v>>(visitor: &mut V, typ: &'v Ty) {
     }
 }
 
-pub fn walk_qpath<'v, V: Visitor<'v>>(visitor: &mut V, qpath: &'v QPath, id: NodeId, span: Span) {
+pub fn walk_qpath<'v, V: Visitor<'v>>(visitor: &mut V, qpath: &'v QPath, id: HirId, span: Span) {
     match *qpath {
         QPath::Resolved(ref maybe_qself, ref path) => {
             if let Some(ref qself) = *maybe_qself {
@@ -670,14 +670,14 @@ pub fn walk_pat<'v, V: Visitor<'v>>(visitor: &mut V, pattern: &'v Pat) {
     visitor.visit_id(pattern.id);
     match pattern.node {
         PatKind::TupleStruct(ref qpath, ref children, _) => {
-            visitor.visit_qpath(qpath, pattern.id, pattern.span);
+            visitor.visit_qpath(qpath, pattern.hir_id, pattern.span);
             walk_list!(visitor, visit_pat, children);
         }
         PatKind::Path(ref qpath) => {
-            visitor.visit_qpath(qpath, pattern.id, pattern.span);
+            visitor.visit_qpath(qpath, pattern.hir_id, pattern.span);
         }
         PatKind::Struct(ref qpath, ref fields, _) => {
-            visitor.visit_qpath(qpath, pattern.id, pattern.span);
+            visitor.visit_qpath(qpath, pattern.hir_id, pattern.span);
             for field in fields {
                 visitor.visit_id(field.node.id);
                 visitor.visit_ident(field.node.ident);
@@ -985,7 +985,7 @@ pub fn walk_expr<'v, V: Visitor<'v>>(visitor: &mut V, expression: &'v Expr) {
             visitor.visit_anon_const(count)
         }
         ExprKind::Struct(ref qpath, ref fields, ref optional_base) => {
-            visitor.visit_qpath(qpath, expression.id, expression.span);
+            visitor.visit_qpath(qpath, expression.hir_id, expression.span);
             for field in fields {
                 visitor.visit_id(field.id);
                 visitor.visit_ident(field.ident);
@@ -1062,7 +1062,7 @@ pub fn walk_expr<'v, V: Visitor<'v>>(visitor: &mut V, expression: &'v Expr) {
             visitor.visit_expr(index_expression)
         }
         ExprKind::Path(ref qpath) => {
-            visitor.visit_qpath(qpath, expression.id, expression.span);
+            visitor.visit_qpath(qpath, expression.hir_id, expression.span);
         }
         ExprKind::Break(ref destination, ref opt_expr) => {
             if let Some(ref label) = destination.label {
@@ -1108,9 +1108,9 @@ pub fn walk_arm<'v, V: Visitor<'v>>(visitor: &mut V, arm: &'v Arm) {
 }
 
 pub fn walk_vis<'v, V: Visitor<'v>>(visitor: &mut V, vis: &'v Visibility) {
-    if let VisibilityKind::Restricted { ref path, id } = vis.node {
+    if let VisibilityKind::Restricted { ref path, id, hir_id } = vis.node {
         visitor.visit_id(id);
-        visitor.visit_path(path, id)
+        visitor.visit_path(path, hir_id)
     }
 }
 
diff --git a/src/librustc/hir/lowering.rs b/src/librustc/hir/lowering.rs
@@ -2155,12 +2155,14 @@ impl<'a> LoweringContext<'a> {
             let future_path =
                 this.std_path(span, &["future", "Future"], Some(future_params), false);
 
+            let LoweredNodeId { node_id, hir_id } = this.next_id();
             let mut bounds = vec![
                 hir::GenericBound::Trait(
                     hir::PolyTraitRef {
                         trait_ref: hir::TraitRef {
                             path: future_path,
-                            ref_id: this.next_id().node_id,
+                            ref_id: node_id,
+                            hir_ref_id: hir_id,
                         },
                         bound_generic_params: hir_vec![],
                         span,
@@ -2482,9 +2484,11 @@ impl<'a> LoweringContext<'a> {
             hir::QPath::Resolved(None, path) => path.and_then(|path| path),
             qpath => bug!("lower_trait_ref: unexpected QPath `{:?}`", qpath),
         };
+        let LoweredNodeId { node_id, hir_id } = self.lower_node_id(p.ref_id);
         hir::TraitRef {
             path,
-            ref_id: self.lower_node_id(p.ref_id).node_id,
+            ref_id: node_id,
+            hir_ref_id: hir_id,
         }
     }
 
@@ -2843,11 +2847,13 @@ impl<'a> LoweringContext<'a> {
                             hir::VisibilityKind::Public => hir::VisibilityKind::Public,
                             hir::VisibilityKind::Crate(sugar) => hir::VisibilityKind::Crate(sugar),
                             hir::VisibilityKind::Inherited => hir::VisibilityKind::Inherited,
-                            hir::VisibilityKind::Restricted { ref path, id: _ } => {
+                            hir::VisibilityKind::Restricted { ref path, id: _, hir_id: _ } => {
+                                let id = this.next_id();
                                 hir::VisibilityKind::Restricted {
                                     path: path.clone(),
                                     // We are allocating a new NodeId here
-                                    id: this.next_id().node_id,
+                                    id: id.node_id,
+                                    hir_id: id.hir_id,
                                 }
                             }
                         };
@@ -2916,11 +2922,13 @@ impl<'a> LoweringContext<'a> {
                             hir::VisibilityKind::Public => hir::VisibilityKind::Public,
                             hir::VisibilityKind::Crate(sugar) => hir::VisibilityKind::Crate(sugar),
                             hir::VisibilityKind::Inherited => hir::VisibilityKind::Inherited,
-                            hir::VisibilityKind::Restricted { ref path, id: _ } => {
+                            hir::VisibilityKind::Restricted { ref path, id: _, hir_id: _ } => {
+                                let id = this.next_id();
                                 hir::VisibilityKind::Restricted {
                                     path: path.clone(),
                                     // We are allocating a new NodeId here
-                                    id: this.next_id().node_id,
+                                    id: id.node_id,
+                                    hir_id: id.hir_id,
                                 }
                             }
                         };
@@ -4350,13 +4358,17 @@ impl<'a> LoweringContext<'a> {
         let node = match v.node {
             VisibilityKind::Public => hir::VisibilityKind::Public,
             VisibilityKind::Crate(sugar) => hir::VisibilityKind::Crate(sugar),
-            VisibilityKind::Restricted { ref path, id } => hir::VisibilityKind::Restricted {
-                path: P(self.lower_path(id, path, ParamMode::Explicit)),
-                id: if let Some(owner) = explicit_owner {
-                    self.lower_node_id_with_owner(id, owner).node_id
+            VisibilityKind::Restricted { ref path, id } => {
+                let lowered_id = if let Some(owner) = explicit_owner {
+                    self.lower_node_id_with_owner(id, owner)
                 } else {
-                    self.lower_node_id(id).node_id
-                },
+                    self.lower_node_id(id)
+                };
+                hir::VisibilityKind::Restricted {
+                    path: P(self.lower_path(id, path, ParamMode::Explicit)),
+                    id: lowered_id.node_id,
+                    hir_id: lowered_id.hir_id,
+                }
             },
             VisibilityKind::Inherited => hir::VisibilityKind::Inherited,
         };
@@ -4675,6 +4687,7 @@ impl<'a> LoweringContext<'a> {
                         trait_ref: hir::TraitRef {
                             path: path.and_then(|path| path),
                             ref_id: id.node_id,
+                            hir_ref_id: id.hir_id,
                         },
                         span,
                     };
diff --git a/src/librustc/hir/mod.rs b/src/librustc/hir/mod.rs
@@ -1912,6 +1912,7 @@ pub enum UseKind {
 pub struct TraitRef {
     pub path: Path,
     pub ref_id: NodeId,
+    pub hir_ref_id: HirId,
 }
 
 #[derive(Clone, RustcEncodable, RustcDecodable, Debug)]
@@ -1931,7 +1932,7 @@ pub type Visibility = Spanned<VisibilityKind>;
 pub enum VisibilityKind {
     Public,
     Crate(CrateSugar),
-    Restricted { path: P<Path>, id: NodeId },
+    Restricted { path: P<Path>, id: NodeId, hir_id: HirId },
     Inherited,
 }
 
diff --git a/src/librustc/ich/impls_hir.rs b/src/librustc/ich/impls_hir.rs
@@ -360,6 +360,7 @@ impl_stable_hash_for!(enum hir::FunctionRetTy {
 impl_stable_hash_for!(struct hir::TraitRef {
     // Don't hash the ref_id. It is tracked via the thing it is used to access
     ref_id -> _,
+    hir_ref_id -> _,
     path,
 });
 
@@ -723,9 +724,10 @@ impl<'a> HashStable<StableHashingContext<'a>> for hir::VisibilityKind {
             hir::VisibilityKind::Crate(sugar) => {
                 sugar.hash_stable(hcx, hasher);
             }
-            hir::VisibilityKind::Restricted { ref path, id } => {
+            hir::VisibilityKind::Restricted { ref path, id, hir_id } => {
                 hcx.with_node_id_hashing_mode(NodeIdHashingMode::HashDefPath, |hcx| {
                     id.hash_stable(hcx, hasher);
+                    hir_id.hash_stable(hcx, hasher);
                 });
                 path.hash_stable(hcx, hasher);
             }
diff --git a/src/librustc/lint/context.rs b/src/librustc/lint/context.rs
@@ -869,7 +869,7 @@ impl<'a, 'tcx> hir_visit::Visitor<'tcx> for LateContext<'a, 'tcx> {
         hir_visit::walk_lifetime(self, lt);
     }
 
-    fn visit_path(&mut self, p: &'tcx hir::Path, id: ast::NodeId) {
+    fn visit_path(&mut self, p: &'tcx hir::Path, id: hir::HirId) {
         run_lints!(self, check_path, p, id);
         hir_visit::walk_path(self, p);
     }
diff --git a/src/librustc/lint/mod.rs b/src/librustc/lint/mod.rs
@@ -242,7 +242,7 @@ macro_rules! late_lint_methods {
             fn check_variant(a: &$hir hir::Variant, b: &$hir hir::Generics);
             fn check_variant_post(a: &$hir hir::Variant, b: &$hir hir::Generics);
             fn check_lifetime(a: &$hir hir::Lifetime);
-            fn check_path(a: &$hir hir::Path, b: ast::NodeId);
+            fn check_path(a: &$hir hir::Path, b: hir::HirId);
             fn check_attribute(a: &$hir ast::Attribute);
 
             /// Called when entering a syntax node that can have lint attributes such
diff --git a/src/librustc/middle/dead.rs b/src/librustc/middle/dead.rs
@@ -279,7 +279,7 @@ impl<'a, 'tcx> Visitor<'tcx> for MarkSymbolVisitor<'a, 'tcx> {
         self.in_pat = false;
     }
 
-    fn visit_path(&mut self, path: &'tcx hir::Path, _: ast::NodeId) {
+    fn visit_path(&mut self, path: &'tcx hir::Path, _: hir::HirId) {
         self.handle_definition(path.def);
         intravisit::walk_path(self, path);
     }
diff --git a/src/librustc/middle/resolve_lifetime.rs b/src/librustc/middle/resolve_lifetime.rs
@@ -903,7 +903,7 @@ impl<'a, 'tcx> Visitor<'tcx> for LifetimeContext<'a, 'tcx> {
         self.resolve_lifetime_ref(lifetime_ref);
     }
 
-    fn visit_path(&mut self, path: &'tcx hir::Path, _: ast::NodeId) {
+    fn visit_path(&mut self, path: &'tcx hir::Path, _: hir::HirId) {
         for (i, segment) in path.segments.iter().enumerate() {
             let depth = path.segments.len() - i - 1;
             if let Some(ref args) = segment.args {
diff --git a/src/librustc/middle/stability.rs b/src/librustc/middle/stability.rs
@@ -780,7 +780,8 @@ impl<'a, 'tcx> Visitor<'tcx> for Checker<'a, 'tcx> {
         intravisit::walk_item(self, item);
     }
 
-    fn visit_path(&mut self, path: &'tcx hir::Path, id: ast::NodeId) {
+    fn visit_path(&mut self, path: &'tcx hir::Path, id: hir::HirId) {
+        let id = self.tcx.hir.hir_to_node_id(id);
         match path.def {
             Def::Local(..) | Def::Upvar(..) |
             Def::PrimTy(..) | Def::SelfTy(..) | Def::Err => {}
diff --git a/src/librustc_lint/builtin.rs b/src/librustc_lint/builtin.rs
@@ -1526,7 +1526,6 @@ impl TypeAliasBounds {
 
         // We use a HIR visitor to walk the type.
         use rustc::hir::intravisit::{self, Visitor};
-        use syntax::ast::NodeId;
         struct WalkAssocTypes<'a, 'db> where 'db: 'a {
             err: &'a mut DiagnosticBuilder<'db>
         }
@@ -1536,7 +1535,7 @@ impl TypeAliasBounds {
                 intravisit::NestedVisitorMap::None
             }
 
-            fn visit_qpath(&mut self, qpath: &'v hir::QPath, id: NodeId, span: Span) {
+            fn visit_qpath(&mut self, qpath: &'v hir::QPath, id: hir::HirId, span: Span) {
                 if TypeAliasBounds::is_type_variable_assoc(qpath) {
                     self.err.span_help(span,
                         "use fully disambiguated paths (i.e., `<T as Trait>::Assoc`) to refer to \
diff --git a/src/librustc_passes/hir_stats.rs b/src/librustc_passes/hir_stats.rs
@@ -224,11 +224,11 @@ impl<'v> hir_visit::Visitor<'v> for StatCollector<'v> {
         self.record("Lifetime", Id::Node(lifetime.id), lifetime);
         hir_visit::walk_lifetime(self, lifetime)
     }
-    fn visit_qpath(&mut self, qpath: &'v hir::QPath, id: NodeId, span: Span) {
+    fn visit_qpath(&mut self, qpath: &'v hir::QPath, id: hir::HirId, span: Span) {
         self.record("QPath", Id::None, qpath);
         hir_visit::walk_qpath(self, qpath, id, span)
     }
-    fn visit_path(&mut self, path: &'v hir::Path, _id: NodeId) {
+    fn visit_path(&mut self, path: &'v hir::Path, _id: hir::HirId) {
         self.record("Path", Id::None, path);
         hir_visit::walk_path(self, path)
     }
diff --git a/src/librustc_privacy/lib.rs b/src/librustc_privacy/lib.rs
@@ -815,16 +815,15 @@ impl<'a, 'tcx> Visitor<'tcx> for TypePrivacyVisitor<'a, 'tcx> {
     // we prohibit access to private statics from other crates, this allows to give
     // more code internal visibility at link time. (Access to private functions
     // is already prohibited by type privacy for function types.)
-    fn visit_qpath(&mut self, qpath: &'tcx hir::QPath, id: ast::NodeId, span: Span) {
+    fn visit_qpath(&mut self, qpath: &'tcx hir::QPath, id: hir::HirId, span: Span) {
         let def = match *qpath {
             hir::QPath::Resolved(_, ref path) => match path.def {
                 Def::Method(..) | Def::AssociatedConst(..) |
                 Def::AssociatedTy(..) | Def::Static(..) => Some(path.def),
                 _ => None,
             }
             hir::QPath::TypeRelative(..) => {
-                let hir_id = self.tcx.hir.node_to_hir_id(id);
-                self.tables.type_dependent_defs().get(hir_id).cloned()
+                self.tables.type_dependent_defs().get(id).cloned()
             }
         };
         if let Some(def) = def {
diff --git a/src/librustdoc/clean/auto_trait.rs b/src/librustdoc/clean/auto_trait.rs
@@ -126,6 +126,7 @@ impl<'a, 'tcx, 'rcx, 'cstore> AutoTraitFinder<'a, 'tcx, 'rcx, 'cstore> {
             let trait_ = hir::TraitRef {
                 path: get_path_for_type(self.cx.tcx, trait_def_id, hir::def::Def::Trait),
                 ref_id: ast::DUMMY_NODE_ID,
+                hir_ref_id: hir::DUMMY_HIR_ID,
             };
 
             let polarity;
diff --git a/src/librustdoc/clean/blanket_impl.rs b/src/librustdoc/clean/blanket_impl.rs
@@ -119,6 +119,7 @@ impl<'a, 'tcx, 'rcx, 'cstore> BlanketImplFinder <'a, 'tcx, 'rcx, 'cstore> {
                                                         trait_def_id,
                                                         hir::def::Def::Trait),
                                 ref_id: ast::DUMMY_NODE_ID,
+                                hir_ref_id: hir::DUMMY_HIR_ID,
                             };
                             let provided_trait_methods =
                                 infcx.tcx.provided_trait_methods(trait_def_id)

Original file line number	Diff line number	Diff line change
`@@ -353,10 +353,10 @@ pub trait Visitor<'v> : Sized {`
`353`	`353`	`fn visit_lifetime(&mut self, lifetime: &'v Lifetime) {`
`354`	`354`	`walk_lifetime(self, lifetime)`
`355`	`355`	`}`
`356`		`- fn visit_qpath(&mut self, qpath: &'v QPath, id: NodeId, span: Span) {`
	`356`	`+ fn visit_qpath(&mut self, qpath: &'v QPath, id: HirId, span: Span) {`
`357`	`357`	`walk_qpath(self, qpath, id, span)`
`358`	`358`	`}`
`359`		`- fn visit_path(&mut self, path: &'v Path, _id: NodeId) {`
	`359`	`+ fn visit_path(&mut self, path: &'v Path, _id: HirId) {`
`360`	`360`	`walk_path(self, path)`
`361`	`361`	`}`
`362`	`362`	`fn visit_path_segment(&mut self, path_span: Span, path_segment: &'v PathSegment) {`
`@@ -456,7 +456,7 @@ pub fn walk_trait_ref<'v, V>(visitor: &mut V, trait_ref: &'v TraitRef)`
`456`	`456`	`where V: Visitor<'v>`
`457`	`457`	`{`
`458`	`458`	`visitor.visit_id(trait_ref.ref_id);`
`459`		`- visitor.visit_path(&trait_ref.path, trait_ref.ref_id)`
	`459`	`+ visitor.visit_path(&trait_ref.path, trait_ref.hir_ref_id)`
`460`	`460`	`}`
`461`	`461`
`462`	`462`	`pub fn walk_item<'v, V: Visitor<'v>>(visitor: &mut V, item: &'v Item) {`
`@@ -471,7 +471,7 @@ pub fn walk_item<'v, V: Visitor<'v>>(visitor: &mut V, item: &'v Item) {`
`471`	`471`	`}`
`472`	`472`	`ItemKind::Use(ref path, _) => {`
`473`	`473`	`visitor.visit_id(item.id);`
`474`		`- visitor.visit_path(path, item.id);`
	`474`	`+ visitor.visit_path(path, item.hir_id);`
`475`	`475`	`}`
`476`	`476`	`ItemKind::Static(ref typ, _, body) \|`
`477`	`477`	`ItemKind::Const(ref typ, body) => {`
`@@ -602,7 +602,7 @@ pub fn walk_ty<'v, V: Visitor<'v>>(visitor: &mut V, typ: &'v Ty) {`
`602`	`602`	`visitor.visit_fn_decl(&function_declaration.decl);`
`603`	`603`	`}`
`604`	`604`	`TyKind::Path(ref qpath) => {`
`605`		`- visitor.visit_qpath(qpath, typ.id, typ.span);`
	`605`	`+ visitor.visit_qpath(qpath, typ.hir_id, typ.span);`
`606`	`606`	`}`
`607`	`607`	`TyKind::Array(ref ty, ref length) => {`
`608`	`608`	`visitor.visit_ty(ty);`
`@@ -621,7 +621,7 @@ pub fn walk_ty<'v, V: Visitor<'v>>(visitor: &mut V, typ: &'v Ty) {`
`621`	`621`	`}`
`622`	`622`	`}`
`623`	`623`
`624`		`-pub fn walk_qpath<'v, V: Visitor<'v>>(visitor: &mut V, qpath: &'v QPath, id: NodeId, span: Span) {`
	`624`	`+pub fn walk_qpath<'v, V: Visitor<'v>>(visitor: &mut V, qpath: &'v QPath, id: HirId, span: Span) {`
`625`	`625`	`match *qpath {`
`626`	`626`	`QPath::Resolved(ref maybe_qself, ref path) => {`
`627`	`627`	`if let Some(ref qself) = *maybe_qself {`
`@@ -670,14 +670,14 @@ pub fn walk_pat<'v, V: Visitor<'v>>(visitor: &mut V, pattern: &'v Pat) {`
`670`	`670`	`visitor.visit_id(pattern.id);`
`671`	`671`	`match pattern.node {`
`672`	`672`	`PatKind::TupleStruct(ref qpath, ref children, _) => {`
`673`		`- visitor.visit_qpath(qpath, pattern.id, pattern.span);`
	`673`	`+ visitor.visit_qpath(qpath, pattern.hir_id, pattern.span);`
`674`	`674`	`walk_list!(visitor, visit_pat, children);`
`675`	`675`	`}`
`676`	`676`	`PatKind::Path(ref qpath) => {`
`677`		`- visitor.visit_qpath(qpath, pattern.id, pattern.span);`
	`677`	`+ visitor.visit_qpath(qpath, pattern.hir_id, pattern.span);`
`678`	`678`	`}`
`679`	`679`	`PatKind::Struct(ref qpath, ref fields, _) => {`
`680`		`- visitor.visit_qpath(qpath, pattern.id, pattern.span);`
	`680`	`+ visitor.visit_qpath(qpath, pattern.hir_id, pattern.span);`
`681`	`681`	`for field in fields {`
`682`	`682`	`visitor.visit_id(field.node.id);`
`683`	`683`	`visitor.visit_ident(field.node.ident);`
`@@ -985,7 +985,7 @@ pub fn walk_expr<'v, V: Visitor<'v>>(visitor: &mut V, expression: &'v Expr) {`
`985`	`985`	`visitor.visit_anon_const(count)`
`986`	`986`	`}`
`987`	`987`	`ExprKind::Struct(ref qpath, ref fields, ref optional_base) => {`
`988`		`- visitor.visit_qpath(qpath, expression.id, expression.span);`
	`988`	`+ visitor.visit_qpath(qpath, expression.hir_id, expression.span);`
`989`	`989`	`for field in fields {`
`990`	`990`	`visitor.visit_id(field.id);`
`991`	`991`	`visitor.visit_ident(field.ident);`
`@@ -1062,7 +1062,7 @@ pub fn walk_expr<'v, V: Visitor<'v>>(visitor: &mut V, expression: &'v Expr) {`
`1062`	`1062`	`visitor.visit_expr(index_expression)`
`1063`	`1063`	`}`
`1064`	`1064`	`ExprKind::Path(ref qpath) => {`
`1065`		`- visitor.visit_qpath(qpath, expression.id, expression.span);`
	`1065`	`+ visitor.visit_qpath(qpath, expression.hir_id, expression.span);`
`1066`	`1066`	`}`
`1067`	`1067`	`ExprKind::Break(ref destination, ref opt_expr) => {`
`1068`	`1068`	`if let Some(ref label) = destination.label {`
`@@ -1108,9 +1108,9 @@ pub fn walk_arm<'v, V: Visitor<'v>>(visitor: &mut V, arm: &'v Arm) {`
`1108`	`1108`	`}`
`1109`	`1109`
`1110`	`1110`	`pub fn walk_vis<'v, V: Visitor<'v>>(visitor: &mut V, vis: &'v Visibility) {`
`1111`		`- if let VisibilityKind::Restricted { ref path, id } = vis.node {`
	`1111`	`+ if let VisibilityKind::Restricted { ref path, id, hir_id } = vis.node {`
`1112`	`1112`	`visitor.visit_id(id);`
`1113`		`- visitor.visit_path(path, id)`
	`1113`	`+ visitor.visit_path(path, hir_id)`
`1114`	`1114`	`}`
`1115`	`1115`	`}`
`1116`	`1116`
Original file line number	Diff line number	Diff line change
`@@ -1912,6 +1912,7 @@ pub enum UseKind {`
`1912`	`1912`	`pub struct TraitRef {`
`1913`	`1913`	`pub path: Path,`
`1914`	`1914`	`pub ref_id: NodeId,`
	`1915`	`+ pub hir_ref_id: HirId,`
`1915`	`1916`	`}`
`1916`	`1917`
`1917`	`1918`	`#[derive(Clone, RustcEncodable, RustcDecodable, Debug)]`
`@@ -1931,7 +1932,7 @@ pub type Visibility = Spanned<VisibilityKind>;`
`1931`	`1932`	`pub enum VisibilityKind {`
`1932`	`1933`	`Public,`
`1933`	`1934`	`Crate(CrateSugar),`
`1934`		`- Restricted { path: P<Path>, id: NodeId },`
	`1935`	`+ Restricted { path: P<Path>, id: NodeId, hir_id: HirId },`
`1935`	`1936`	`Inherited,`
`1936`	`1937`	`}`
`1937`	`1938`
Original file line number	Diff line number	Diff line change
`@@ -869,7 +869,7 @@ impl<'a, 'tcx> hir_visit::Visitor<'tcx> for LateContext<'a, 'tcx> {`
`869`	`869`	`hir_visit::walk_lifetime(self, lt);`
`870`	`870`	`}`
`871`	`871`
`872`		`- fn visit_path(&mut self, p: &'tcx hir::Path, id: ast::NodeId) {`
	`872`	`+ fn visit_path(&mut self, p: &'tcx hir::Path, id: hir::HirId) {`
`873`	`873`	`run_lints!(self, check_path, p, id);`
`874`	`874`	`hir_visit::walk_path(self, p);`
`875`	`875`	`}`
Original file line number	Diff line number	Diff line change
`@@ -279,7 +279,7 @@ impl<'a, 'tcx> Visitor<'tcx> for MarkSymbolVisitor<'a, 'tcx> {`
`279`	`279`	`self.in_pat = false;`
`280`	`280`	`}`
`281`	`281`
`282`		`- fn visit_path(&mut self, path: &'tcx hir::Path, _: ast::NodeId) {`
	`282`	`+ fn visit_path(&mut self, path: &'tcx hir::Path, _: hir::HirId) {`
`283`	`283`	`self.handle_definition(path.def);`
`284`	`284`	`intravisit::walk_path(self, path);`
`285`	`285`	`}`
Original file line number	Diff line number	Diff line change
`@@ -903,7 +903,7 @@ impl<'a, 'tcx> Visitor<'tcx> for LifetimeContext<'a, 'tcx> {`
`903`	`903`	`self.resolve_lifetime_ref(lifetime_ref);`
`904`	`904`	`}`
`905`	`905`
`906`		`- fn visit_path(&mut self, path: &'tcx hir::Path, _: ast::NodeId) {`
	`906`	`+ fn visit_path(&mut self, path: &'tcx hir::Path, _: hir::HirId) {`
`907`	`907`	`for (i, segment) in path.segments.iter().enumerate() {`
`908`	`908`	`let depth = path.segments.len() - i - 1;`
`909`	`909`	`if let Some(ref args) = segment.args {`
Original file line number	Diff line number	Diff line change
`@@ -780,7 +780,8 @@ impl<'a, 'tcx> Visitor<'tcx> for Checker<'a, 'tcx> {`
`780`	`780`	`intravisit::walk_item(self, item);`
`781`	`781`	`}`
`782`	`782`
`783`		`- fn visit_path(&mut self, path: &'tcx hir::Path, id: ast::NodeId) {`
	`783`	`+ fn visit_path(&mut self, path: &'tcx hir::Path, id: hir::HirId) {`
	`784`	`+ let id = self.tcx.hir.hir_to_node_id(id);`
`784`	`785`	`match path.def {`
`785`	`786`	`Def::Local(..) \| Def::Upvar(..) \|`
`786`	`787`	`Def::PrimTy(..) \| Def::SelfTy(..) \| Def::Err => {}`
Original file line number	Diff line number	Diff line change
`@@ -1526,7 +1526,6 @@ impl TypeAliasBounds {`
`1526`	`1526`
`1527`	`1527`	`// We use a HIR visitor to walk the type.`
`1528`	`1528`	`use rustc::hir::intravisit::{self, Visitor};`
`1529`		`- use syntax::ast::NodeId;`
`1530`	`1529`	`struct WalkAssocTypes<'a, 'db> where 'db: 'a {`
`1531`	`1530`	`err: &'a mut DiagnosticBuilder<'db>`
`1532`	`1531`	`}`
`@@ -1536,7 +1535,7 @@ impl TypeAliasBounds {`
`1536`	`1535`	`intravisit::NestedVisitorMap::None`
`1537`	`1536`	`}`
`1538`	`1537`
`1539`		`- fn visit_qpath(&mut self, qpath: &'v hir::QPath, id: NodeId, span: Span) {`
	`1538`	`+ fn visit_qpath(&mut self, qpath: &'v hir::QPath, id: hir::HirId, span: Span) {`
`1540`	`1539`	`if TypeAliasBounds::is_type_variable_assoc(qpath) {`
`1541`	`1540`	`self.err.span_help(span,`
`1542`	`1541`	"use fully disambiguated paths (i.e., `<T as Trait>::Assoc`) to refer to \