Implement Clone for Vec

Author: TimDiekmann

src/boxed.rs

@@ -783,7 +783,7 @@ where
     }
 }
 
-impl<T: Clone, A: Clone> Clone for Box<T, A>
+impl<T: Clone, A> Clone for Box<T, A>
 where
     A: AllocRef,
     A::BuildAlloc: Clone,

src/raw_vec.rs

@@ -311,17 +311,23 @@ impl<T, A: DeallocRef> RawVec<T, A> {
     /// Returns the allocator used by this `RawVec` and the used layout, if any.
     /// The layout is `None` if the capacity of this `RawVec` is `0` or if `T` is a zero sized type.
     pub fn alloc_ref(&mut self) -> (A, Option<NonZeroLayout>) {
-        let size = mem::size_of::<T>() * self.capacity;
+        let layout = self.current_layout();
         unsafe {
-            let layout = Layout::from_size_align_unchecked(size, mem::align_of::<T>())
-                .try_into()
-                .ok();
             let ptr = self.ptr.cast();
             let alloc = self.build_alloc_mut().build_alloc_ref(ptr.into(), layout);
             (alloc, layout)
         }
     }
 
+    pub fn current_layout(&self) -> Option<NonZeroLayout> {
+        let size = mem::size_of::<T>() * self.capacity;
+        unsafe {
+            Layout::from_size_align_unchecked(size, mem::align_of::<T>())
+                .try_into()
+                .ok()
+        }
+    }
+
     /// Converts a `Box<[T], A>` into a `RawVec<T, A>`.
     pub fn from_box(slice: Box<[mem::MaybeUninit<T>], A>) -> Self {
         unsafe {

src/vec.rs

@@ -69,7 +69,15 @@
 //! [`vec!`]: ../macro.vec.html
 
 use crate::{
-    alloc::{handle_alloc_error, AllocRef, DeallocRef, Global, ReallocRef},
+    alloc::{
+        handle_alloc_error,
+        AllocRef,
+        BuildAllocRef,
+        DeallocRef,
+        Global,
+        NonZeroLayout,
+        ReallocRef,
+    },
     boxed::Box,
     clone::CloneIn,
     collections::CollectionAllocErr,
@@ -2177,11 +2185,22 @@ unsafe impl<T: ?Sized> IsZero for Option<Box<T>> {
 // Common trait implementations for Vec
 ////////////////////////////////////////////////////////////////////////////////
 
-impl<T: Clone> Clone for Vec<T> {
+impl<T: Clone, A> Clone for Vec<T, A>
+where
+    A: AllocRef,
+    A::BuildAlloc: Clone,
+{
     #[must_use]
     #[inline]
     fn clone(&self) -> Self {
-        self.clone_in(Global)
+        let mut b = self.buf.build_alloc().clone();
+        let old_layout = self.buf.current_layout();
+
+        unsafe {
+            let old_ptr = NonNull::new_unchecked(self.buf.ptr());
+            let a = b.build_alloc_ref(old_ptr.cast(), old_layout);
+            self.clone_in(a)
+        }
     }
 }