mikros/rust
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Use collect to decode Vec.

Browse Source 
It's hyper-optimized, we don't need our own unsafe code here.

This requires getting rid of all the `Allocator` stuff, which isn't
needed anyway.
This commit is contained in:
Nicholas Nethercote 2023-10-06 10:16:20 +11:00
parent 1d71971973
commit ad8271dd56
1 changed files with 10 additions and 23 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

33
compiler/rustc_serialize/src/serialize.rs
View File

@ -1,7 +1,6 @@
//! Support code for encoding and decoding types.
use smallvec::{Array, SmallVec};
use std::alloc::Allocator;
use std::borrow::Cow;
use std::cell::{Cell, RefCell};
use std::collections::{BTreeMap, BTreeSet, HashMap, HashSet, VecDeque};
@ -277,9 +276,9 @@ fn decode(_: &mut D) -> PhantomData<T> {
}
}
impl<D: Decoder, A: Allocator + Default, T: Decodable<D>> Decodable<D> for Box<[T], A> {
fn decode(d: &mut D) -> Box<[T], A> {
let v: Vec<T, A> = Decodable::decode(d);
impl<D: Decoder, T: Decodable<D>> Decodable<D> for Box<[T]> {
fn decode(d: &mut D) -> Box<[T]> {
let v: Vec<T> = Decodable::decode(d);
v.into_boxed_slice()
}
}
@ -311,21 +310,10 @@ fn encode(&self, s: &mut S) {
}
}
impl<D: Decoder, T: Decodable<D>, A: Allocator + Default> Decodable<D> for Vec<T, A> {
default fn decode(d: &mut D) -> Vec<T, A> {
impl<D: Decoder, T: Decodable<D>> Decodable<D> for Vec<T> {
default fn decode(d: &mut D) -> Vec<T> {
let len = d.read_usize();
let allocator = A::default();
// SAFETY: we set the capacity in advance, only write elements, and
// only set the length at the end once the writing has succeeded.
let mut vec = Vec::with_capacity_in(len, allocator);
unsafe {
let ptr: *mut T = vec.as_mut_ptr();
for i in 0..len {
std::ptr::write(ptr.add(i), Decodable::decode(d));
}
vec.set_len(len);
}
vec
(0..len).map(|_| Decodable::decode(d)).collect()
}
}
@ -499,16 +487,15 @@ fn decode(d: &mut D) -> Arc<T> {
}
}
impl<S: Encoder, T: ?Sized + Encodable<S>, A: Allocator + Default> Encodable<S> for Box<T, A> {
impl<S: Encoder, T: ?Sized + Encodable<S>> Encodable<S> for Box<T> {
fn encode(&self, s: &mut S) {
(**self).encode(s)
}
}
impl<D: Decoder, A: Allocator + Default, T: Decodable<D>> Decodable<D> for Box<T, A> {
fn decode(d: &mut D) -> Box<T, A> {
let allocator = A::default();
Box::new_in(Decodable::decode(d), allocator)
impl<D: Decoder, T: Decodable<D>> Decodable<D> for Box<T> {
fn decode(d: &mut D) -> Box<T> {
Box::new(Decodable::decode(d))
}
}