FIX: Use raw pointer casts for MaybeUninit

The nodrop/fallback code is as it was, it uses the Array trait accessors
as_ptr/as_ptr_mut; but we really want to do this properly with a raw
pointer cast according to discussion with arielb.

The idea is that we don't take a reference to a partially uninitialized
array value -- we just extract a raw pointer to the first array element
instead.

Author: bluss

src/lib.rs

@@ -581,7 +581,7 @@ impl<A: Array> ArrayVec<A> {
             Err(self)
         } else {
             unsafe {
-                let array = ptr::read(self.xs.ptr());
+                let array = ptr::read(self.xs.ptr() as *const A);
                 mem::forget(self);
                 Ok(array)
             }
@@ -610,7 +610,7 @@ impl<A: Array> Deref for ArrayVec<A> {
     #[inline]
     fn deref(&self) -> &[A::Item] {
         unsafe {
-            slice::from_raw_parts((*self.xs.ptr()).as_ptr(), self.len())
+            slice::from_raw_parts(self.xs.ptr(), self.len())
         }
     }
 }
@@ -620,7 +620,7 @@ impl<A: Array> DerefMut for ArrayVec<A> {
     fn deref_mut(&mut self) -> &mut [A::Item] {
         let len = self.len();
         unsafe {
-            slice::from_raw_parts_mut((*self.xs.ptr_mut()).as_mut_ptr(), len)
+            slice::from_raw_parts_mut(self.xs.ptr_mut(), len)
         }
     }
 }

src/maybe_uninit.rs

@@ -1,11 +1,13 @@
 
 
+use array::Array;
 use std::mem::ManuallyDrop;
 use std::mem::uninitialized;
 
 /// A combination of ManuallyDrop and “maybe uninitialized”;
 /// this wraps a value that can be wholly or partially uninitialized;
 /// it also has no drop regardless of the type of T.
+#[repr(C)]
 pub struct MaybeUninit<T>(ManuallyDrop<T>);
 
 impl<T> MaybeUninit<T> {
@@ -19,16 +21,42 @@ impl<T> MaybeUninit<T> {
         MaybeUninit(ManuallyDrop::new(v))
     }
 
-    /// Return a raw pointer to the interior
-    pub fn ptr(&self) -> *const T {
-        (&self.0) as *const ManuallyDrop<_> as *const T
+    // Raw pointer casts written so that we don't reference or access the
+    // uninitialized interior value
+
+    /// Return a raw pointer to the start of the interior array
+    pub fn ptr(&self) -> *const T::Item
+        where T: Array
+    {
+        self as *const _ as *const T::Item
     }
 
-    /// Return a raw pointer to the interior (mutable)
-    pub fn ptr_mut(&mut self) -> *mut T {
-        (&mut self.0) as *mut ManuallyDrop<_> as *mut T
+    /// Return a mut raw pointer to the start of the interior array
+    pub fn ptr_mut(&mut self) -> *mut T::Item
+        where T: Array
+    {
+        self as *mut _ as *mut T::Item
     }
 }
 
 
 
+#[test]
+fn test_offset() {
+    use std::ptr;
+
+    let mut mu = MaybeUninit::from([1, 2, 3]);
+    assert!(ptr::eq(mu.ptr(), &mu.0[0]));
+    assert!(ptr::eq(mu.ptr_mut(), &mut mu.0[0]));
+}
+
+#[test]
+#[cfg(feature = "std")]
+fn test_offset_string() {
+    use std::ptr;
+
+    let s = String::from;
+    let mut mu = MaybeUninit::from([s("a"), s("b")]);
+    assert!(ptr::eq(mu.ptr(), &mu.0[0]));
+    assert!(ptr::eq(mu.ptr_mut(), &mut mu.0[0]));
+}

src/maybe_uninit_nodrop.rs

@@ -1,5 +1,5 @@
 
-
+use array::Array;
 use nodrop::NoDrop;
 use std::mem::uninitialized;
 
@@ -18,14 +18,18 @@ impl<T> MaybeUninit<T> {
         MaybeUninit(NoDrop::new(v))
     }
 
-    /// Return a raw pointer to the interior
-    pub fn ptr(&self) -> *const T {
-        &**(&self.0)
+    /// Return a raw pointer to the start of the interior array
+    pub fn ptr(&self) -> *const T::Item
+        where T: Array
+    {
+        self.0.as_ptr()
     }
 
-    /// Return a raw pointer to the interior (mutable)
-    pub fn ptr_mut(&mut self) -> *mut T {
-        &mut **(&mut self.0)
+    /// Return a mut raw pointer to the start of the interior array
+    pub fn ptr_mut(&mut self) -> *mut T::Item
+        where T: Array
+    {
+        self.0.as_mut_ptr()
     }
 }