Skip to content

Commit 42904b0

Browse files
Mark-SimulacrumMark-Simulacrum
committed
Delete Decoder::read_seq
1 parent 75614c0 commit 42904b0

File tree

3 files changed

+54
-64
lines changed

3 files changed

+54
-64
lines changed

‎compiler/rustc_query_system/src/dep_graph/serialized.rs‎

Lines changed: 10 additions & 10 deletions
Original file line numberDiff line numberDiff line change
@@ -130,16 +130,16 @@ impl<'a, K: DepKind + Decodable<opaque::Decoder<'a>>> Decodable<opaque::Decoder<
130130
let _i: SerializedDepNodeIndex = fingerprints.push(fingerprint);
131131
debug_assert_eq!(_i.index(), _index);
132132

133-
d.read_seq(|d, len| {
134-
let start = edge_list_data.len().try_into().unwrap();
135-
for _ in 0..len {
136-
let edge = Decodable::decode(d);
137-
edge_list_data.push(edge);
138-
}
139-
let end = edge_list_data.len().try_into().unwrap();
140-
let _i: SerializedDepNodeIndex = edge_list_indices.push((start, end));
141-
debug_assert_eq!(_i.index(), _index);
142-
})
133+
// Deserialize edges -- sequence of DepNodeIndex
134+
let len = d.read_usize();
135+
let start = edge_list_data.len().try_into().unwrap();
136+
for _ in 0..len {
137+
let edge = Decodable::decode(d);
138+
edge_list_data.push(edge);
139+
}
140+
let end = edge_list_data.len().try_into().unwrap();
141+
let _i: SerializedDepNodeIndex = edge_list_indices.push((start, end));
142+
debug_assert_eq!(_i.index(), _index);
143143
}
144144

145145
let index: FxHashMap<_, _> =

‎compiler/rustc_serialize/src/collection_impls.rs‎

Lines changed: 26 additions & 26 deletions
Original file line numberDiff line numberDiff line change
@@ -18,7 +18,8 @@ impl<S: Encoder, A: Array<Item: Encodable<S>>> Encodable<S> for SmallVec<A> {
1818

1919
impl<D: Decoder, A: Array<Item: Decodable<D>>> Decodable<D> for SmallVec<A> {
2020
fn decode(d: &mut D) -> SmallVec<A> {
21-
d.read_seq(|d, len| (0..len).map(|_| Decodable::decode(d)).collect())
21+
let len = d.read_usize();
22+
(0..len).map(|_| Decodable::decode(d)).collect()
2223
}
2324
}
2425

@@ -35,7 +36,8 @@ impl<S: Encoder, T: Encodable<S>> Encodable<S> for LinkedList<T> {
3536

3637
impl<D: Decoder, T: Decodable<D>> Decodable<D> for LinkedList<T> {
3738
fn decode(d: &mut D) -> LinkedList<T> {
38-
d.read_seq(|d, len| (0..len).map(|_| Decodable::decode(d)).collect())
39+
let len = d.read_usize();
40+
(0..len).map(|_| Decodable::decode(d)).collect()
3941
}
4042
}
4143

@@ -52,7 +54,8 @@ impl<S: Encoder, T: Encodable<S>> Encodable<S> for VecDeque<T> {
5254

5355
impl<D: Decoder, T: Decodable<D>> Decodable<D> for VecDeque<T> {
5456
fn decode(d: &mut D) -> VecDeque<T> {
55-
d.read_seq(|d, len| (0..len).map(|_| Decodable::decode(d)).collect())
57+
let len = d.read_usize();
58+
(0..len).map(|_| Decodable::decode(d)).collect()
5659
}
5760
}
5861

@@ -109,13 +112,12 @@ where
109112
T: Decodable<D> + PartialEq + Ord,
110113
{
111114
fn decode(d: &mut D) -> BTreeSet<T> {
112-
d.read_seq(|d, len| {
113-
let mut set = BTreeSet::new();
114-
for _ in 0..len {
115-
set.insert(Decodable::decode(d));
116-
}
117-
set
118-
})
115+
let len = d.read_usize();
116+
let mut set = BTreeSet::new();
117+
for _ in 0..len {
118+
set.insert(Decodable::decode(d));
119+
}
120+
set
119121
}
120122
}
121123

@@ -187,14 +189,13 @@ where
187189
S: BuildHasher + Default,
188190
{
189191
fn decode(d: &mut D) -> HashSet<T, S> {
190-
d.read_seq(|d, len| {
191-
let state = Default::default();
192-
let mut set = HashSet::with_capacity_and_hasher(len, state);
193-
for _ in 0..len {
194-
set.insert(Decodable::decode(d));
195-
}
196-
set
197-
})
192+
let len = d.read_usize();
193+
let state = Default::default();
194+
let mut set = HashSet::with_capacity_and_hasher(len, state);
195+
for _ in 0..len {
196+
set.insert(Decodable::decode(d));
197+
}
198+
set
198199
}
199200
}
200201

@@ -256,14 +257,13 @@ where
256257
S: BuildHasher + Default,
257258
{
258259
fn decode(d: &mut D) -> indexmap::IndexSet<T, S> {
259-
d.read_seq(|d, len| {
260-
let state = Default::default();
261-
let mut set = indexmap::IndexSet::with_capacity_and_hasher(len, state);
262-
for _ in 0..len {
263-
set.insert(Decodable::decode(d));
264-
}
265-
set
266-
})
260+
let len = d.read_usize();
261+
let state = Default::default();
262+
let mut set = indexmap::IndexSet::with_capacity_and_hasher(len, state);
263+
for _ in 0..len {
264+
set.insert(Decodable::decode(d));
265+
}
266+
set
267267
}
268268
}
269269

‎compiler/rustc_serialize/src/serialize.rs‎

Lines changed: 18 additions & 28 deletions
Original file line numberDiff line numberDiff line change
@@ -201,14 +201,6 @@ pub trait Decoder {
201201
fn read_str(&mut self) -> Cow<'_, str>;
202202
fn read_raw_bytes_into(&mut self, s: &mut [u8]);
203203

204-
fn read_seq<T, F>(&mut self, f: F) -> T
205-
where
206-
F: FnOnce(&mut Self, usize) -> T,
207-
{
208-
let len = self.read_usize();
209-
f(self, len)
210-
}
211-
212204
fn read_map<T, F>(&mut self, f: F) -> T
213205
where
214206
F: FnOnce(&mut Self, usize) -> T,
@@ -397,19 +389,18 @@ impl<S: Encoder, T: Encodable<S>> Encodable<S> for Vec<T> {
397389

398390
impl<D: Decoder, T: Decodable<D>> Decodable<D> for Vec<T> {
399391
default fn decode(d: &mut D) -> Vec<T> {
400-
d.read_seq(|d, len| {
401-
// SAFETY: we set the capacity in advance, only write elements, and
402-
// only set the length at the end once the writing has succeeded.
403-
let mut vec = Vec::with_capacity(len);
404-
unsafe {
405-
let ptr: *mut T = vec.as_mut_ptr();
406-
for i in 0..len {
407-
std::ptr::write(ptr.offset(i as isize), Decodable::decode(d));
408-
}
409-
vec.set_len(len);
392+
let len = d.read_usize();
393+
// SAFETY: we set the capacity in advance, only write elements, and
394+
// only set the length at the end once the writing has succeeded.
395+
let mut vec = Vec::with_capacity(len);
396+
unsafe {
397+
let ptr: *mut T = vec.as_mut_ptr();
398+
for i in 0..len {
399+
std::ptr::write(ptr.offset(i as isize), Decodable::decode(d));
410400
}
411-
vec
412-
})
401+
vec.set_len(len);
402+
}
403+
vec
413404
}
414405
}
415406

@@ -422,14 +413,13 @@ impl<S: Encoder, T: Encodable<S>, const N: usize> Encodable<S> for [T; N] {
422413

423414
impl<D: Decoder, const N: usize> Decodable<D> for [u8; N] {
424415
fn decode(d: &mut D) -> [u8; N] {
425-
d.read_seq(|d, len| {
426-
assert!(len == N);
427-
let mut v = [0u8; N];
428-
for i in 0..len {
429-
v[i] = Decodable::decode(d);
430-
}
431-
v
432-
})
416+
let len = d.read_usize();
417+
assert!(len == N);
418+
let mut v = [0u8; N];
419+
for i in 0..len {
420+
v[i] = Decodable::decode(d);
421+
}
422+
v
433423
}
434424
}
435425

0 commit comments

Comments
 (0)