hir: HirIdify Impl&TraitItemId

ljedrz · ljedrz · commit fa61c67fe63d · 2019-03-02T07:48:53.000+01:00
diff --git a/src/librustc/hir/lowering.rs b/src/librustc/hir/lowering.rs
@@ -469,8 +469,8 @@ impl<'a> LoweringContext<'a> {
 
             fn visit_trait_item(&mut self, item: &'lcx TraitItem) {
                 self.lctx.with_hir_id_owner(item.id, |lctx| {
-                    let id = hir::TraitItemId { node_id: item.id };
                     let hir_item = lctx.lower_trait_item(item);
+                    let id = hir::TraitItemId { hir_id: hir_item.hir_id };
                     lctx.trait_items.insert(id, hir_item);
                     lctx.modules.get_mut(&lctx.current_module).unwrap().trait_items.insert(id);
                 });
@@ -480,8 +480,8 @@ impl<'a> LoweringContext<'a> {
 
             fn visit_impl_item(&mut self, item: &'lcx ImplItem) {
                 self.lctx.with_hir_id_owner(item.id, |lctx| {
-                    let id = hir::ImplItemId { node_id: item.id };
                     let hir_item = lctx.lower_impl_item(item);
+                    let id = hir::ImplItemId { hir_id: hir_item.hir_id };
                     lctx.impl_items.insert(id, hir_item);
                     lctx.modules.get_mut(&lctx.current_module).unwrap().impl_items.insert(id);
                 });
@@ -3363,7 +3363,7 @@ impl<'a> LoweringContext<'a> {
             TraitItemKind::Macro(..) => unimplemented!(),
         };
         hir::TraitItemRef {
-            id: hir::TraitItemId { node_id: i.id },
+            id: hir::TraitItemId { hir_id: self.lower_node_id(i.id).hir_id },
             ident: i.ident,
             span: i.span,
             defaultness: self.lower_defaultness(Defaultness::Default, has_default),
@@ -3427,7 +3427,7 @@ impl<'a> LoweringContext<'a> {
 
     fn lower_impl_item_ref(&mut self, i: &ImplItem) -> hir::ImplItemRef {
         hir::ImplItemRef {
-            id: hir::ImplItemId { node_id: i.id },
+            id: hir::ImplItemId { hir_id: self.lower_node_id(i.id).hir_id },
             ident: i.ident,
             span: i.span,
             vis: self.lower_visibility(&i.vis, Some(i.id)),
diff --git a/src/librustc/hir/map/mod.rs b/src/librustc/hir/map/mod.rs
@@ -427,15 +427,15 @@ impl<'hir> Map<'hir> {
     }
 
     pub fn trait_item(&self, id: TraitItemId) -> &'hir TraitItem {
-        self.read(id.node_id);
+        self.read_by_hir_id(id.hir_id);
 
         // N.B., intentionally bypass `self.forest.krate()` so that we
         // do not trigger a read of the whole krate here
         self.forest.krate.trait_item(id)
     }
 
     pub fn impl_item(&self, id: ImplItemId) -> &'hir ImplItem {
-        self.read(id.node_id);
+        self.read_by_hir_id(id.hir_id);
 
         // N.B., intentionally bypass `self.forest.krate()` so that we
         // do not trigger a read of the whole krate here
@@ -618,11 +618,11 @@ impl<'hir> Map<'hir> {
         }
 
         for id in &module.trait_items {
-            visitor.visit_trait_item(self.expect_trait_item(id.node_id));
+            visitor.visit_trait_item(self.expect_trait_item_by_hir_id(id.hir_id));
         }
 
         for id in &module.impl_items {
-            visitor.visit_impl_item(self.expect_impl_item(id.node_id));
+            visitor.visit_impl_item(self.expect_impl_item_by_hir_id(id.hir_id));
         }
     }
 
diff --git a/src/librustc/hir/mod.rs b/src/librustc/hir/mod.rs
@@ -1657,7 +1657,7 @@ pub struct MethodSig {
 // so it can fetched later.
 #[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, RustcEncodable, RustcDecodable, Debug)]
 pub struct TraitItemId {
-    pub node_id: NodeId,
+    pub hir_id: HirId,
 }
 
 /// Represents an item declaration within a trait declaration,
@@ -1702,7 +1702,7 @@ pub enum TraitItemKind {
 // so it can fetched later.
 #[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, RustcEncodable, RustcDecodable, Debug)]
 pub struct ImplItemId {
-    pub node_id: NodeId,
+    pub hir_id: HirId,
 }
 
 /// Represents anything within an `impl` block
diff --git a/src/librustc/ich/impls_hir.rs b/src/librustc/ich/impls_hir.rs
@@ -116,11 +116,11 @@ impl<'a> HashStable<StableHashingContext<'a>> for hir::TraitItemId {
                                           hcx: &mut StableHashingContext<'a>,
                                           hasher: &mut StableHasher<W>) {
         let hir::TraitItemId {
-            node_id
+            hir_id
         } = * self;
 
         hcx.with_node_id_hashing_mode(NodeIdHashingMode::HashDefPath, |hcx| {
-            node_id.hash_stable(hcx, hasher);
+            hir_id.hash_stable(hcx, hasher);
         })
     }
 }
@@ -130,11 +130,11 @@ impl<'a> HashStable<StableHashingContext<'a>> for hir::ImplItemId {
                                           hcx: &mut StableHashingContext<'a>,
                                           hasher: &mut StableHasher<W>) {
         let hir::ImplItemId {
-            node_id
+            hir_id
         } = * self;
 
         hcx.with_node_id_hashing_mode(NodeIdHashingMode::HashDefPath, |hcx| {
-            node_id.hash_stable(hcx, hasher);
+            hir_id.hash_stable(hcx, hasher);
         })
     }
 }
diff --git a/src/librustc/middle/dead.rs b/src/librustc/middle/dead.rs
@@ -376,7 +376,7 @@ impl<'v, 'k, 'tcx> ItemLikeVisitor<'v> for LifeSeeder<'k, 'tcx> {
                             has_allow_dead_code_or_lang_attr(self.tcx,
                                                              impl_item.hir_id,
                                                              &impl_item.attrs) {
-                        self.worklist.push(self.tcx.hir().node_to_hir_id(impl_item_ref.id.node_id));
+                        self.worklist.push(impl_item_ref.id.hir_id);
                     }
                 }
             }
diff --git a/src/librustc/middle/reachable.rs b/src/librustc/middle/reachable.rs
@@ -355,11 +355,7 @@ impl<'a, 'tcx: 'a> ItemLikeVisitor<'tcx> for CollectPrivateImplItemsVisitor<'a,
         if let hir::ItemKind::Impl(.., Some(ref trait_ref), _, ref impl_item_refs) = item.node {
             let node_id = self.tcx.hir().hir_to_node_id(item.hir_id);
             if !self.access_levels.is_reachable(node_id) {
-                // FIXME(@ljedrz): rework back to a nice extend when item Ids contain HirId
-                for impl_item_ref in impl_item_refs {
-                    let hir_id = self.tcx.hir().node_to_hir_id(impl_item_ref.id.node_id);
-                    self.worklist.push(hir_id);
-                }
+                self.worklist.extend(impl_item_refs.iter().map(|ii_ref| ii_ref.id.hir_id));
 
                 let trait_def_id = match trait_ref.path.def {
                     Def::Trait(def_id) => def_id,
diff --git a/src/librustc/middle/resolve_lifetime.rs b/src/librustc/middle/resolve_lifetime.rs
@@ -671,13 +671,14 @@ impl<'a, 'tcx> Visitor<'tcx> for LifetimeContext<'a, 'tcx> {
                         // In the future, this should be fixed and this error should be removed.
                         let def = self.map.defs.get(&lifetime.hir_id).cloned();
                         if let Some(Region::LateBound(_, def_id, _)) = def {
-                            if let Some(node_id) = self.tcx.hir().as_local_node_id(def_id) {
+                            if let Some(hir_id) = self.tcx.hir().as_local_hir_id(def_id) {
                                 // Ensure that the parent of the def is an item, not HRTB
-                                let parent_id = self.tcx.hir().get_parent_node(node_id);
-                                let parent_impl_id = hir::ImplItemId { node_id: parent_id };
-                                let parent_trait_id = hir::TraitItemId { node_id: parent_id };
+                                let parent_id = self.tcx.hir().get_parent_node_by_hir_id(hir_id);
+                                let parent_impl_id = hir::ImplItemId { hir_id: parent_id };
+                                let parent_trait_id = hir::TraitItemId { hir_id: parent_id };
                                 let krate = self.tcx.hir().forest.krate();
-                                if !(krate.items.contains_key(&parent_id)
+                                let parent_node_id = self.tcx.hir().hir_to_node_id(parent_id);
+                                if !(krate.items.contains_key(&parent_node_id)
                                     || krate.impl_items.contains_key(&parent_impl_id)
                                     || krate.trait_items.contains_key(&parent_trait_id))
                                 {
@@ -2072,10 +2073,9 @@ impl<'a, 'tcx> LifetimeContext<'a, 'tcx> {
                     .expect_item_by_hir_id(self.tcx.hir().get_parent_item(parent))
                     .node
                 {
-                    let parent_node_id = self.tcx.hir().hir_to_node_id(parent);
                     assoc_item_kind = trait_items
                         .iter()
-                        .find(|ti| ti.id.node_id == parent_node_id)
+                        .find(|ti| ti.id.hir_id == parent)
                         .map(|ti| ti.kind);
                 }
                 match *m {
@@ -2094,10 +2094,9 @@ impl<'a, 'tcx> LifetimeContext<'a, 'tcx> {
                     .node
                 {
                     impl_self = Some(self_ty);
-                    let parent_node_id = self.tcx.hir().hir_to_node_id(parent);
                     assoc_item_kind = impl_items
                         .iter()
-                        .find(|ii| ii.id.node_id == parent_node_id)
+                        .find(|ii| ii.id.hir_id == parent)
                         .map(|ii| ii.kind);
                 }
                 Some(body)
diff --git a/src/librustc/ty/mod.rs b/src/librustc/ty/mod.rs
@@ -2727,7 +2727,7 @@ impl<'a, 'gcx, 'tcx> TyCtxt<'a, 'gcx, 'tcx> {
                                            parent_vis: &hir::Visibility,
                                            trait_item_ref: &hir::TraitItemRef)
                                            -> AssociatedItem {
-        let def_id = self.hir().local_def_id(trait_item_ref.id.node_id);
+        let def_id = self.hir().local_def_id_from_hir_id(trait_item_ref.id.hir_id);
         let (kind, has_self) = match trait_item_ref.kind {
             hir::AssociatedItemKind::Const => (ty::AssociatedKind::Const, false),
             hir::AssociatedItemKind::Method { has_self } => {
@@ -2737,13 +2737,11 @@ impl<'a, 'gcx, 'tcx> TyCtxt<'a, 'gcx, 'tcx> {
             hir::AssociatedItemKind::Existential => bug!("only impls can have existentials"),
         };
 
-        let hir_id = self.hir().node_to_hir_id(trait_item_ref.id.node_id);
-
         AssociatedItem {
             ident: trait_item_ref.ident,
             kind,
             // Visibility of trait items is inherited from their traits.
-            vis: Visibility::from_hir(parent_vis, hir_id, self),
+            vis: Visibility::from_hir(parent_vis, trait_item_ref.id.hir_id, self),
             defaultness: trait_item_ref.defaultness,
             def_id,
             container: TraitContainer(parent_def_id),
@@ -2755,7 +2753,7 @@ impl<'a, 'gcx, 'tcx> TyCtxt<'a, 'gcx, 'tcx> {
                                           parent_def_id: DefId,
                                           impl_item_ref: &hir::ImplItemRef)
                                           -> AssociatedItem {
-        let def_id = self.hir().local_def_id(impl_item_ref.id.node_id);
+        let def_id = self.hir().local_def_id_from_hir_id(impl_item_ref.id.hir_id);
         let (kind, has_self) = match impl_item_ref.kind {
             hir::AssociatedItemKind::Const => (ty::AssociatedKind::Const, false),
             hir::AssociatedItemKind::Method { has_self } => {
@@ -2765,13 +2763,11 @@ impl<'a, 'gcx, 'tcx> TyCtxt<'a, 'gcx, 'tcx> {
             hir::AssociatedItemKind::Existential => (ty::AssociatedKind::Existential, false),
         };
 
-        let hir_id = self.hir().node_to_hir_id(impl_item_ref.id.node_id);
-
         AssociatedItem {
             ident: impl_item_ref.ident,
             kind,
             // Visibility of trait impl items doesn't matter.
-            vis: ty::Visibility::from_hir(&impl_item_ref.vis, hir_id, self),
+            vis: ty::Visibility::from_hir(&impl_item_ref.vis, impl_item_ref.id.hir_id, self),
             defaultness: impl_item_ref.defaultness,
             def_id,
             container: ImplContainer(parent_def_id),
@@ -3041,13 +3037,13 @@ impl<'a, 'gcx, 'tcx> TyCtxt<'a, 'gcx, 'tcx> {
 }
 
 fn associated_item<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, def_id: DefId) -> AssociatedItem {
-    let id = tcx.hir().as_local_node_id(def_id).unwrap();
-    let parent_id = tcx.hir().get_parent(id);
-    let parent_def_id = tcx.hir().local_def_id(parent_id);
-    let parent_item = tcx.hir().expect_item(parent_id);
+    let id = tcx.hir().as_local_hir_id(def_id).unwrap();
+    let parent_id = tcx.hir().get_parent_item(id);
+    let parent_def_id = tcx.hir().local_def_id_from_hir_id(parent_id);
+    let parent_item = tcx.hir().expect_item_by_hir_id(parent_id);
     match parent_item.node {
         hir::ItemKind::Impl(.., ref impl_item_refs) => {
-            if let Some(impl_item_ref) = impl_item_refs.iter().find(|i| i.id.node_id == id) {
+            if let Some(impl_item_ref) = impl_item_refs.iter().find(|i| i.id.hir_id == id) {
                 let assoc_item = tcx.associated_item_from_impl_item_ref(parent_def_id,
                                                                         impl_item_ref);
                 debug_assert_eq!(assoc_item.def_id, def_id);
@@ -3056,7 +3052,7 @@ fn associated_item<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, def_id: DefId) -> Asso
         }
 
         hir::ItemKind::Trait(.., ref trait_item_refs) => {
-            if let Some(trait_item_ref) = trait_item_refs.iter().find(|i| i.id.node_id == id) {
+            if let Some(trait_item_ref) = trait_item_refs.iter().find(|i| i.id.hir_id == id) {
                 let assoc_item = tcx.associated_item_from_trait_item_ref(parent_def_id,
                                                                          &parent_item.vis,
                                                                          trait_item_ref);
@@ -3110,13 +3106,13 @@ fn associated_item_def_ids<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
         hir::ItemKind::Trait(.., ref trait_item_refs) => {
             trait_item_refs.iter()
                            .map(|trait_item_ref| trait_item_ref.id)
-                           .map(|id| tcx.hir().local_def_id(id.node_id))
+                           .map(|id| tcx.hir().local_def_id_from_hir_id(id.hir_id))
                            .collect()
         }
         hir::ItemKind::Impl(.., ref impl_item_refs) => {
             impl_item_refs.iter()
                           .map(|impl_item_ref| impl_item_ref.id)
-                          .map(|id| tcx.hir().local_def_id(id.node_id))
+                          .map(|id| tcx.hir().local_def_id_from_hir_id(id.hir_id))
                           .collect()
         }
         hir::ItemKind::TraitAlias(..) => vec![],
diff --git a/src/librustc_lint/builtin.rs b/src/librustc_lint/builtin.rs
@@ -447,8 +447,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for MissingDoc {
                 if let hir::VisibilityKind::Inherited = it.vis.node {
                     self.private_traits.insert(it.hir_id);
                     for trait_item_ref in trait_item_refs {
-                        let hir_id = cx.tcx.hir().node_to_hir_id(trait_item_ref.id.node_id);
-                        self.private_traits.insert(hir_id);
+                        self.private_traits.insert(trait_item_ref.id.hir_id);
                     }
                     return;
                 }
@@ -464,9 +463,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for MissingDoc {
                         Some(Node::Item(item)) => {
                             if let hir::VisibilityKind::Inherited = item.vis.node {
                                 for impl_item_ref in impl_item_refs {
-                                    let hir_id = cx.tcx.hir().node_to_hir_id(
-                                        impl_item_ref.id.node_id);
-                                    self.private_traits.insert(hir_id);
+                                    self.private_traits.insert(impl_item_ref.id.hir_id);
                                 }
                             }
                         }
diff --git a/src/librustc_privacy/lib.rs b/src/librustc_privacy/lib.rs
diff --git a/src/librustc_typeck/check/compare_method.rs b/src/librustc_typeck/check/compare_method.rs
diff --git a/src/librustc_typeck/impl_wf_check.rs b/src/librustc_typeck/impl_wf_check.rs

Original file line number	Diff line number	Diff line change
`@@ -427,15 +427,15 @@ impl<'hir> Map<'hir> {`
`427`	`427`	`}`
`428`	`428`
`429`	`429`	`pub fn trait_item(&self, id: TraitItemId) -> &'hir TraitItem {`
`430`		`- self.read(id.node_id);`
	`430`	`+ self.read_by_hir_id(id.hir_id);`
`431`	`431`
`432`	`432`	// N.B., intentionally bypass `self.forest.krate()` so that we
`433`	`433`	`// do not trigger a read of the whole krate here`
`434`	`434`	`self.forest.krate.trait_item(id)`
`435`	`435`	`}`
`436`	`436`
`437`	`437`	`pub fn impl_item(&self, id: ImplItemId) -> &'hir ImplItem {`
`438`		`- self.read(id.node_id);`
	`438`	`+ self.read_by_hir_id(id.hir_id);`
`439`	`439`
`440`	`440`	// N.B., intentionally bypass `self.forest.krate()` so that we
`441`	`441`	`// do not trigger a read of the whole krate here`
`@@ -618,11 +618,11 @@ impl<'hir> Map<'hir> {`
`618`	`618`	`}`
`619`	`619`
`620`	`620`	`for id in &module.trait_items {`
`621`		`- visitor.visit_trait_item(self.expect_trait_item(id.node_id));`
	`621`	`+ visitor.visit_trait_item(self.expect_trait_item_by_hir_id(id.hir_id));`
`622`	`622`	`}`
`623`	`623`
`624`	`624`	`for id in &module.impl_items {`
`625`		`- visitor.visit_impl_item(self.expect_impl_item(id.node_id));`
	`625`	`+ visitor.visit_impl_item(self.expect_impl_item_by_hir_id(id.hir_id));`
`626`	`626`	`}`
`627`	`627`	`}`
`628`	`628`
Original file line number	Diff line number	Diff line change
`@@ -376,7 +376,7 @@ impl<'v, 'k, 'tcx> ItemLikeVisitor<'v> for LifeSeeder<'k, 'tcx> {`
`376`	`376`	`has_allow_dead_code_or_lang_attr(self.tcx,`
`377`	`377`	`impl_item.hir_id,`
`378`	`378`	`&impl_item.attrs) {`
`379`		`- self.worklist.push(self.tcx.hir().node_to_hir_id(impl_item_ref.id.node_id));`
	`379`	`+ self.worklist.push(impl_item_ref.id.hir_id);`
`380`	`380`	`}`
`381`	`381`	`}`
`382`	`382`	`}`
Original file line number	Diff line number	Diff line change
`@@ -447,8 +447,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for MissingDoc {`
`447`	`447`	`if let hir::VisibilityKind::Inherited = it.vis.node {`
`448`	`448`	`self.private_traits.insert(it.hir_id);`
`449`	`449`	`for trait_item_ref in trait_item_refs {`
`450`		`- let hir_id = cx.tcx.hir().node_to_hir_id(trait_item_ref.id.node_id);`
`451`		`- self.private_traits.insert(hir_id);`
	`450`	`+ self.private_traits.insert(trait_item_ref.id.hir_id);`
`452`	`451`	`}`
`453`	`452`	`return;`
`454`	`453`	`}`
`@@ -464,9 +463,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for MissingDoc {`
`464`	`463`	`Some(Node::Item(item)) => {`
`465`	`464`	`if let hir::VisibilityKind::Inherited = item.vis.node {`
`466`	`465`	`for impl_item_ref in impl_item_refs {`
`467`		`- let hir_id = cx.tcx.hir().node_to_hir_id(`
`468`		`- impl_item_ref.id.node_id);`
`469`		`- self.private_traits.insert(hir_id);`
	`466`	`+ self.private_traits.insert(impl_item_ref.id.hir_id);`
`470`	`467`	`}`
`471`	`468`	`}`
`472`	`469`	`}`