Delete Decoder::read_seq_elt

diff --git a/compiler/rustc_query_system/src/dep_graph/serialized.rs b/compiler/rustc_query_system/src/dep_graph/serialized.rs
index 29db5a9878e028b9668a554d5c38e5a064f9b0aa..2ac5d5431a5b6e728c44238753fb865318494d45 100644 (file)
--- a/compiler/rustc_query_system/src/dep_graph/serialized.rs
+++ b/compiler/rustc_query_system/src/dep_graph/serialized.rs
@@ -133,7 +133,7 @@ fn decode(d: &mut opaque::Decoder<'a>) -> SerializedDepGraph<K> {
             d.read_seq(|d, len| {
                 let start = edge_list_data.len().try_into().unwrap();
                 for _ in 0..len {
-                    let edge = d.read_seq_elt(Decodable::decode);
+                    let edge = Decodable::decode(d);
                     edge_list_data.push(edge);
                 }
                 let end = edge_list_data.len().try_into().unwrap();

diff --git a/compiler/rustc_serialize/src/collection_impls.rs b/compiler/rustc_serialize/src/collection_impls.rs
index 02b28f7c6267770b2a52759c3a98619131142d9a..e53a6dc47b40ae5c760d945810c39dd76b803b47 100644 (file)
--- a/compiler/rustc_serialize/src/collection_impls.rs
+++ b/compiler/rustc_serialize/src/collection_impls.rs
@@ -18,7 +18,7 @@ fn encode(&self, s: &mut S) -> Result<(), S::Error> {
 
 impl<D: Decoder, A: Array<Item: Decodable<D>>> Decodable<D> for SmallVec<A> {
     fn decode(d: &mut D) -> SmallVec<A> {
-        d.read_seq(|d, len| (0..len).map(|_| d.read_seq_elt(|d| Decodable::decode(d))).collect())
+        d.read_seq(|d, len| (0..len).map(|_| Decodable::decode(d)).collect())
     }
 }
 
@@ -35,7 +35,7 @@ fn encode(&self, s: &mut S) -> Result<(), S::Error> {
 
 impl<D: Decoder, T: Decodable<D>> Decodable<D> for LinkedList<T> {
     fn decode(d: &mut D) -> LinkedList<T> {
-        d.read_seq(|d, len| (0..len).map(|_| d.read_seq_elt(|d| Decodable::decode(d))).collect())
+        d.read_seq(|d, len| (0..len).map(|_| Decodable::decode(d)).collect())
     }
 }
 
@@ -52,7 +52,7 @@ fn encode(&self, s: &mut S) -> Result<(), S::Error> {
 
 impl<D: Decoder, T: Decodable<D>> Decodable<D> for VecDeque<T> {
     fn decode(d: &mut D) -> VecDeque<T> {
-        d.read_seq(|d, len| (0..len).map(|_| d.read_seq_elt(|d| Decodable::decode(d))).collect())
+        d.read_seq(|d, len| (0..len).map(|_| Decodable::decode(d)).collect())
     }
 }
 
@@ -112,7 +112,7 @@ fn decode(d: &mut D) -> BTreeSet<T> {
         d.read_seq(|d, len| {
             let mut set = BTreeSet::new();
             for _ in 0..len {
-                set.insert(d.read_seq_elt(|d| Decodable::decode(d)));
+                set.insert(Decodable::decode(d));
             }
             set
         })
@@ -191,7 +191,7 @@ fn decode(d: &mut D) -> HashSet<T, S> {
             let state = Default::default();
             let mut set = HashSet::with_capacity_and_hasher(len, state);
             for _ in 0..len {
-                set.insert(d.read_seq_elt(|d| Decodable::decode(d)));
+                set.insert(Decodable::decode(d));
             }
             set
         })
@@ -260,7 +260,7 @@ fn decode(d: &mut D) -> indexmap::IndexSet<T, S> {
             let state = Default::default();
             let mut set = indexmap::IndexSet::with_capacity_and_hasher(len, state);
             for _ in 0..len {
-                set.insert(d.read_seq_elt(|d| Decodable::decode(d)));
+                set.insert(Decodable::decode(d));
             }
             set
         })

diff --git a/compiler/rustc_serialize/src/serialize.rs b/compiler/rustc_serialize/src/serialize.rs
index 660de8346a5bc910e3aab1cda108fae67d19fb24..9a45bc56ce17af55a2f10b8a8d7cd0c140300746 100644 (file)
--- a/compiler/rustc_serialize/src/serialize.rs
+++ b/compiler/rustc_serialize/src/serialize.rs
@@ -230,14 +230,6 @@ fn read_seq<T, F>(&mut self, f: F) -> T
         f(self, len)
     }
 
-    #[inline]
-    fn read_seq_elt<T, F>(&mut self, f: F) -> T
-    where
-        F: FnOnce(&mut Self) -> T,
-    {
-        f(self)
-    }
-
     fn read_map<T, F>(&mut self, f: F) -> T
     where
         F: FnOnce(&mut Self, usize) -> T,
@@ -449,10 +441,7 @@ impl<D: Decoder, T: Decodable<D>> Decodable<D> for Vec<T> {
             unsafe {
                 let ptr: *mut T = vec.as_mut_ptr();
                 for i in 0..len {
-                    std::ptr::write(
-                        ptr.offset(i as isize),
-                        d.read_seq_elt(|d| Decodable::decode(d)),
-                    );
+                    std::ptr::write(ptr.offset(i as isize), Decodable::decode(d));
                 }
                 vec.set_len(len);
             }
@@ -474,7 +463,7 @@ fn encode(&self, s: &mut S) -> Result<(), S::Error> {
             assert!(len == N);
             let mut v = [0u8; N];
             for i in 0..len {
-                v[i] = d.read_seq_elt(|d| Decodable::decode(d));
+                v[i] = Decodable::decode(d);
             }
             v
         })