Rollup merge of rust-lang#60647 - petrochenkov:nospace, r=michaelwoerister

cleanup: Remove `DefIndexAddressSpace`

The scheme with two address spaces for `DefIndex` was needed in the past, but apparently not needed anymore (after removing `DefId`s from locals and `HirId`-ification).

Author: Centril

src/librustc/hir/def_id.rs

@@ -1,5 +1,5 @@
 use crate::ty::{self, TyCtxt};
-use crate::hir::map::definitions::FIRST_FREE_HIGH_DEF_INDEX;
+use crate::hir::map::definitions::FIRST_FREE_DEF_INDEX;
 use rustc_data_structures::indexed_vec::Idx;
 use serialize;
 use std::fmt;
@@ -99,17 +99,6 @@ impl serialize::UseSpecializedDecodable for CrateNum {}
 /// A DefIndex is an index into the hir-map for a crate, identifying a
 /// particular definition. It should really be considered an interned
 /// shorthand for a particular DefPath.
-///
-/// At the moment we are allocating the numerical values of DefIndexes from two
-/// address spaces: DefIndexAddressSpace::Low and DefIndexAddressSpace::High.
-/// This allows us to allocate the DefIndexes of all item-likes
-/// (Items, TraitItems, and ImplItems) into one of these spaces and
-/// consequently use a simple array for lookup tables keyed by DefIndex and
-/// known to be densely populated. This is especially important for the HIR map.
-///
-/// Since the DefIndex is mostly treated as an opaque ID, you probably
-/// don't have to care about these address spaces.
-
 #[derive(Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Copy)]
 pub struct DefIndex(u32);
 
@@ -119,67 +108,49 @@ pub const CRATE_DEF_INDEX: DefIndex = DefIndex(0);
 
 impl fmt::Debug for DefIndex {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        write!(f,
-               "DefIndex({}:{})",
-               self.address_space().index(),
-               self.as_array_index())
+        write!(f, "DefIndex({})", self.as_array_index())
     }
 }
 
 impl DefIndex {
-    #[inline]
-    pub fn address_space(&self) -> DefIndexAddressSpace {
-        match self.0 & 1 {
-            0 => DefIndexAddressSpace::Low,
-            1 => DefIndexAddressSpace::High,
-            _ => unreachable!()
-        }
-    }
-
     /// Converts this DefIndex into a zero-based array index.
-    /// This index is the offset within the given DefIndexAddressSpace.
     #[inline]
     pub fn as_array_index(&self) -> usize {
-        (self.0 >> 1) as usize
+        self.0 as usize
     }
 
     #[inline]
-    pub fn from_array_index(i: usize, address_space: DefIndexAddressSpace) -> DefIndex {
-        DefIndex::from_raw_u32(((i << 1) | (address_space as usize)) as u32)
+    pub fn from_array_index(i: usize) -> DefIndex {
+        DefIndex(i as u32)
     }
 
     // Proc macros from a proc-macro crate have a kind of virtual DefIndex. This
     // function maps the index of the macro within the crate (which is also the
     // index of the macro in the CrateMetadata::proc_macros array) to the
     // corresponding DefIndex.
     pub fn from_proc_macro_index(proc_macro_index: usize) -> DefIndex {
-        // DefIndex for proc macros start from FIRST_FREE_HIGH_DEF_INDEX,
-        // because the first FIRST_FREE_HIGH_DEF_INDEX indexes are reserved
+        // DefIndex for proc macros start from FIRST_FREE_DEF_INDEX,
+        // because the first FIRST_FREE_DEF_INDEX indexes are reserved
         // for internal use.
         let def_index = DefIndex::from_array_index(
-            proc_macro_index.checked_add(FIRST_FREE_HIGH_DEF_INDEX)
-                .expect("integer overflow adding `proc_macro_index`"),
-            DefIndexAddressSpace::High);
+            proc_macro_index.checked_add(FIRST_FREE_DEF_INDEX)
+                .expect("integer overflow adding `proc_macro_index`"));
         assert!(def_index != CRATE_DEF_INDEX);
         def_index
     }
 
     // This function is the reverse of from_proc_macro_index() above.
     pub fn to_proc_macro_index(self: DefIndex) -> usize {
-        assert_eq!(self.address_space(), DefIndexAddressSpace::High);
-
-        self.as_array_index().checked_sub(FIRST_FREE_HIGH_DEF_INDEX)
+        self.as_array_index().checked_sub(FIRST_FREE_DEF_INDEX)
             .unwrap_or_else(|| {
                 bug!("using local index {:?} as proc-macro index", self)
             })
     }
 
-    // Don't use this if you don't know about the DefIndex encoding.
     pub fn from_raw_u32(x: u32) -> DefIndex {
         DefIndex(x)
     }
 
-    // Don't use this if you don't know about the DefIndex encoding.
     pub fn as_raw_u32(&self) -> u32 {
         self.0
     }
@@ -188,19 +159,6 @@ impl DefIndex {
 impl serialize::UseSpecializedEncodable for DefIndex {}
 impl serialize::UseSpecializedDecodable for DefIndex {}
 
-#[derive(Copy, Clone, Debug, PartialEq, Eq, Hash)]
-pub enum DefIndexAddressSpace {
-    Low = 0,
-    High = 1,
-}
-
-impl DefIndexAddressSpace {
-    #[inline]
-    pub fn index(&self) -> usize {
-        *self as usize
-    }
-}
-
 /// A `DefId` identifies a particular *definition*, by combining a crate
 /// index and a def index.
 #[derive(Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Copy)]
@@ -211,10 +169,7 @@ pub struct DefId {
 
 impl fmt::Debug for DefId {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        write!(f, "DefId({}/{}:{}",
-               self.krate,
-               self.index.address_space().index(),
-               self.index.as_array_index())?;
+        write!(f, "DefId({}:{}", self.krate, self.index.as_array_index())?;
 
         ty::tls::with_opt(|opt_tcx| {
             if let Some(tcx) = opt_tcx {

src/librustc/hir/lowering.rs

@@ -36,7 +36,7 @@ use crate::dep_graph::DepGraph;
 use crate::hir::{self, ParamName};
 use crate::hir::HirVec;
 use crate::hir::map::{DefKey, DefPathData, Definitions};
-use crate::hir::def_id::{DefId, DefIndex, DefIndexAddressSpace, CRATE_DEF_INDEX};
+use crate::hir::def_id::{DefId, DefIndex, CRATE_DEF_INDEX};
 use crate::hir::def::{Res, DefKind, PartialRes, PerNS};
 use crate::hir::{GenericArg, ConstArg};
 use crate::lint::builtin::{self, PARENTHESIZED_PARAMS_IN_TYPES_AND_MODULES,
@@ -418,7 +418,6 @@ impl<'a> LoweringContext<'a> {
                                 owner,
                                 id,
                                 DefPathData::Misc,
-                                DefIndexAddressSpace::High,
                                 Mark::root(),
                                 tree.prefix.span,
                             );
@@ -962,7 +961,6 @@ impl<'a> LoweringContext<'a> {
             parent_index,
             node_id,
             DefPathData::LifetimeNs(str_name),
-            DefIndexAddressSpace::High,
             Mark::root(),
             span,
         );
@@ -1763,7 +1761,6 @@ impl<'a> LoweringContext<'a> {
                         self.parent,
                         def_node_id,
                         DefPathData::LifetimeNs(name.ident().as_interned_str()),
-                        DefIndexAddressSpace::High,
                         Mark::root(),
                         lifetime.span,
                     );

src/librustc/hir/map/collector.rs

@@ -145,15 +145,10 @@ impl<'a, 'hir> NodeCollector<'a, 'hir> {
             );
         }
 
-        let (lo, hi) = definitions.def_index_counts_lo_hi();
-
         let mut collector = NodeCollector {
             krate,
             source_map: sess.source_map(),
-            map: [
-                repeat(None).take(lo).collect(),
-                repeat(None).take(hi).collect(),
-            ],
+            map: vec![None; definitions.def_index_count()],
             parent_node: hir::CRATE_HIR_ID,
             current_signature_dep_index: root_mod_sig_dep_index,
             current_full_dep_index: root_mod_full_dep_index,
@@ -231,7 +226,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.address_space().index()][id.owner.as_array_index()];
+        let local_map = &mut self.map[id.owner.as_array_index()];
         let i = id.local_id.as_u32() as usize;
         if local_map.is_none() {
             *local_map = Some(IndexVec::with_capacity(i + 1));

src/librustc/hir/map/def_collector.rs

@@ -1,5 +1,5 @@
 use crate::hir::map::definitions::*;
-use crate::hir::def_id::{CRATE_DEF_INDEX, DefIndex, DefIndexAddressSpace};
+use crate::hir::def_id::{CRATE_DEF_INDEX, DefIndex};
 use crate::session::CrateDisambiguator;
 
 use syntax::ast::*;
@@ -10,8 +10,6 @@ use syntax::symbol::Symbol;
 use syntax::parse::token::{self, Token};
 use syntax_pos::Span;
 
-use crate::hir::map::{ITEM_LIKE_SPACE, REGULAR_SPACE};
-
 /// Creates `DefId`s for nodes in the AST.
 pub struct DefCollector<'a> {
     definitions: &'a mut Definitions,
@@ -47,13 +45,12 @@ impl<'a> DefCollector<'a> {
     fn create_def(&mut self,
                   node_id: NodeId,
                   data: DefPathData,
-                  address_space: DefIndexAddressSpace,
                   span: Span)
                   -> DefIndex {
         let parent_def = self.parent_def.unwrap();
         debug!("create_def(node_id={:?}, data={:?}, parent_def={:?})", node_id, data, parent_def);
         self.definitions
-            .create_def_with_parent(parent_def, node_id, data, address_space, self.expansion, span)
+            .create_def_with_parent(parent_def, node_id, data, self.expansion, span)
     }
 
     pub fn with_parent<F: FnOnce(&mut Self)>(&mut self, parent_def: DefIndex, f: F) {
@@ -85,9 +82,9 @@ impl<'a> DefCollector<'a> {
         // For async functions, we need to create their inner defs inside of a
         // closure to match their desugared representation.
         let fn_def_data = DefPathData::ValueNs(name.as_interned_str());
-        let fn_def = self.create_def(id, fn_def_data, ITEM_LIKE_SPACE, span);
+        let fn_def = self.create_def(id, fn_def_data, span);
         return self.with_parent(fn_def, |this| {
-            this.create_def(*return_impl_trait_id, DefPathData::ImplTrait, REGULAR_SPACE, span);
+            this.create_def(*return_impl_trait_id, DefPathData::ImplTrait, span);
 
             visit::walk_generics(this, generics);
 
@@ -106,7 +103,7 @@ impl<'a> DefCollector<'a> {
             visit::walk_fn_ret_ty(this, &decl.output);
 
             let closure_def = this.create_def(
-                *closure_id, DefPathData::ClosureExpr, REGULAR_SPACE, span,
+                *closure_id, DefPathData::ClosureExpr, span,
             );
             this.with_parent(closure_def, |this| {
                 use visit::Visitor;
@@ -173,14 +170,14 @@ impl<'a> visit::Visitor<'a> for DefCollector<'a> {
                 return visit::walk_item(self, i);
             }
         };
-        let def = self.create_def(i.id, def_data, ITEM_LIKE_SPACE, i.span);
+        let def = self.create_def(i.id, def_data, i.span);
 
         self.with_parent(def, |this| {
             match i.node {
                 ItemKind::Struct(ref struct_def, _) | ItemKind::Union(ref struct_def, _) => {
                     // If this is a unit or tuple-like struct, register the constructor.
                     if let Some(ctor_hir_id) = struct_def.ctor_id() {
-                        this.create_def(ctor_hir_id, DefPathData::Ctor, REGULAR_SPACE, i.span);
+                        this.create_def(ctor_hir_id, DefPathData::Ctor, i.span);
                     }
                 }
                 _ => {}
@@ -190,7 +187,7 @@ impl<'a> visit::Visitor<'a> for DefCollector<'a> {
     }
 
     fn visit_use_tree(&mut self, use_tree: &'a UseTree, id: NodeId, _nested: bool) {
-        self.create_def(id, DefPathData::Misc, ITEM_LIKE_SPACE, use_tree.span);
+        self.create_def(id, DefPathData::Misc, use_tree.span);
         visit::walk_use_tree(self, use_tree, id);
     }
 
@@ -201,7 +198,6 @@ impl<'a> visit::Visitor<'a> for DefCollector<'a> {
 
         let def = self.create_def(foreign_item.id,
                                   DefPathData::ValueNs(foreign_item.ident.as_interned_str()),
-                                  REGULAR_SPACE,
                                   foreign_item.span);
 
         self.with_parent(def, |this| {
@@ -212,11 +208,10 @@ impl<'a> visit::Visitor<'a> for DefCollector<'a> {
     fn visit_variant(&mut self, v: &'a Variant, g: &'a Generics, item_id: NodeId) {
         let def = self.create_def(v.node.id,
                                   DefPathData::TypeNs(v.node.ident.as_interned_str()),
-                                  REGULAR_SPACE,
                                   v.span);
         self.with_parent(def, |this| {
             if let Some(ctor_hir_id) = v.node.data.ctor_id() {
-                this.create_def(ctor_hir_id, DefPathData::Ctor, REGULAR_SPACE, v.span);
+                this.create_def(ctor_hir_id, DefPathData::Ctor, v.span);
             }
             visit::walk_variant(this, v, g, item_id)
         });
@@ -229,7 +224,6 @@ impl<'a> visit::Visitor<'a> for DefCollector<'a> {
                 .unwrap_or_else(|| Symbol::intern(&index.to_string()));
             let def = self.create_def(field.id,
                                       DefPathData::ValueNs(name.as_interned_str()),
-                                      REGULAR_SPACE,
                                       field.span);
             self.with_parent(def, |this| this.visit_struct_field(field));
         }
@@ -242,7 +236,7 @@ impl<'a> visit::Visitor<'a> for DefCollector<'a> {
             GenericParamKind::Type { .. } => DefPathData::TypeNs(name),
             GenericParamKind::Const { .. } => DefPathData::ValueNs(name),
         };
-        self.create_def(param.id, def_path_data, REGULAR_SPACE, param.ident.span);
+        self.create_def(param.id, def_path_data, param.ident.span);
 
         visit::walk_generic_param(self, param);
     }
@@ -257,7 +251,7 @@ impl<'a> visit::Visitor<'a> for DefCollector<'a> {
             TraitItemKind::Macro(..) => return self.visit_macro_invoc(ti.id),
         };
 
-        let def = self.create_def(ti.id, def_data, ITEM_LIKE_SPACE, ti.span);
+        let def = self.create_def(ti.id, def_data, ti.span);
         self.with_parent(def, |this| visit::walk_trait_item(this, ti));
     }
 
@@ -286,7 +280,7 @@ impl<'a> visit::Visitor<'a> for DefCollector<'a> {
             ImplItemKind::Macro(..) => return self.visit_macro_invoc(ii.id),
         };
 
-        let def = self.create_def(ii.id, def_data, ITEM_LIKE_SPACE, ii.span);
+        let def = self.create_def(ii.id, def_data, ii.span);
         self.with_parent(def, |this| visit::walk_impl_item(this, ii));
     }
 
@@ -300,7 +294,6 @@ impl<'a> visit::Visitor<'a> for DefCollector<'a> {
     fn visit_anon_const(&mut self, constant: &'a AnonConst) {
         let def = self.create_def(constant.id,
                                   DefPathData::AnonConst,
-                                  REGULAR_SPACE,
                                   constant.value.span);
         self.with_parent(def, |this| visit::walk_anon_const(this, constant));
     }
@@ -313,7 +306,6 @@ impl<'a> visit::Visitor<'a> for DefCollector<'a> {
             ExprKind::Closure(_, ref asyncness, ..) => {
                 let closure_def = self.create_def(expr.id,
                                           DefPathData::ClosureExpr,
-                                          REGULAR_SPACE,
                                           expr.span);
                 self.parent_def = Some(closure_def);
 
@@ -322,15 +314,13 @@ impl<'a> visit::Visitor<'a> for DefCollector<'a> {
                 if let IsAsync::Async { closure_id, .. } = asyncness {
                     let async_def = self.create_def(*closure_id,
                                                     DefPathData::ClosureExpr,
-                                                    REGULAR_SPACE,
                                                     expr.span);
                     self.parent_def = Some(async_def);
                 }
             }
             ExprKind::Async(_, async_id, _) => {
                 let async_def = self.create_def(async_id,
                                                 DefPathData::ClosureExpr,
-                                                REGULAR_SPACE,
                                                 expr.span);
                 self.parent_def = Some(async_def);
             }
@@ -345,7 +335,7 @@ impl<'a> visit::Visitor<'a> for DefCollector<'a> {
         match ty.node {
             TyKind::Mac(..) => return self.visit_macro_invoc(ty.id),
             TyKind::ImplTrait(node_id, _) => {
-                self.create_def(node_id, DefPathData::ImplTrait, REGULAR_SPACE, ty.span);
+                self.create_def(node_id, DefPathData::ImplTrait, ty.span);
             }
             _ => {}
         }