Rollup merge of #68424 - estebank:suggest-borrow-for-non-copy-vec, r=davidtwco

[rust.git] / src / librustc_index / vec.rs

diff --git a/src/librustc_index/vec.rs b/src/librustc_index/vec.rs
index 84b460bf5717edd81f46305d1537cff5ee4f9e3e..d14bafb44fd5b519c1ded8c80b32965ddd8bc97e 100644 (file)
--- a/src/librustc_index/vec.rs
+++ b/src/librustc_index/vec.rs
@@ -1,14 +1,14 @@
-use rustc_serialize::{Encodable, Decodable, Encoder, Decoder};
+use rustc_serialize::{Decodable, Decoder, Encodable, Encoder};
 
+use std::fmt;
 use std::fmt::Debug;
+use std::hash::Hash;
 use std::iter::{self, FromIterator};
-use std::slice;
 use std::marker::PhantomData;
 use std::ops::{Index, IndexMut, Range, RangeBounds};
-use std::fmt;
-use std::hash::Hash;
-use std::vec;
+use std::slice;
 use std::u32;
+use std::vec;
 
 /// Represents some newtyped `usize` wrapper.
 ///
@@ -29,16 +29,25 @@ fn plus(self, amount: usize) -> Self {
 
 impl Idx for usize {
     #[inline]
-    fn new(idx: usize) -> Self { idx }
+    fn new(idx: usize) -> Self {
+        idx
+    }
     #[inline]
-    fn index(self) -> usize { self }
+    fn index(self) -> usize {
+        self
+    }
 }
 
 impl Idx for u32 {
     #[inline]
-    fn new(idx: usize) -> Self { assert!(idx <= u32::MAX as usize); idx as u32 }
+    fn new(idx: usize) -> Self {
+        assert!(idx <= u32::MAX as usize);
+        idx as u32
+    }
     #[inline]
-    fn index(self) -> usize { self as usize }
+    fn index(self) -> usize {
+        self as usize
+    }
 }
 
 /// Creates a struct type `S` that can be used as an index with
@@ -111,13 +120,13 @@ fn clone(&self) -> Self {
         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)
                 }
             }
 
@@ -125,7 +134,7 @@ impl $type {
             $v fn from_u32(value: u32) -> Self {
                 assert!(value <= $max);
                 unsafe {
-                    $type::from_u32_unchecked(value)
+                    Self::from_u32_unchecked(value)
                 }
             }
 
@@ -143,13 +152,13 @@ impl $type {
                 ];
 
                 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.
@@ -175,14 +184,14 @@ impl std::ops::Add<usize> for $type {
             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]
@@ -195,39 +204,39 @@ impl ::std::iter::Step for $type {
             #[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)
             }
         }
 
@@ -248,14 +257,14 @@ fn from(v: $type) -> usize {
         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)
             }
         }
 
@@ -400,7 +409,7 @@ fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
     (@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)
             }
         }
     );
@@ -491,7 +500,7 @@ fn decode<D: ::rustc_serialize::Decoder>(d: &mut D) -> Result<Self, D::Error> {
                    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])*]
@@ -506,7 +515,7 @@ fn decode<D: ::rustc_serialize::Decoder>(d: &mut D) -> Result<Self, D::Error> {
 #[derive(Clone, PartialEq, Eq, Hash)]
 pub struct IndexVec<I: Idx, T> {
     pub raw: Vec<T>,
-    _marker: PhantomData<fn(&I)>
+    _marker: PhantomData<fn(&I)>,
 }
 
 // Whether `IndexVec` is `Send` depends only on the data,
@@ -521,9 +530,7 @@ fn encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> {
 
 impl<I: Idx, T: Decodable> Decodable for IndexVec<I, T> {
     fn decode<D: Decoder>(d: &mut D) -> Result<Self, D::Error> {
-        Decodable::decode(d).map(|v| {
-            IndexVec { raw: v, _marker: PhantomData }
-        })
+        Decodable::decode(d).map(|v| IndexVec { raw: v, _marker: PhantomData })
     }
 }
 
@@ -553,14 +560,16 @@ pub fn with_capacity(capacity: usize) -> Self {
 
     #[inline]
     pub fn from_elem<S>(elem: T, universe: &IndexVec<I, S>) -> Self
-        where T: Clone
+    where
+        T: Clone,
     {
         IndexVec { raw: vec![elem; universe.len()], _marker: PhantomData }
     }
 
     #[inline]
     pub fn from_elem_n(elem: T, n: usize) -> Self
-        where T: Clone
+    where
+        T: Clone,
     {
         IndexVec { raw: vec![elem; n], _marker: PhantomData }
     }
@@ -600,8 +609,7 @@ pub fn into_iter(self) -> vec::IntoIter<T> {
     }
 
     #[inline]
-    pub fn into_iter_enumerated(self) -> Enumerated<I, vec::IntoIter<T>>
-    {
+    pub fn into_iter_enumerated(self) -> Enumerated<I, vec::IntoIter<T>> {
         self.raw.into_iter().enumerate().map(IntoIdx { _marker: PhantomData })
     }
 
@@ -611,8 +619,7 @@ pub fn iter(&self) -> slice::Iter<'_, T> {
     }
 
     #[inline]
-    pub fn iter_enumerated(&self) -> Enumerated<I, slice::Iter<'_, T>>
-    {
+    pub fn iter_enumerated(&self) -> Enumerated<I, slice::Iter<'_, T>> {
         self.raw.iter().enumerate().map(IntoIdx { _marker: PhantomData })
     }
 
@@ -627,22 +634,23 @@ pub fn iter_mut(&mut self) -> slice::IterMut<'_, T> {
     }
 
     #[inline]
-    pub fn iter_enumerated_mut(&mut self) -> Enumerated<I, slice::IterMut<'_, T>>
-    {
+    pub fn iter_enumerated_mut(&mut self) -> Enumerated<I, slice::IterMut<'_, T>> {
         self.raw.iter_mut().enumerate().map(IntoIdx { _marker: PhantomData })
     }
 
     #[inline]
-    pub fn drain<'a, R: RangeBounds<usize>>(&'a mut self, range: R)
-        -> impl Iterator<Item=T> + ExactSizeIterator + 'a
-    {
+    pub fn drain<'a, R: RangeBounds<usize>>(
+        &'a mut self,
+        range: R,
+    ) -> impl Iterator<Item = T> + 'a {
         self.raw.drain(range)
     }
 
     #[inline]
-    pub fn drain_enumerated<'a, R: RangeBounds<usize>>(&'a mut self, range: R)
-        -> impl Iterator<Item=(I, T)> + ExactSizeIterator + 'a
-    {
+    pub fn drain_enumerated<'a, R: RangeBounds<usize>>(
+        &'a mut self,
+        range: R,
+    ) -> impl Iterator<Item = (I, T)> + 'a {
         self.raw.drain(range).enumerate().map(IntoIdx { _marker: PhantomData })
     }
 
@@ -692,10 +700,7 @@ pub fn pick2_mut(&mut self, a: I, b: I) -> (&mut T, &mut T) {
     }
 
     pub fn convert_index_type<Ix: Idx>(self) -> IndexVec<Ix, T> {
-        IndexVec {
-            raw: self.raw,
-            _marker: PhantomData,
-        }
+        IndexVec { raw: self.raw, _marker: PhantomData }
     }
 }
 
@@ -766,7 +771,10 @@ fn extend<J: IntoIterator<Item = T>>(&mut self, iter: J) {
 
 impl<I: Idx, T> FromIterator<T> for IndexVec<I, T> {
     #[inline]
-    fn from_iter<J>(iter: J) -> Self where J: IntoIterator<Item=T> {
+    fn from_iter<J>(iter: J) -> Self
+    where
+        J: IntoIterator<Item = T>,
+    {
         IndexVec { raw: FromIterator::from_iter(iter), _marker: PhantomData }
     }
 }
@@ -779,7 +787,6 @@ impl<I: Idx, T> IntoIterator for IndexVec<I, T> {
     fn into_iter(self) -> vec::IntoIter<T> {
         self.raw.into_iter()
     }
-
 }
 
 impl<'a, I: Idx, T> IntoIterator for &'a IndexVec<I, T> {
@@ -802,7 +809,9 @@ fn into_iter(self) -> slice::IterMut<'a, T> {
     }
 }
 
-pub struct IntoIdx<I: Idx> { _marker: PhantomData<fn(&I)> }
+pub struct IntoIdx<I: Idx> {
+    _marker: PhantomData<fn(&I)>,
+}
 impl<I: Idx, T> FnOnce<((usize, T),)> for IntoIdx<I> {
     type Output = (I, T);
 
@@ -830,3 +839,6 @@ extern "rust-call" fn call_mut(&mut self, (n,): (usize,)) -> Self::Output {
         I::new(n)
     }
 }
+
+#[cfg(test)]
+mod tests;