Make Vec.ptr() return the ptr field always

Don't special-case zero-sized values in Vec.ptr(). Doing that prevents
the following from working:

    // v is a Vec<T>
    let newv = Vec::from_raw_parts(v.len(), v.cap(), v.mut_ptr());
    mem::forget(v);

Instead, teach slice::Items/MutItems to handle zero-sized values better.

Author: lilyball

src/libcore/slice.rs

@@ -1257,17 +1257,18 @@ macro_rules! iterator {
                     if self.ptr == self.end {
                         None
                     } else {
-                        let old = self.ptr;
-                        self.ptr = if mem::size_of::<T>() == 0 {
+                        if mem::size_of::<T>() == 0 {
                             // purposefully don't use 'ptr.offset' because for
                             // vectors with 0-size elements this would return the
                             // same pointer.
-                            transmute(self.ptr as uint + 1)
+                            self.ptr = transmute(self.ptr as uint + 1);
+                            Some(transmute(1u)) // Use a non-NULL pointer value
                         } else {
-                            self.ptr.offset(1)
-                        };
+                            let old = self.ptr;
+                            self.ptr = self.ptr.offset(1);
 
-                        Some(transmute(old))
+                            Some(transmute(old))
+                        }
                     }
                 }
             }
@@ -1289,13 +1290,14 @@ macro_rules! iterator {
                     if self.end == self.ptr {
                         None
                     } else {
-                        self.end = if mem::size_of::<T>() == 0 {
-                            // See above for why 'ptr.offset' isn't used
-                            transmute(self.end as uint - 1)
+                        if mem::size_of::<T>() == 0 {
+                            // See above for why `ptr.offset` isn't used
+                            self.end = transmute(self.end as uint - 1);
+                            Some(transmute(1u)) // Use a non-NULL pointer value
                         } else {
-                            self.end.offset(-1)
-                        };
-                        Some(transmute(self.end))
+                            self.end = self.end.offset(-1);
+                            Some(transmute(self.end))
+                        }
                     }
                 }
             }
@@ -1314,7 +1316,11 @@ impl<'a, T> RandomAccessIterator<&'a T> for Items<'a, T> {
     fn idx(&mut self, index: uint) -> Option<&'a T> {
         unsafe {
             if index < self.indexable() {
-                transmute(self.ptr.offset(index as int))
+                if mem::size_of::<T>() == 0 {
+                    Some(transmute(1u)) // Use a non-NULL pointer value
+                } else {
+                    Some(transmute(self.ptr.offset(index as int)))
+                }
             } else {
                 None
             }

src/libstd/vec.rs

@@ -1184,15 +1184,7 @@ impl<T> Vec<T> {
     /// would also make any pointers to it invalid.
     #[inline]
     pub fn as_ptr(&self) -> *T {
-        // If we have a 0-sized vector, then the base pointer should not be NULL
-        // because an iterator over the slice will attempt to yield the base
-        // pointer as the first element in the vector, but this will end up
-        // being Some(NULL) which is optimized to None.
-        if mem::size_of::<T>() == 0 {
-            1 as *T
-        } else {
-            self.ptr as *T
-        }
+        self.ptr as *T
     }
 
     /// Returns a mutable unsafe pointer to the vector's buffer.
@@ -1204,12 +1196,7 @@ impl<T> Vec<T> {
     /// would also make any pointers to it invalid.
     #[inline]
     pub fn as_mut_ptr(&mut self) -> *mut T {
-        // see above for the 0-size check
-        if mem::size_of::<T>() == 0 {
-            1 as *mut T
-        } else {
-            self.ptr
-        }
+        self.ptr
     }
 
     /// Retains only the elements specified by the predicate.