wasmtime_internal_core/alloc/
vec.rs

1use crate::alloc::{TryClone, try_realloc};
2use crate::error::OutOfMemory;
3use core::borrow::Borrow;
4use core::{
5    cmp::Ordering,
6    fmt, mem,
7    num::NonZeroUsize,
8    ops::{Deref, DerefMut, Index, IndexMut},
9    slice::SliceIndex,
10};
11#[cfg(feature = "serde")]
12use serde::ser::SerializeSeq;
13use std_alloc::alloc::Layout;
14use std_alloc::boxed::Box;
15use std_alloc::vec::Vec as StdVec;
16
17/// Same as the [`std::vec!`] macro but returns an error on allocation failure.
18#[macro_export]
19macro_rules! vec {
20    ( $( $elem:expr ),* ) => {{
21        let len = $crate::private_len!( $( $elem ),* );
22        $crate::alloc::Vec::with_capacity(len).and_then(|mut v| {
23            $( v.push($elem)?; )*
24            let _ = &mut v;
25            Ok(v)
26        })
27    }};
28
29    ( $elem:expr; $len:expr ) => {{
30        let len: usize = $len;
31        if let Some(len) = ::core::num::NonZeroUsize::new(len) {
32            let elem = $elem;
33            $crate::alloc::Vec::from_elem(elem, len)
34        } else {
35            Ok($crate::alloc::Vec::new())
36        }
37    }};
38
39}
40
41// Only for use by the `vec!` macro.
42#[doc(hidden)]
43#[macro_export]
44macro_rules! private_len {
45    ( ) => { 0 };
46    ( $e:expr $( , $es:expr )* ) => { 1 + $crate::private_len!( $( $es ),* ) };
47}
48
49/// Like `std::vec::Vec` but all methods that allocate force handling allocation
50/// failure.
51#[derive(PartialEq, Eq, PartialOrd, Ord, Hash)]
52pub struct Vec<T> {
53    inner: StdVec<T>,
54}
55
56impl<T> Default for Vec<T> {
57    fn default() -> Self {
58        Self {
59            inner: Default::default(),
60        }
61    }
62}
63
64impl<T: fmt::Debug> fmt::Debug for Vec<T> {
65    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
66        fmt::Debug::fmt(&self.inner, f)
67    }
68}
69
70impl<T> TryClone for Vec<T>
71where
72    T: TryClone,
73{
74    fn try_clone(&self) -> Result<Self, OutOfMemory> {
75        let mut v = Vec::with_capacity(self.len())?;
76        for x in self {
77            v.push(x.try_clone()?).expect("reserved capacity");
78        }
79        Ok(v)
80    }
81}
82
83impl<T> Vec<T> {
84    /// Same as [`std::vec::Vec::new`].
85    pub const fn new() -> Self {
86        Self {
87            inner: StdVec::new(),
88        }
89    }
90
91    /// Same as [`std::vec::Vec::with_capacity`] but returns an error on
92    /// allocation failure.
93    pub fn with_capacity(capacity: usize) -> Result<Self, OutOfMemory> {
94        let mut v = Self::new();
95        v.reserve(capacity)?;
96        Ok(v)
97    }
98
99    // For use with the `vec!` macro.
100    #[doc(hidden)]
101    #[inline]
102    pub fn from_elem(elem: T, len: NonZeroUsize) -> Result<Self, OutOfMemory>
103    where
104        T: TryClone,
105    {
106        let mut v = Self::with_capacity(len.get())?;
107
108        // Minimize calls to `TryClone` by always pushing `elem` itself as the
109        // last element.
110        for _ in 0..len.get() - 1 {
111            v.push(elem.try_clone()?)?;
112        }
113        v.push(elem)?;
114
115        Ok(v)
116    }
117
118    /// Same as [`std::vec::Vec::reserve`] but returns an error on allocation
119    /// failure.
120    pub fn reserve(&mut self, additional: usize) -> Result<(), OutOfMemory> {
121        self.inner.try_reserve(additional).map_err(|_| {
122            OutOfMemory::new(
123                self.len()
124                    .saturating_add(additional)
125                    .saturating_mul(mem::size_of::<T>()),
126            )
127        })
128    }
129
130    /// Same as [`std::vec::Vec::reserve_exact`] but returns an error on allocation
131    /// failure.
132    pub fn reserve_exact(&mut self, additional: usize) -> Result<(), OutOfMemory> {
133        self.inner
134            .try_reserve_exact(additional)
135            .map_err(|_| OutOfMemory::new(self.len().saturating_add(additional)))
136    }
137
138    /// Same as [`std::vec::Vec::len`].
139    pub fn len(&self) -> usize {
140        self.inner.len()
141    }
142
143    /// Same as [`std::vec::Vec::capacity`].
144    pub fn capacity(&self) -> usize {
145        self.inner.capacity()
146    }
147
148    /// Same as [`std::vec::Vec::is_empty`].
149    pub fn is_empty(&self) -> bool {
150        self.inner.is_empty()
151    }
152
153    /// Same as [`std::vec::Vec::push`] but returns an error on allocation
154    /// failure.
155    pub fn push(&mut self, value: T) -> Result<(), OutOfMemory> {
156        self.reserve(1)?;
157        self.inner.push(value);
158        Ok(())
159    }
160
161    /// Same as [`std::vec::Vec::pop`].
162    pub fn pop(&mut self) -> Option<T> {
163        self.inner.pop()
164    }
165
166    /// Same as [`std::vec::Vec::truncate`].
167    pub fn truncate(&mut self, len: usize) {
168        self.inner.truncate(len);
169    }
170
171    /// Same as [`std::vec::Vec::resize`] but returns an error on allocation
172    /// failure.
173    pub fn resize(&mut self, new_len: usize, value: T) -> Result<(), OutOfMemory>
174    where
175        T: TryClone,
176    {
177        match new_len.cmp(&self.len()) {
178            Ordering::Less => self.truncate(new_len),
179            Ordering::Equal => {}
180            Ordering::Greater => {
181                let delta = new_len - self.len();
182                self.reserve(delta)?;
183                // Minimize `try_clone` calls by always pushing `value` directly
184                // as the last element.
185                for _ in 0..delta - 1 {
186                    self.push(value.try_clone()?)?;
187                }
188                self.push(value)?;
189            }
190        }
191        Ok(())
192    }
193
194    /// Same as [`std::vec::Vec::into_raw_parts`].
195    pub fn into_raw_parts(mut self) -> (*mut T, usize, usize) {
196        // NB: Can't use `Vec::into_raw_parts` until our MSRV is >= 1.93.
197        #[cfg(not(miri))]
198        {
199            let ptr = self.as_mut_ptr();
200            let len = self.len();
201            let cap = self.capacity();
202            mem::forget(self);
203            (ptr, len, cap)
204        }
205        // NB: Miri requires using `into_raw_parts`, but always run on nightly,
206        // so it's fine to use there.
207        #[cfg(miri)]
208        {
209            let _ = &mut self;
210            self.inner.into_raw_parts()
211        }
212    }
213
214    /// Same as [`std::vec::Vec::from_raw_parts`].
215    pub unsafe fn from_raw_parts(ptr: *mut T, length: usize, capacity: usize) -> Self {
216        Vec {
217            // Safety: Same as our unsafe contract.
218            inner: unsafe { StdVec::from_raw_parts(ptr, length, capacity) },
219        }
220    }
221
222    /// Same as [`std::vec::Vec::drain`].
223    pub fn drain<R>(&mut self, range: R) -> std_alloc::vec::Drain<'_, T>
224    where
225        R: core::ops::RangeBounds<usize>,
226    {
227        self.inner.drain(range)
228    }
229
230    /// Same as [`std::vec::Vec::shrink_to_fit`] but returns an error on
231    /// allocation failure.
232    pub fn shrink_to_fit(&mut self) -> Result<(), OutOfMemory> {
233        // If our length is already equal to our capacity, then there is nothing
234        // to shrink.
235        if self.len() == self.capacity() {
236            return Ok(());
237        }
238
239        // `realloc` requires a non-zero original layout as well as a non-zero
240        // destination layout, so this guard ensures that the sizes below are
241        // all nonzero. This handles a few cases:
242        //
243        // * If `len == cap == 0` then no allocation has ever been made.
244        // * If `len == 0` and `cap != 0` then this function effectively frees
245        //   the memory.
246        // * If `T` is a zero-sized type then nothing's been allocated either.
247        //
248        // In all of these cases delegate to the standard library's
249        // `shrink_to_fit` which is guaranteed to not perform a `realloc`.
250        if self.is_empty() || mem::size_of::<T>() == 0 {
251            self.inner.shrink_to_fit();
252            return Ok(());
253        }
254
255        let (ptr, len, cap) = mem::take(self).into_raw_parts();
256        let layout = Layout::array::<T>(cap).unwrap();
257        let new_size = Layout::array::<T>(len).unwrap().size();
258
259        // SAFETY: `ptr` was previously allocated in the global allocator,
260        // `layout` has a nonzero size and matches the current allocation of
261        // `ptr`, `new_size` is nonzero, and `new_size` is a valid array size
262        // for `len` elements given its constructor.
263        let result = unsafe { try_realloc(ptr.cast(), layout, new_size) };
264
265        match result {
266            Ok(ptr) => {
267                // SAFETY: `result` is allocated with the global allocator and
268                // has room for exactly `[T; len]`.
269                *self = unsafe { Self::from_raw_parts(ptr.cast::<T>().as_ptr(), len, len) };
270                Ok(())
271            }
272            Err(oom) => {
273                // SAFETY: If reallocation fails then it's guaranteed that the
274                // original allocation is not tampered with, so it's safe to
275                // reassemble the original vector.
276                *self = unsafe { Vec::from_raw_parts(ptr, len, cap) };
277                Err(oom)
278            }
279        }
280    }
281
282    /// Same as [`std::vec::Vec::into_boxed_slice`] but returns an error on
283    /// allocation failure.
284    pub fn into_boxed_slice(mut self) -> Result<Box<[T]>, OutOfMemory> {
285        self.shrink_to_fit()?;
286
287        // Once we've shrunken the allocation to just the actual length, we can
288        // use `std`'s `into_boxed_slice` without fear of `realloc`.
289        Ok(self.inner.into_boxed_slice())
290    }
291
292    /// Same as [`std::vec::Vec::clear`].
293    pub fn clear(&mut self) {
294        self.inner.clear();
295    }
296}
297
298impl<T> Deref for Vec<T> {
299    type Target = [T];
300
301    fn deref(&self) -> &Self::Target {
302        &self.inner
303    }
304}
305
306impl<T> DerefMut for Vec<T> {
307    fn deref_mut(&mut self) -> &mut Self::Target {
308        &mut self.inner
309    }
310}
311
312impl<T> AsRef<[T]> for Vec<T> {
313    fn as_ref(&self) -> &[T] {
314        self
315    }
316}
317
318impl<T> Borrow<[T]> for Vec<T> {
319    fn borrow(&self) -> &[T] {
320        self
321    }
322}
323
324impl<T, I> Index<I> for Vec<T>
325where
326    I: SliceIndex<[T]>,
327{
328    type Output = <I as SliceIndex<[T]>>::Output;
329
330    fn index(&self, index: I) -> &Self::Output {
331        &self.inner[index]
332    }
333}
334
335impl<T, I> IndexMut<I> for Vec<T>
336where
337    I: SliceIndex<[T]>,
338{
339    fn index_mut(&mut self, index: I) -> &mut Self::Output {
340        &mut self.inner[index]
341    }
342}
343
344impl<T> IntoIterator for Vec<T> {
345    type Item = T;
346    type IntoIter = std_alloc::vec::IntoIter<T>;
347
348    fn into_iter(self) -> Self::IntoIter {
349        self.inner.into_iter()
350    }
351}
352
353impl<'a, T> IntoIterator for &'a Vec<T> {
354    type Item = &'a T;
355
356    type IntoIter = core::slice::Iter<'a, T>;
357
358    fn into_iter(self) -> Self::IntoIter {
359        (**self).iter()
360    }
361}
362
363impl<'a, T> IntoIterator for &'a mut Vec<T> {
364    type Item = &'a mut T;
365
366    type IntoIter = core::slice::IterMut<'a, T>;
367
368    fn into_iter(self) -> Self::IntoIter {
369        (**self).iter_mut()
370    }
371}
372
373impl<T> From<Vec<T>> for StdVec<T> {
374    fn from(v: Vec<T>) -> Self {
375        v.inner
376    }
377}
378
379impl<T> From<StdVec<T>> for Vec<T> {
380    fn from(inner: StdVec<T>) -> Self {
381        Self { inner }
382    }
383}
384
385impl<T> From<Box<[T]>> for Vec<T> {
386    fn from(boxed_slice: Box<[T]>) -> Self {
387        Self::from(StdVec::from(boxed_slice))
388    }
389}
390
391#[cfg(feature = "serde")]
392impl<T> serde::ser::Serialize for Vec<T>
393where
394    T: serde::ser::Serialize,
395{
396    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
397    where
398        S: serde::Serializer,
399    {
400        let mut seq = serializer.serialize_seq(Some(self.len()))?;
401        for elem in self {
402            seq.serialize_element(elem)?;
403        }
404        seq.end()
405    }
406}
407
408#[cfg(feature = "serde")]
409impl<'de, T> serde::de::Deserialize<'de> for Vec<T>
410where
411    T: serde::de::Deserialize<'de>,
412{
413    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
414    where
415        D: serde::Deserializer<'de>,
416    {
417        use core::marker::PhantomData;
418
419        struct Visitor<T>(PhantomData<fn() -> Vec<T>>);
420
421        impl<'de, T> serde::de::Visitor<'de> for Visitor<T>
422        where
423            T: serde::de::Deserialize<'de>,
424        {
425            type Value = Vec<T>;
426
427            fn expecting(&self, f: &mut fmt::Formatter) -> fmt::Result {
428                f.write_str("a `wasmtime_core::alloc::Vec` sequence")
429            }
430
431            fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
432            where
433                A: serde::de::SeqAccess<'de>,
434            {
435                use serde::de::Error as _;
436
437                let mut v = Vec::new();
438
439                if let Some(len) = seq.size_hint() {
440                    v.reserve_exact(len).map_err(|oom| A::Error::custom(oom))?;
441                }
442
443                while let Some(elem) = seq.next_element()? {
444                    v.push(elem).map_err(|oom| A::Error::custom(oom))?;
445                }
446
447                Ok(v)
448            }
449        }
450
451        deserializer.deserialize_seq(Visitor(PhantomData))
452    }
453}
454
455#[cfg(test)]
456mod tests {
457    use super::Vec;
458    use crate::error::OutOfMemory;
459
460    #[test]
461    fn test_into_boxed_slice() -> Result<(), OutOfMemory> {
462        assert_eq!(*Vec::<i32>::new().into_boxed_slice()?, []);
463
464        let mut vec = Vec::new();
465        vec.push(1)?;
466        assert_eq!(*vec.into_boxed_slice()?, [1]);
467
468        let mut vec = Vec::with_capacity(2)?;
469        vec.push(1)?;
470        assert_eq!(*vec.into_boxed_slice()?, [1]);
471
472        let mut vec = Vec::with_capacity(2)?;
473        vec.push(1_u128)?;
474        assert_eq!(*vec.into_boxed_slice()?, [1]);
475
476        assert_eq!(*Vec::<()>::new().into_boxed_slice()?, []);
477
478        let mut vec = Vec::new();
479        vec.push(())?;
480        assert_eq!(*vec.into_boxed_slice()?, [()]);
481
482        let vec = Vec::<i32>::with_capacity(2)?;
483        assert_eq!(*vec.into_boxed_slice()?, []);
484        Ok(())
485    }
486}
wasmtime_internal_core/alloc/vec.rs

wasmtime_internal_core/alloc/
vec.rs
