Auto merge of #67445 - llogiq:todo, r=dtolnay

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

diff --git a/src/librustc_index/vec.rs b/src/librustc_index/vec.rs
index 6e80b48a6856016dadab3a7eb46bb2add06f0d6c..1f6a330cdc23537b7bb8334752b3fe95d28ea2c2 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
@@ -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,20 +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> + 'a {
+        &'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)> + 'a {
+        &'a mut self,
+        range: R,
+    ) -> impl Iterator<Item = (I, T)> + 'a {
         self.raw.drain(range).enumerate().map(IntoIdx { _marker: PhantomData })
     }
 
@@ -690,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 }
     }
 }
 
@@ -764,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 }
     }
 }
@@ -777,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> {
@@ -800,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);