Add GcSimpleAlloc::alloc_array_from_vec

Fix miscelaneous clippy lints

Author: Techcable

src/array/repr.rs

@@ -5,6 +5,9 @@
 //! 1. FatArrayRepr - Represents arrays as a fat pointer
 //! 2. ThinArrayRepr - Represents arrays as a thin pointer,
 //!    with the length stored indirectly in the object header.
+#![allow(
+    clippy::len_without_is_empty, // This is really an internal interface...
+)]
 use core::marker::PhantomData;
 use core::ptr::NonNull;
 

src/lib.rs

@@ -511,6 +511,36 @@ pub unsafe trait GcSimpleAlloc: GcContext {
             )
         }
     }
+    /// Allocate an array, taking ownership of the values in
+    /// the specified vec.
+    #[inline]
+    fn alloc_array_from_vec<'gc, T>(&'gc self, mut src: Vec<T>) -> GcArray<'gc, T, Self::Id> 
+        where T: GcSafe<'gc, Self::Id> + 'gc {
+        unsafe {
+            let ptr = src.as_ptr();
+            let len = src.len();
+            /*
+             * NOTE: Don't steal ownership of the
+             * source Vec until *after* we allocate.
+             *
+             * It is possible allocation panics in
+             * which case we want to free the source elements.
+             */
+            let (_, dest) = self.alloc_uninit_slice::<T>(len);
+            /*
+             * NOTE: From here to the end,
+             * we should be infallible.
+             */
+            src.set_len(0);
+            dest.copy_from_nonoverlapping(ptr, len);
+            let res = GcArray::from_raw_ptr(
+                NonNull::new_unchecked(ptr as *mut _),
+                len
+            );
+            drop(src);
+            res
+        }
+    }
     /// Allocate a slice by filling it with results from the specified closure.
     ///
     /// The closure receives the target index as its only argument.