FEAT: Use MaybeUninit in ArrayString too

This way to encapsulate and consolidate all the uninitialized usage in
one place in the crate. This requires MaybeUninit to implement Copy.

Author: bluss

src/array_string.rs

@@ -16,6 +16,8 @@ use char::encode_utf8;
 #[cfg(feature="serde-1")]
 use serde::{Serialize, Deserialize, Serializer, Deserializer};
 
+use super::MaybeUninit;
+
 /// A string with a fixed capacity.
 ///
 /// The `ArrayString` is a string backed by a fixed size array. It keeps track
@@ -25,7 +27,7 @@ use serde::{Serialize, Deserialize, Serializer, Deserializer};
 /// if needed.
 #[derive(Copy)]
 pub struct ArrayString<A: Array<Item=u8>> {
-    xs: A,
+    xs: MaybeUninit<A>,
     len: A::Index,
 }
 
@@ -52,7 +54,7 @@ impl<A: Array<Item=u8>> ArrayString<A> {
     pub fn new() -> ArrayString<A> {
         unsafe {
             ArrayString {
-                xs: ::new_array(),
+                xs: MaybeUninit::uninitialized(),
                 len: Index::from(0),
             }
         }
@@ -210,7 +212,7 @@ impl<A: Array<Item=u8>> ArrayString<A> {
             return Err(CapacityError::new(s));
         }
         unsafe {
-            let dst = self.xs.as_mut_ptr().offset(self.len() as isize);
+            let dst = self.xs.ptr_mut().offset(self.len() as isize);
             let src = s.as_ptr();
             ptr::copy_nonoverlapping(src, dst, s.len());
             let newl = self.len() + s.len();
@@ -304,8 +306,8 @@ impl<A: Array<Item=u8>> ArrayString<A> {
         let next = idx + ch.len_utf8();
         let len = self.len();
         unsafe {
-            ptr::copy(self.xs.as_ptr().offset(next as isize),
-                      self.xs.as_mut_ptr().offset(idx as isize),
+            ptr::copy(self.xs.ptr().offset(next as isize),
+                      self.xs.ptr_mut().offset(idx as isize),
                       len - next);
             self.set_len(len - (next - idx));
         }
@@ -339,7 +341,7 @@ impl<A: Array<Item=u8>> ArrayString<A> {
 
     /// Return a mutable slice of the whole string’s buffer
     unsafe fn raw_mut_bytes(&mut self) -> &mut [u8] {
-        slice::from_raw_parts_mut(self.xs.as_mut_ptr(), self.capacity())
+        slice::from_raw_parts_mut(self.xs.ptr_mut(), self.capacity())
     }
 }
 
@@ -348,7 +350,7 @@ impl<A: Array<Item=u8>> Deref for ArrayString<A> {
     #[inline]
     fn deref(&self) -> &str {
         unsafe {
-            let sl = slice::from_raw_parts(self.xs.as_ptr(), self.len.to_usize());
+            let sl = slice::from_raw_parts(self.xs.ptr(), self.len.to_usize());
             str::from_utf8_unchecked(sl)
         }
     }
@@ -358,7 +360,7 @@ impl<A: Array<Item=u8>> DerefMut for ArrayString<A> {
     #[inline]
     fn deref_mut(&mut self) -> &mut str {
         unsafe {
-            let sl = slice::from_raw_parts_mut(self.xs.as_mut_ptr(), self.len.to_usize());
+            let sl = slice::from_raw_parts_mut(self.xs.ptr_mut(), self.len.to_usize());
             str::from_utf8_unchecked_mut(sl)
         }
     }

src/lib.rs

@@ -65,14 +65,6 @@ pub use array_string::ArrayString;
 pub use errors::CapacityError;
 
 
-unsafe fn new_array<A: Array>() -> A {
-    // Note: Returning an uninitialized value here only works
-    // if we can be sure the data is never used. The nullable pointer
-    // inside enum optimization conflicts with this this for example,
-    // so we need to be extra careful. See `NoDrop` enum.
-    mem::uninitialized()
-}
-
 /// A vector with a fixed capacity.
 ///
 /// The `ArrayVec` is a vector backed by a fixed size array. It keeps track of

src/maybe_uninit.rs

@@ -10,6 +10,7 @@ use std::mem::uninitialized;
 ///
 /// This is a stop-gap solution until MaybeUninit is stable in Rust's std.
 #[repr(C)]
+#[derive(Copy)]
 pub struct MaybeUninit<T>(ManuallyDrop<T>);
 
 impl<T> MaybeUninit<T> {
@@ -42,6 +43,10 @@ impl<T> MaybeUninit<T> {
 }
 
 
+impl<T> Clone for MaybeUninit<T> where T: Copy {
+    fn clone(&self) -> Self { *self }
+}
+
 
 #[test]
 fn test_offset() {