Make use of NonNull

Author: c410-f3r

lib.rs

@@ -41,7 +41,7 @@ use core::{
     iter::{IntoIterator, FromIterator, repeat},
     mem::{ManuallyDrop, self},
     ops,
-    ptr,
+    ptr::{self, NonNull},
     slice,
 };
 #[cfg(feature = "std")]
@@ -214,7 +214,7 @@ impl<'a, T: 'a> Drop for Drain<'a,T> {
 #[cfg(feature = "union")]
 union SmallVecData<A: Array> {
     inline: ManuallyDrop<A>,
-    heap: (*mut A::Item, usize),
+    heap: (NonNull<A::Item>, usize),
 }
 
 #[cfg(feature = "union")]
@@ -235,22 +235,22 @@ impl<A: Array> SmallVecData<A> {
     unsafe fn into_inline(self) -> A { ManuallyDrop::into_inner(self.inline) }
     #[inline]
     unsafe fn heap(&self) -> (*mut A::Item, usize) {
-        self.heap
+        (self.heap.0.as_ptr(), self.heap.1)
     }
     #[inline]
-    unsafe fn heap_mut(&mut self) -> &mut (*mut A::Item, usize) {
-        &mut self.heap
+    unsafe fn heap_mut(&mut self) -> (*mut A::Item, &mut usize) {
+        (self.heap.0.as_ptr(), &mut self.heap.1)
     }
     #[inline]
     fn from_heap(ptr: *mut A::Item, len: usize) -> SmallVecData<A> {
-        SmallVecData { heap: (ptr, len) }
+        SmallVecData { heap: (NonNull::new(ptr).unwrap(), len) }
     }
 }
 
 #[cfg(not(feature = "union"))]
 enum SmallVecData<A: Array> {
     Inline(ManuallyDrop<A>),
-    Heap((*mut A::Item, usize)),
+    Heap((NonNull<A::Item>, usize)),
 }
 
 #[cfg(not(feature = "union"))]
@@ -283,20 +283,20 @@ impl<A: Array> SmallVecData<A> {
     #[inline]
     unsafe fn heap(&self) -> (*mut A::Item, usize) {
         match *self {
-            SmallVecData::Heap(data) => data,
+            SmallVecData::Heap(data) => (data.0.as_ptr(), data.1),
             _ => debug_unreachable!(),
         }
     }
     #[inline]
-    unsafe fn heap_mut(&mut self) -> &mut (*mut A::Item, usize) {
+    unsafe fn heap_mut(&mut self) -> (*mut A::Item, &mut usize) {
         match *self {
-            SmallVecData::Heap(ref mut data) => data,
+            SmallVecData::Heap(ref mut data) => (data.0.as_ptr(), &mut data.1),
             _ => debug_unreachable!(),
         }
     }
     #[inline]
     fn from_heap(ptr: *mut A::Item, len: usize) -> SmallVecData<A> {
-        SmallVecData::Heap((ptr, len))
+        SmallVecData::Heap((NonNull::new(ptr).unwrap(), len))
     }
 }
 
@@ -519,7 +519,7 @@ impl<A: Array> SmallVec<A> {
     fn triple_mut(&mut self) -> (*mut A::Item, &mut usize, usize) {
         unsafe {
             if self.spilled() {
-                let &mut (ptr, ref mut len_ptr) = self.data.heap_mut();
+                let (ptr, len_ptr) = self.data.heap_mut();
                 (ptr, len_ptr, self.capacity)
             } else {
                 (self.data.inline_mut().as_mut_ptr(), &mut self.capacity, A::size())