rustc: use LocalDefId instead of DefIndex in HirId.

Author: eddyb

src/librustc/dep_graph/dep_node.rs

@@ -565,7 +565,7 @@ impl<'tcx> DepNodeParams<'tcx> for HirId {
             local_id,
         } = *self;
 
-        let def_path_hash = tcx.def_path_hash(DefId::local(owner));
+        let def_path_hash = tcx.def_path_hash(owner.to_def_id());
         let local_id = Fingerprint::from_smaller_hash(local_id.as_u32().into());
 
         def_path_hash.0.combine(local_id)

src/librustc/hir/def_id.rs

@@ -174,7 +174,7 @@ impl rustc_serialize::UseSpecializedDecodable for DefId {}
 /// few cases where we know that only DefIds from the local crate are expected
 /// and a DefId from a different crate would signify a bug somewhere. This
 /// is when LocalDefId comes in handy.
-#[derive(Clone, Copy, PartialEq, Eq, Hash)]
+#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
 pub struct LocalDefId {
     pub index: DefIndex,
 }

src/librustc/hir/lowering.rs

@@ -420,7 +420,7 @@ impl<'a> LoweringContext<'a> {
                             let hir_id = self.lctx.allocate_hir_id_counter(id);
                             self.allocate_use_tree_hir_id_counters(
                                 use_tree,
-                                hir_id.owner_local_def_id(),
+                                hir_id.owner,
                             );
                         }
                     }
@@ -474,7 +474,7 @@ impl<'a> LoweringContext<'a> {
                     ItemKind::Use(ref use_tree) => {
                         self.allocate_use_tree_hir_id_counters(
                             use_tree,
-                            hir_id.owner_local_def_id(),
+                            hir_id.owner,
                         );
                     }
                     _ => {}
@@ -643,12 +643,12 @@ impl<'a> LoweringContext<'a> {
     /// properly. Calling the method twice with the same `NodeId` is fine though.
     fn lower_node_id(&mut self, ast_node_id: NodeId) -> hir::HirId {
         self.lower_node_id_generic(ast_node_id, |this| {
-            let &mut (def_id, ref mut local_id_counter) =
+            let &mut (owner, ref mut local_id_counter) =
                 this.current_hir_id_owner.last_mut().unwrap();
             let local_id = *local_id_counter;
             *local_id_counter += 1;
             hir::HirId {
-                owner: def_id.index,
+                owner,
                 local_id: hir::ItemLocalId::from_u32(local_id),
             }
         })
@@ -668,15 +668,16 @@ impl<'a> LoweringContext<'a> {
             debug_assert!(local_id != HIR_ID_COUNTER_LOCKED);
 
             *local_id_counter += 1;
-            let def_index = this
+            let owner = this
                 .resolver
                 .definitions()
-                .opt_def_index(owner)
+                .opt_local_def_id(owner)
                 .expect("you forgot to call `create_def_with_parent` or are lowering node-IDs \
-                         that do not belong to the current owner");
+                         that do not belong to the current owner")
+                .assert_local();
 
             hir::HirId {
-                owner: def_index,
+                owner,
                 local_id: hir::ItemLocalId::from_u32(local_id),
             }
         })

src/librustc/hir/map/collector.rs

@@ -34,7 +34,7 @@ pub(super) struct NodeCollector<'a, 'hir> {
 
     // These fields keep track of the currently relevant DepNodes during
     // the visitor's traversal.
-    current_dep_node_owner: DefIndex,
+    current_dep_node_owner: LocalDefId,
     current_signature_dep_index: DepNodeIndex,
     current_full_dep_index: DepNodeIndex,
     currently_in_body: bool,
@@ -153,7 +153,7 @@ impl<'a, 'hir> NodeCollector<'a, 'hir> {
             parent_node: hir::CRATE_HIR_ID,
             current_signature_dep_index: root_mod_sig_dep_index,
             current_full_dep_index: root_mod_full_dep_index,
-            current_dep_node_owner: CRATE_DEF_INDEX,
+            current_dep_node_owner: LocalDefId { index: CRATE_DEF_INDEX },
             currently_in_body: false,
             dep_graph,
             definitions,
@@ -227,7 +227,7 @@ impl<'a, 'hir> NodeCollector<'a, 'hir> {
 
     fn insert_entry(&mut self, id: HirId, entry: Entry<'hir>) {
         debug!("hir_map: {:?} => {:?}", id, entry);
-        let local_map = &mut self.map[id.owner];
+        let local_map = &mut self.map[id.owner.index];
         let i = id.local_id.as_u32() as usize;
         let len = local_map.len();
         if i >= len {
@@ -274,10 +274,10 @@ impl<'a, 'hir> NodeCollector<'a, 'hir> {
                     self.source_map.span_to_string(span),
                     node_str,
                     self.definitions
-                        .def_path(self.current_dep_node_owner)
+                        .def_path(self.current_dep_node_owner.index)
                         .to_string_no_crate(),
                     self.current_dep_node_owner,
-                    self.definitions.def_path(hir_id.owner).to_string_no_crate(),
+                    self.definitions.def_path(hir_id.owner.index).to_string_no_crate(),
                     hir_id.owner,
                     forgot_str,
                 )
@@ -300,15 +300,15 @@ impl<'a, 'hir> NodeCollector<'a, 'hir> {
 
     fn with_dep_node_owner<T: for<'b> HashStable<StableHashingContext<'b>>,
                            F: FnOnce(&mut Self)>(&mut self,
-                                                 dep_node_owner: DefIndex,
+                                                 dep_node_owner: LocalDefId,
                                                  item_like: &T,
                                                  f: F) {
         let prev_owner = self.current_dep_node_owner;
         let prev_signature_dep_index = self.current_signature_dep_index;
         let prev_full_dep_index = self.current_full_dep_index;
         let prev_in_body = self.currently_in_body;
 
-        let def_path_hash = self.definitions.def_path_hash(dep_node_owner);
+        let def_path_hash = self.definitions.def_path_hash(dep_node_owner.index);
 
         let (signature_dep_index, full_dep_index) = alloc_hir_dep_nodes(
             self.dep_graph,
@@ -369,7 +369,7 @@ impl<'a, 'hir> Visitor<'hir> for NodeCollector<'a, 'hir> {
 
     fn visit_item(&mut self, i: &'hir Item) {
         debug!("visit_item: {:?}", i);
-        debug_assert_eq!(i.hir_id.owner,
+        debug_assert_eq!(i.hir_id.owner.index,
                          self.definitions.opt_def_index(self.hir_to_node_id[&i.hir_id]).unwrap());
         self.with_dep_node_owner(i.hir_id.owner, i, |this| {
             this.insert(i.span, i.hir_id, Node::Item(i));
@@ -399,7 +399,7 @@ impl<'a, 'hir> Visitor<'hir> for NodeCollector<'a, 'hir> {
     }
 
     fn visit_trait_item(&mut self, ti: &'hir TraitItem) {
-        debug_assert_eq!(ti.hir_id.owner,
+        debug_assert_eq!(ti.hir_id.owner.index,
                          self.definitions.opt_def_index(self.hir_to_node_id[&ti.hir_id]).unwrap());
         self.with_dep_node_owner(ti.hir_id.owner, ti, |this| {
             this.insert(ti.span, ti.hir_id, Node::TraitItem(ti));
@@ -411,7 +411,7 @@ impl<'a, 'hir> Visitor<'hir> for NodeCollector<'a, 'hir> {
     }
 
     fn visit_impl_item(&mut self, ii: &'hir ImplItem) {
-        debug_assert_eq!(ii.hir_id.owner,
+        debug_assert_eq!(ii.hir_id.owner.index,
                          self.definitions.opt_def_index(self.hir_to_node_id[&ii.hir_id]).unwrap());
         self.with_dep_node_owner(ii.hir_id.owner, ii, |this| {
             this.insert(ii.span, ii.hir_id, Node::ImplItem(ii));
@@ -531,10 +531,7 @@ impl<'a, 'hir> Visitor<'hir> for NodeCollector<'a, 'hir> {
     }
 
     fn visit_macro_def(&mut self, macro_def: &'hir MacroDef) {
-        let node_id = self.hir_to_node_id[&macro_def.hir_id];
-        let def_index = self.definitions.opt_def_index(node_id).unwrap();
-
-        self.with_dep_node_owner(def_index, macro_def, |this| {
+        self.with_dep_node_owner(macro_def.hir_id.owner, macro_def, |this| {
             this.insert(macro_def.span, macro_def.hir_id, Node::MacroDef(macro_def));
         });
     }

src/librustc/hir/map/hir_id_validator.rs

@@ -1,4 +1,4 @@
-use crate::hir::def_id::{DefIndex, CRATE_DEF_INDEX, LocalDefId};
+use crate::hir::def_id::{CRATE_DEF_INDEX, LocalDefId};
 use crate::hir::{self, intravisit, HirId, ItemLocalId};
 use crate::hir::itemlikevisit::ItemLikeVisitor;
 use rustc_data_structures::fx::FxHashSet;
@@ -29,7 +29,7 @@ pub fn check_crate(hir_map: &hir::map::Map<'_>) {
 
 struct HirIdValidator<'a, 'hir> {
     hir_map: &'a hir::map::Map<'hir>,
-    owner_def_index: Option<DefIndex>,
+    owner: Option<LocalDefId>,
     hir_ids_seen: FxHashSet<ItemLocalId>,
     errors: &'a Lock<Vec<String>>,
 }
@@ -45,7 +45,7 @@ impl<'a, 'hir> OuterVisitor<'a, 'hir> {
                          -> HirIdValidator<'a, 'hir> {
         HirIdValidator {
             hir_map,
-            owner_def_index: None,
+            owner: None,
             hir_ids_seen: Default::default(),
             errors: self.errors,
         }
@@ -79,12 +79,12 @@ impl<'a, 'hir> HirIdValidator<'a, 'hir> {
     fn check<F: FnOnce(&mut HirIdValidator<'a, 'hir>)>(&mut self,
                                                        hir_id: HirId,
                                                        walk: F) {
-        assert!(self.owner_def_index.is_none());
-        let owner_def_index = self.hir_map.local_def_id(hir_id).index;
-        self.owner_def_index = Some(owner_def_index);
+        assert!(self.owner.is_none());
+        let owner = self.hir_map.local_def_id(hir_id).assert_local();
+        self.owner = Some(owner);
         walk(self);
 
-        if owner_def_index == CRATE_DEF_INDEX {
+        if owner.index == CRATE_DEF_INDEX {
             return;
         }
 
@@ -106,7 +106,7 @@ impl<'a, 'hir> HirIdValidator<'a, 'hir> {
 
             for local_id in missing {
                 let hir_id = HirId {
-                    owner: owner_def_index,
+                    owner,
                     local_id: ItemLocalId::from_u32(local_id),
                 };
 
@@ -119,13 +119,13 @@ impl<'a, 'hir> HirIdValidator<'a, 'hir> {
             self.error(|| format!(
                 "ItemLocalIds not assigned densely in {}. \
                 Max ItemLocalId = {}, missing IDs = {:?}; seens IDs = {:?}",
-                self.hir_map.def_path(LocalDefId { index: owner_def_index }).to_string_no_crate(),
+                self.hir_map.def_path(owner).to_string_no_crate(),
                 max,
                 missing_items,
                 self.hir_ids_seen
                     .iter()
                     .map(|&local_id| HirId {
-                        owner: owner_def_index,
+                        owner,
                         local_id,
                     })
                     .map(|h| format!("({:?} {})", h, self.hir_map.node_to_string(h)))
@@ -142,7 +142,7 @@ impl<'a, 'hir> intravisit::Visitor<'hir> for HirIdValidator<'a, 'hir> {
     }
 
     fn visit_id(&mut self, hir_id: HirId) {
-        let owner = self.owner_def_index.expect("no owner_def_index");
+        let owner = self.owner.expect("no owner");
 
         if hir_id == hir::DUMMY_HIR_ID {
             self.error(|| format!("HirIdValidator: HirId {:?} is invalid",
@@ -154,8 +154,8 @@ impl<'a, 'hir> intravisit::Visitor<'hir> for HirIdValidator<'a, 'hir> {
             self.error(|| format!(
                 "HirIdValidator: The recorded owner of {} is {} instead of {}",
                 self.hir_map.node_to_string(hir_id),
-                self.hir_map.def_path(hir_id.owner_local_def_id()).to_string_no_crate(),
-                self.hir_map.def_path(LocalDefId { index: owner }).to_string_no_crate()));
+                self.hir_map.def_path(hir_id.owner).to_string_no_crate(),
+                self.hir_map.def_path(owner).to_string_no_crate()));
         }
 
         self.hir_ids_seen.insert(hir_id.local_id);

src/librustc/hir/map/mod.rs

@@ -222,7 +222,7 @@ impl<'map> Iterator for ParentHirIterator<'map> {
 impl<'hir> Map<'hir> {
     #[inline]
     fn lookup(&self, id: HirId) -> Option<&Entry<'hir>> {
-        let local_map = self.map.get(id.owner)?;
+        let local_map = self.map.get(id.owner.index)?;
         local_map.get(id.local_id)?.as_ref()
     }
 
@@ -466,8 +466,7 @@ impl<'hir> Map<'hir> {
     pub fn maybe_body_owned_by(&self, hir_id: HirId) -> Option<BodyId> {
         if let Some(entry) = self.find_entry(hir_id) {
             if self.dep_graph.is_fully_enabled() {
-                let hir_id_owner = hir_id.owner;
-                let def_path_hash = self.definitions.def_path_hash(hir_id_owner);
+                let def_path_hash = self.definitions.def_path_hash(hir_id.owner.index);
                 self.dep_graph.read(def_path_hash.to_dep_node(DepKind::HirBody));
             }
 
@@ -646,8 +645,7 @@ impl<'hir> Map<'hir> {
     /// which can happen if the ID is not in the map itself or is just weird).
     pub fn get_parent_node(&self, hir_id: HirId) -> HirId {
         if self.dep_graph.is_fully_enabled() {
-            let hir_id_owner = hir_id.owner;
-            let def_path_hash = self.definitions.def_path_hash(hir_id_owner);
+            let def_path_hash = self.definitions.def_path_hash(hir_id.owner.index);
             self.dep_graph.read(def_path_hash.to_dep_node(DepKind::HirBody));
         }
 
@@ -1034,7 +1032,7 @@ impl<'hir> Map<'hir> {
             local_map.iter_enumerated().filter_map(move |(i, entry)| entry.map(move |_| {
                 // Reconstruct the `HirId` based on the 3 indices we used to find it.
                 HirId {
-                    owner,
+                    owner: LocalDefId { index: owner },
                     local_id: i,
                 }
             }))

src/librustc/hir/mod.rs

@@ -64,7 +64,7 @@ pub mod ptr;
 pub mod upvars;
 
 /// Uniquely identifies a node in the HIR of the current crate. It is
-/// composed of the `owner`, which is the `DefIndex` of the directly enclosing
+/// composed of the `owner`, which is the `LocalDefId` of the directly enclosing
 /// `hir::Item`, `hir::TraitItem`, or `hir::ImplItem` (i.e., the closest "item-like"),
 /// and the `local_id` which is unique within the given owner.
 ///
@@ -75,38 +75,30 @@ pub mod upvars;
 /// the code base.
 #[derive(Copy, Clone, PartialEq, Eq, Hash, Debug, PartialOrd, Ord)]
 pub struct HirId {
-    pub owner: DefIndex,
+    pub owner: LocalDefId,
     pub local_id: ItemLocalId,
 }
 
-impl HirId {
-    pub fn owner_def_id(self) -> DefId {
-        DefId::local(self.owner)
-    }
-
-    pub fn owner_local_def_id(self) -> LocalDefId {
-        LocalDefId {
-            index: self.owner,
-        }
-    }
-}
-
 impl rustc_serialize::UseSpecializedEncodable for HirId {
     fn default_encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> {
         let HirId {
             owner,
             local_id,
         } = *self;
 
-        owner.encode(s)?;
+        // HACK(eddyb) this avoids `LocalDefId` because that encodes as a `DefId`,
+        // maybe try to fix that? (but it's unclear if anything relies on it)
+        owner.index.encode(s)?;
         local_id.encode(s)?;
         Ok(())
     }
 }
 
 impl rustc_serialize::UseSpecializedDecodable for HirId {
     fn default_decode<D: Decoder>(d: &mut D) -> Result<HirId, D::Error> {
-        let owner = DefIndex::decode(d)?;
+        // HACK(eddyb) this avoids `LocalDefId` because that encodes as a `DefId`,
+        // maybe try to fix that? (but it's unclear if anything relies on it)
+        let owner = LocalDefId { index: DefIndex::decode(d)? };
         let local_id = ItemLocalId::decode(d)?;
 
         Ok(HirId {
@@ -145,12 +137,12 @@ pub use self::item_local_id_inner::ItemLocalId;
 
 /// The `HirId` corresponding to `CRATE_NODE_ID` and `CRATE_DEF_INDEX`.
 pub const CRATE_HIR_ID: HirId = HirId {
-    owner: CRATE_DEF_INDEX,
+    owner: LocalDefId { index: CRATE_DEF_INDEX },
     local_id: ItemLocalId::from_u32_const(0)
 };
 
 pub const DUMMY_HIR_ID: HirId = HirId {
-    owner: CRATE_DEF_INDEX,
+    owner: LocalDefId { index: CRATE_DEF_INDEX },
     local_id: DUMMY_ITEM_LOCAL_ID,
 };
 

src/librustc/ich/hcx.rs

@@ -238,7 +238,7 @@ impl<'a> HashStable<StableHashingContext<'a>> for hir::HirId {
                     local_id,
                 } = *self;
 
-                hcx.local_def_path_hash(owner).hash_stable(hcx, hasher);
+                hcx.local_def_path_hash(owner.index).hash_stable(hcx, hasher);
                 local_id.hash_stable(hcx, hasher);
             }
         }
@@ -252,7 +252,7 @@ impl<'a> ToStableHashKey<StableHashingContext<'a>> for hir::HirId {
     fn to_stable_hash_key(&self,
                           hcx: &StableHashingContext<'a>)
                           -> (DefPathHash, hir::ItemLocalId) {
-        let def_path_hash = hcx.local_def_path_hash(self.owner);
+        let def_path_hash = hcx.local_def_path_hash(self.owner.index);
         (def_path_hash, self.local_id)
     }
 }

src/librustc/ich/impls_hir.rs

@@ -374,9 +374,10 @@ impl<'a> ToStableHashKey<StableHashingContext<'a>> for hir::TraitCandidate {
             import_ids,
         } = self;
 
-        let import_keys = import_ids.iter().map(|node_id| hcx.node_to_hir_id(*node_id))
-                                           .map(|hir_id| (hcx.local_def_path_hash(hir_id.owner),
-                                                          hir_id.local_id)).collect();
+        let import_keys = import_ids.iter()
+            .map(|node_id| hcx.node_to_hir_id(*node_id))
+            .map(|hir_id| (hcx.local_def_path_hash(hir_id.owner.index), hir_id.local_id))
+            .collect();
         (hcx.def_path_hash(*def_id), import_keys)
     }
 }