Rollup of 5 pull requests

src/libcore/array.rs

@@ -4,10 +4,7 @@
 //!
 //! *[See also the array primitive type](../../std/primitive.array.html).*
 
-#![unstable(feature = "fixed_size_array",
-            reason = "traits and impls are better expressed through generic \
-                      integer constants",
-            issue = "27778")]
+#![stable(feature = "core_array", since = "1.36.0")]
 
 use crate::borrow::{Borrow, BorrowMut};
 use crate::cmp::Ordering;
@@ -30,13 +27,17 @@ use crate::slice::{Iter, IterMut};
 /// Note that the traits AsRef and AsMut provide similar methods for types that
 /// may not be fixed-size arrays. Implementors should prefer those traits
 /// instead.
+#[unstable(feature = "fixed_size_array", issue = "27778")]
 pub unsafe trait FixedSizeArray<T> {
     /// Converts the array to immutable slice
+    #[unstable(feature = "fixed_size_array", issue = "27778")]
     fn as_slice(&self) -> &[T];
     /// Converts the array to mutable slice
+    #[unstable(feature = "fixed_size_array", issue = "27778")]
     fn as_mut_slice(&mut self) -> &mut [T];
 }
 
+#[unstable(feature = "fixed_size_array", issue = "27778")]
 unsafe impl<T, A: Unsize<[T]>> FixedSizeArray<T> for A {
     #[inline]
     fn as_slice(&self) -> &[T] {
@@ -53,6 +54,7 @@ unsafe impl<T, A: Unsize<[T]>> FixedSizeArray<T> for A {
 #[derive(Debug, Copy, Clone)]
 pub struct TryFromSliceError(());
 
+#[stable(feature = "core_array", since = "1.36.0")]
 impl fmt::Display for TryFromSliceError {
     #[inline]
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {

src/libcore/pin.rs

@@ -274,7 +274,7 @@ use crate::ops::{Deref, DerefMut, Receiver, CoerceUnsized, DispatchFromDyn};
 /// value in place, preventing the value referenced by that pointer from being moved
 /// unless it implements [`Unpin`].
 ///
-/// See the [`pin` module] documentation for further explanation on pinning.
+/// *See the [`pin` module] documentation for an explanation of pinning.*
 ///
 /// [`Unpin`]: ../../std/marker/trait.Unpin.html
 /// [`pin` module]: ../../std/pin/index.html

src/libcore/ptr.rs

@@ -974,6 +974,13 @@ impl<T: ?Sized> *const T {
         (self as *const u8) == null()
     }
 
+    /// Cast to a pointer to a different type
+    #[unstable(feature = "ptr_cast", issue = "60602")]
+    #[inline]
+    pub const fn cast<U>(self) -> *const U {
+        self as _
+    }
+
     /// Returns `None` if the pointer is null, or else returns a reference to
     /// the value wrapped in `Some`.
     ///
@@ -1593,6 +1600,13 @@ impl<T: ?Sized> *mut T {
         (self as *mut u8) == null_mut()
     }
 
+    /// Cast to a pointer to a different type
+    #[unstable(feature = "ptr_cast", issue = "60602")]
+    #[inline]
+    pub const fn cast<U>(self) -> *mut U {
+        self as _
+    }
+
     /// Returns `None` if the pointer is null, or else returns a reference to
     /// the value wrapped in `Some`.
     ///

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));