Improve hygiene of newtype_index

matthewjasper · matthewjasper · commit 9462c8babb87 · 2020-01-06T20:43:10.000Z
Also add unit tests
diff --git a/src/librustc/dep_graph/serialized.rs b/src/librustc/dep_graph/serialized.rs
@@ -2,7 +2,7 @@
 
 use crate::dep_graph::DepNode;
 use crate::ich::Fingerprint;
-use rustc_index::vec::{Idx, IndexVec};
+use rustc_index::vec::IndexVec;
 
 rustc_index::newtype_index! {
     pub struct SerializedDepNodeIndex { .. }
diff --git a/src/librustc/middle/region.rs b/src/librustc/middle/region.rs
@@ -14,7 +14,6 @@ use rustc_hir::Node;
 
 use rustc_data_structures::fx::FxHashMap;
 use rustc_data_structures::stable_hasher::{HashStable, StableHasher};
-use rustc_index::vec::Idx;
 use rustc_macros::HashStable;
 use rustc_span::{Span, DUMMY_SP};
 
diff --git a/src/librustc_hir/hir_id.rs b/src/librustc_hir/hir_id.rs
@@ -56,7 +56,6 @@ impl fmt::Display for HirId {
 rustc_data_structures::define_id_collections!(HirIdMap, HirIdSet, HirId);
 rustc_data_structures::define_id_collections!(ItemLocalMap, ItemLocalSet, ItemLocalId);
 
-use rustc_index::vec::Idx;
 rustc_index::newtype_index! {
     /// An `ItemLocalId` uniquely identifies something within a given "item-like";
     /// that is, within a `hir::Item`, `hir::TraitItem`, or `hir::ImplItem`. There is no
diff --git a/src/librustc_index/vec.rs b/src/librustc_index/vec.rs
@@ -120,21 +120,21 @@ macro_rules! newtype_index {
         impl $type {
             $v const MAX_AS_U32: u32 = $max;
 
-            $v const MAX: $type = $type::from_u32_const($max);
+            $v const MAX: Self = Self::from_u32_const($max);
 
             #[inline]
             $v fn from_usize(value: usize) -> Self {
                 assert!(value <= ($max as usize));
                 unsafe {
-                    $type::from_u32_unchecked(value as u32)
+                    Self::from_u32_unchecked(value as u32)
                 }
             }
 
             #[inline]
             $v fn from_u32(value: u32) -> Self {
                 assert!(value <= $max);
                 unsafe {
-                    $type::from_u32_unchecked(value)
+                    Self::from_u32_unchecked(value)
                 }
             }
 
@@ -152,13 +152,13 @@ macro_rules! newtype_index {
                 ];
 
                 unsafe {
-                    $type { private: value }
+                    Self { private: value }
                 }
             }
 
             #[inline]
             $v const unsafe fn from_u32_unchecked(value: u32) -> Self {
-                $type { private: value }
+                Self { private: value }
             }
 
             /// Extracts the value of this index as an integer.
@@ -184,14 +184,14 @@ macro_rules! newtype_index {
             type Output = Self;
 
             fn add(self, other: usize) -> Self {
-                Self::new(self.index() + other)
+                Self::from_usize(self.index() + other)
             }
         }
 
-        impl Idx for $type {
+        impl $crate::vec::Idx for $type {
             #[inline]
             fn new(value: usize) -> Self {
-                Self::from(value)
+                Self::from_usize(value)
             }
 
             #[inline]
@@ -204,39 +204,39 @@ macro_rules! newtype_index {
             #[inline]
             fn steps_between(start: &Self, end: &Self) -> Option<usize> {
                 <usize as ::std::iter::Step>::steps_between(
-                    &Idx::index(*start),
-                    &Idx::index(*end),
+                    &Self::index(*start),
+                    &Self::index(*end),
                 )
             }
 
             #[inline]
             fn replace_one(&mut self) -> Self {
-                ::std::mem::replace(self, Self::new(1))
+                ::std::mem::replace(self, Self::from_u32(1))
             }
 
             #[inline]
             fn replace_zero(&mut self) -> Self {
-                ::std::mem::replace(self, Self::new(0))
+                ::std::mem::replace(self, Self::from_u32(0))
             }
 
             #[inline]
             fn add_one(&self) -> Self {
-                Self::new(Idx::index(*self) + 1)
+                Self::from_usize(Self::index(*self) + 1)
             }
 
             #[inline]
             fn sub_one(&self) -> Self {
-                Self::new(Idx::index(*self) - 1)
+                Self::from_usize(Self::index(*self) - 1)
             }
 
             #[inline]
             fn add_usize(&self, u: usize) -> Option<Self> {
-                Idx::index(*self).checked_add(u).map(Self::new)
+                Self::index(*self).checked_add(u).map(Self::from_usize)
             }
 
             #[inline]
             fn sub_usize(&self, u: usize) -> Option<Self> {
-                Idx::index(*self).checked_sub(u).map(Self::new)
+                Self::index(*self).checked_sub(u).map(Self::from_usize)
             }
         }
 
@@ -257,14 +257,14 @@ macro_rules! newtype_index {
         impl From<usize> for $type {
             #[inline]
             fn from(value: usize) -> Self {
-                $type::from_usize(value)
+                Self::from_usize(value)
             }
         }
 
         impl From<u32> for $type {
             #[inline]
             fn from(value: u32) -> Self {
-                $type::from_u32(value)
+                Self::from_u32(value)
             }
         }
 
@@ -409,7 +409,7 @@ macro_rules! newtype_index {
     (@decodable $type:ident) => (
         impl ::rustc_serialize::Decodable for $type {
             fn decode<D: ::rustc_serialize::Decoder>(d: &mut D) -> Result<Self, D::Error> {
-                d.read_u32().map(Self::from)
+                d.read_u32().map(Self::from_u32)
             }
         }
     );
@@ -500,7 +500,7 @@ macro_rules! newtype_index {
                    const $name:ident = $constant:expr,
                    $($tokens:tt)*) => (
         $(#[doc = $doc])*
-        pub const $name: $type = $type::from_u32_const($constant);
+        $v const $name: $type = $type::from_u32_const($constant);
         $crate::newtype_index!(
             @derives      [$($derives,)*]
             @attrs        [$(#[$attrs])*]
@@ -839,3 +839,6 @@ impl<I: Idx> FnMut<(usize,)> for IntoIdx<I> {
         I::new(n)
     }
 }
+
+#[cfg(test)]
+mod tests;
diff --git a/src/librustc_index/vec/tests.rs b/src/librustc_index/vec/tests.rs
@@ -0,0 +1,51 @@
+#![allow(dead_code)]
+newtype_index!(struct MyIdx { MAX = 0xFFFF_FFFA });
+
+#[test]
+fn index_size_is_optimized() {
+    use std::mem::size_of;
+
+    assert_eq!(size_of::<MyIdx>(), 4);
+    // Uses 0xFFFF_FFFB
+    assert_eq!(size_of::<Option<MyIdx>>(), 4);
+    // Uses 0xFFFF_FFFC
+    assert_eq!(size_of::<Option<Option<MyIdx>>>(), 4);
+    // Uses 0xFFFF_FFFD
+    assert_eq!(size_of::<Option<Option<Option<MyIdx>>>>(), 4);
+    // Uses 0xFFFF_FFFE
+    assert_eq!(size_of::<Option<Option<Option<Option<MyIdx>>>>>(), 4);
+    // Uses 0xFFFF_FFFF
+    assert_eq!(size_of::<Option<Option<Option<Option<Option<MyIdx>>>>>>(), 4);
+    // Uses a tag
+    assert_eq!(size_of::<Option<Option<Option<Option<Option<Option<MyIdx>>>>>>>(), 8);
+}
+
+#[test]
+fn range_iterator_iterates_forwards() {
+    let range = MyIdx::from_u32(1)..MyIdx::from_u32(4);
+    assert_eq!(
+        range.collect::<Vec<_>>(),
+        [MyIdx::from_u32(1), MyIdx::from_u32(2), MyIdx::from_u32(3)]
+    );
+}
+
+#[test]
+fn range_iterator_iterates_backwards() {
+    let range = MyIdx::from_u32(1)..MyIdx::from_u32(4);
+    assert_eq!(
+        range.rev().collect::<Vec<_>>(),
+        [MyIdx::from_u32(3), MyIdx::from_u32(2), MyIdx::from_u32(1)]
+    );
+}
+
+#[test]
+fn range_count_is_correct() {
+    let range = MyIdx::from_u32(1)..MyIdx::from_u32(4);
+    assert_eq!(range.count(), 3);
+}
+
+#[test]
+fn range_size_hint_is_correct() {
+    let range = MyIdx::from_u32(1)..MyIdx::from_u32(4);
+    assert_eq!(range.size_hint(), (3, Some(3)));
+}
diff --git a/src/librustc_mir/borrow_check/constraints/mod.rs b/src/librustc_mir/borrow_check/constraints/mod.rs
@@ -1,7 +1,7 @@
 use rustc::mir::ConstraintCategory;
 use rustc::ty::RegionVid;
 use rustc_data_structures::graph::scc::Sccs;
-use rustc_index::vec::{Idx, IndexVec};
+use rustc_index::vec::IndexVec;
 use std::fmt;
 use std::ops::Index;
 
diff --git a/src/librustc_mir/borrow_check/member_constraints.rs b/src/librustc_mir/borrow_check/member_constraints.rs
@@ -2,7 +2,7 @@ use crate::rustc::ty::{self, Ty};
 use rustc::infer::region_constraints::MemberConstraint;
 use rustc_data_structures::fx::FxHashMap;
 use rustc_hir::def_id::DefId;
-use rustc_index::vec::{Idx, IndexVec};
+use rustc_index::vec::IndexVec;
 use rustc_span::Span;
 use std::hash::Hash;
 use std::ops::Index;
diff --git a/src/librustc_mir/borrow_check/type_check/liveness/local_use_map.rs b/src/librustc_mir/borrow_check/type_check/liveness/local_use_map.rs
@@ -1,7 +1,7 @@
 use rustc::mir::visit::{PlaceContext, Visitor};
 use rustc::mir::{Local, Location, ReadOnlyBodyAndCache};
 use rustc_data_structures::vec_linked_list as vll;
-use rustc_index::vec::{Idx, IndexVec};
+use rustc_index::vec::IndexVec;
 
 use crate::util::liveness::{categorize, DefUse};
 
diff --git a/src/librustc_mir/dataflow/impls/borrows.rs b/src/librustc_mir/dataflow/impls/borrows.rs
@@ -4,7 +4,7 @@ use rustc::ty::{self, TyCtxt};
 
 use rustc_data_structures::fx::FxHashMap;
 use rustc_index::bit_set::BitSet;
-use rustc_index::vec::{Idx, IndexVec};
+use rustc_index::vec::IndexVec;
 
 use crate::borrow_check::{
     places_conflict, BorrowData, BorrowSet, PlaceConflictBias, PlaceExt, RegionInferenceContext,
diff --git a/src/librustc_mir/dataflow/move_paths/mod.rs b/src/librustc_mir/dataflow/move_paths/mod.rs
@@ -2,7 +2,7 @@ use core::slice::Iter;
 use rustc::mir::*;
 use rustc::ty::{ParamEnv, Ty, TyCtxt};
 use rustc_data_structures::fx::FxHashMap;
-use rustc_index::vec::{Enumerated, Idx, IndexVec};
+use rustc_index::vec::{Enumerated, IndexVec};
 use rustc_span::Span;
 use smallvec::SmallVec;
 
diff --git a/src/librustc_session/node_id.rs b/src/librustc_session/node_id.rs
@@ -1,4 +1,3 @@
-use rustc_index::vec::Idx;
 use rustc_serialize::{Decoder, Encoder};
 use rustc_span::ExpnId;
 use std::fmt;
diff --git a/src/librustc_span/symbol.rs b/src/librustc_span/symbol.rs
@@ -5,7 +5,6 @@
 use arena::DroplessArena;
 use rustc_data_structures::fx::FxHashMap;
 use rustc_data_structures::stable_hasher::{HashStable, StableHasher, ToStableHashKey};
-use rustc_index::vec::Idx;
 use rustc_macros::{symbols, HashStable_Generic};
 use rustc_serialize::{Decodable, Decoder, Encodable, Encoder};
 use rustc_serialize::{UseSpecializedDecodable, UseSpecializedEncodable};
diff --git a/src/test/ui-fulldeps/newtype_index.rs b/src/test/ui-fulldeps/newtype_index.rs

Original file line number	Diff line number	Diff line change
`@@ -120,21 +120,21 @@ macro_rules! newtype_index {`
`120`	`120`	`impl $type {`
`121`	`121`	`$v const MAX_AS_U32: u32 = $max;`
`122`	`122`
`123`		`- $v const MAX: $type = $type::from_u32_const($max);`
	`123`	`+ $v const MAX: Self = Self::from_u32_const($max);`
`124`	`124`
`125`	`125`	`#[inline]`
`126`	`126`	`$v fn from_usize(value: usize) -> Self {`
`127`	`127`	`assert!(value <= ($max as usize));`
`128`	`128`	`unsafe {`
`129`		`- $type::from_u32_unchecked(value as u32)`
	`129`	`+ Self::from_u32_unchecked(value as u32)`
`130`	`130`	`}`
`131`	`131`	`}`
`132`	`132`
`133`	`133`	`#[inline]`
`134`	`134`	`$v fn from_u32(value: u32) -> Self {`
`135`	`135`	`assert!(value <= $max);`
`136`	`136`	`unsafe {`
`137`		`- $type::from_u32_unchecked(value)`
	`137`	`+ Self::from_u32_unchecked(value)`
`138`	`138`	`}`
`139`	`139`	`}`
`140`	`140`
`@@ -152,13 +152,13 @@ macro_rules! newtype_index {`
`152`	`152`	`];`
`153`	`153`
`154`	`154`	`unsafe {`
`155`		`- $type { private: value }`
	`155`	`+ Self { private: value }`
`156`	`156`	`}`
`157`	`157`	`}`
`158`	`158`
`159`	`159`	`#[inline]`
`160`	`160`	`$v const unsafe fn from_u32_unchecked(value: u32) -> Self {`
`161`		`- $type { private: value }`
	`161`	`+ Self { private: value }`
`162`	`162`	`}`
`163`	`163`
`164`	`164`	`/// Extracts the value of this index as an integer.`
`@@ -184,14 +184,14 @@ macro_rules! newtype_index {`
`184`	`184`	`type Output = Self;`
`185`	`185`
`186`	`186`	`fn add(self, other: usize) -> Self {`
`187`		`- Self::new(self.index() + other)`
	`187`	`+ Self::from_usize(self.index() + other)`
`188`	`188`	`}`
`189`	`189`	`}`
`190`	`190`
`191`		`- impl Idx for $type {`
	`191`	`+ impl $crate::vec::Idx for $type {`
`192`	`192`	`#[inline]`
`193`	`193`	`fn new(value: usize) -> Self {`
`194`		`- Self::from(value)`
	`194`	`+ Self::from_usize(value)`
`195`	`195`	`}`
`196`	`196`
`197`	`197`	`#[inline]`
`@@ -204,39 +204,39 @@ macro_rules! newtype_index {`
`204`	`204`	`#[inline]`
`205`	`205`	`fn steps_between(start: &Self, end: &Self) -> Option<usize> {`
`206`	`206`	`<usize as ::std::iter::Step>::steps_between(`
`207`		`- &Idx::index(*start),`
`208`		`- &Idx::index(*end),`
	`207`	`+ &Self::index(*start),`
	`208`	`+ &Self::index(*end),`
`209`	`209`	`)`
`210`	`210`	`}`
`211`	`211`
`212`	`212`	`#[inline]`
`213`	`213`	`fn replace_one(&mut self) -> Self {`
`214`		`- ::std::mem::replace(self, Self::new(1))`
	`214`	`+ ::std::mem::replace(self, Self::from_u32(1))`
`215`	`215`	`}`
`216`	`216`
`217`	`217`	`#[inline]`
`218`	`218`	`fn replace_zero(&mut self) -> Self {`
`219`		`- ::std::mem::replace(self, Self::new(0))`
	`219`	`+ ::std::mem::replace(self, Self::from_u32(0))`
`220`	`220`	`}`
`221`	`221`
`222`	`222`	`#[inline]`
`223`	`223`	`fn add_one(&self) -> Self {`
`224`		`- Self::new(Idx::index(*self) + 1)`
	`224`	`+ Self::from_usize(Self::index(*self) + 1)`
`225`	`225`	`}`
`226`	`226`
`227`	`227`	`#[inline]`
`228`	`228`	`fn sub_one(&self) -> Self {`
`229`		`- Self::new(Idx::index(*self) - 1)`
	`229`	`+ Self::from_usize(Self::index(*self) - 1)`
`230`	`230`	`}`
`231`	`231`
`232`	`232`	`#[inline]`
`233`	`233`	`fn add_usize(&self, u: usize) -> Option<Self> {`
`234`		`- Idx::index(*self).checked_add(u).map(Self::new)`
	`234`	`+ Self::index(*self).checked_add(u).map(Self::from_usize)`
`235`	`235`	`}`
`236`	`236`
`237`	`237`	`#[inline]`
`238`	`238`	`fn sub_usize(&self, u: usize) -> Option<Self> {`
`239`		`- Idx::index(*self).checked_sub(u).map(Self::new)`
	`239`	`+ Self::index(*self).checked_sub(u).map(Self::from_usize)`
`240`	`240`	`}`
`241`	`241`	`}`
`242`	`242`
`@@ -257,14 +257,14 @@ macro_rules! newtype_index {`
`257`	`257`	`impl From<usize> for $type {`
`258`	`258`	`#[inline]`
`259`	`259`	`fn from(value: usize) -> Self {`
`260`		`- $type::from_usize(value)`
	`260`	`+ Self::from_usize(value)`
`261`	`261`	`}`
`262`	`262`	`}`
`263`	`263`
`264`	`264`	`impl From<u32> for $type {`
`265`	`265`	`#[inline]`
`266`	`266`	`fn from(value: u32) -> Self {`
`267`		`- $type::from_u32(value)`
	`267`	`+ Self::from_u32(value)`
`268`	`268`	`}`
`269`	`269`	`}`
`270`	`270`
`@@ -409,7 +409,7 @@ macro_rules! newtype_index {`
`409`	`409`	`(@decodable $type:ident) => (`
`410`	`410`	`impl ::rustc_serialize::Decodable for $type {`
`411`	`411`	`fn decode<D: ::rustc_serialize::Decoder>(d: &mut D) -> Result<Self, D::Error> {`
`412`		`- d.read_u32().map(Self::from)`
	`412`	`+ d.read_u32().map(Self::from_u32)`
`413`	`413`	`}`
`414`	`414`	`}`
`415`	`415`	`);`
`@@ -500,7 +500,7 @@ macro_rules! newtype_index {`
`500`	`500`	`const $name:ident = $constant:expr,`
`501`	`501`	`$($tokens:tt)*) => (`
`502`	`502`	`$(#[doc = $doc])*`
`503`		`- pub const $name: $type = $type::from_u32_const($constant);`
	`503`	`+ $v const $name: $type = $type::from_u32_const($constant);`
`504`	`504`	`$crate::newtype_index!(`
`505`	`505`	`@derives [$($derives,)*]`
`506`	`506`	`@attrs [$(#[$attrs])*]`
`@@ -839,3 +839,6 @@ impl<I: Idx> FnMut<(usize,)> for IntoIdx<I> {`
`839`	`839`	`I::new(n)`
`840`	`840`	`}`
`841`	`841`	`}`
	`842`	`+`
	`843`	`+#[cfg(test)]`
	`844`	`+mod tests;`