Delete Decoder::read_seq_elt

Author: Mark-Simulacrum

compiler/rustc_query_system/src/dep_graph/serialized.rs

@@ -133,7 +133,7 @@ impl<'a, K: DepKind + Decodable<opaque::Decoder<'a>>> Decodable<opaque::Decoder<
             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();

compiler/rustc_serialize/src/collection_impls.rs

@@ -18,7 +18,7 @@ impl<S: Encoder, A: Array<Item: Encodable<S>>> Encodable<S> for SmallVec<A> {
 
 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 @@ impl<S: Encoder, T: Encodable<S>> Encodable<S> for LinkedList<T> {
 
 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 @@ impl<S: Encoder, T: Encodable<S>> Encodable<S> for VecDeque<T> {
 
 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 @@ where
         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 @@ where
             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 @@ where
             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
         })

compiler/rustc_serialize/src/serialize.rs

@@ -230,14 +230,6 @@ pub trait Decoder {
         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 @@ impl<D: Decoder, const N: usize> Decodable<D> for [u8; N] {
             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
         })