fixup

Author: Julian Orth

src/libcollections/binary_heap.rs

@@ -553,7 +553,7 @@ impl<T: Ord> BinaryHeap<T> {
     #[inline]
     #[unstable(feature = "collections",
                reason = "matches collection reform specification, waiting for dust to settle")]
-    pub fn drain<'a>(&'a mut self) -> Drain<'a, T> {
+    pub fn drain(&mut self) -> Drain<T> {
         Drain { iter: self.data.drain(..) }
     }
 

src/libcollections/string.rs

@@ -671,24 +671,25 @@ impl String {
         self.vec.clear()
     }
 
-    /// Creates a draining iterator that clears the specified range in the String
-    /// and iterates over the characters contained in the range.
+    /// Creates a draining iterator that clears the specified byte-range in the String
+    /// and iterates over the characters contained in the range, backshifting the
+    /// remaining bytes.
     ///
     /// # Example
     ///
     /// ```
-    /// let mut s = "Hello World!".to_string();
-    /// let s2: String = s.drain(6..11).collect();
+    /// let mut s = "Hello Wörld!".to_string();
+    /// let s2: String = s.drain(6..12).collect();
     /// assert_eq!(s, "Hello !");
-    /// assert_eq!(s2, "World");
+    /// assert_eq!(s2, "Wörld");
     /// ```
     ///
     /// # Panics
     ///
     /// Panics if the range is decreasing, if the upper bound is larger than the
     /// length of the String, or if the start and the end of the range don't lie on
     /// character boundaries.
-    pub fn drain<'a, T: DrainRange>(&'a mut self, range: T) -> CharDrain<'a> {
+    pub fn drain<'a, T: DrainRange>(&'a mut self, range: T) -> Drain<'a> {
         range.drain(self)
     }
 }
@@ -697,19 +698,19 @@ impl String {
 ///
 /// See the documentation of `String::drain`.
 pub trait DrainRange {
-    fn drain<'a>(&self, s: &'a mut String) -> CharDrain<'a>;
+    fn drain<'a>(&self, s: &'a mut String) -> Drain<'a>;
 }
 
 impl DrainRange for Range<usize> {
-    fn drain<'a>(&self, s: &'a mut String) -> CharDrain<'a> {
+    fn drain<'a>(&self, s: &'a mut String) -> Drain<'a> {
         assert!(self.start <= self.end, "Range not increasing");
         assert!(self.end <= s.len(), "Range out of bounds");
         unsafe {
             let slice = mem::transmute::<&str, &'static str>(&s[self.start..self.end]);
             let tail = s.len() - self.end;
             s.as_mut_vec().set_len(tail + self.start);
             let ptr = s.as_mut_vec().as_mut_ptr();
-            CharDrain {
+            Drain {
                 tail: tail,
                 start: ptr.offset(self.start as isize),
                 end:   ptr.offset(self.end   as isize),
@@ -720,43 +721,43 @@ impl DrainRange for Range<usize> {
 }
 
 impl DrainRange for RangeFrom<usize> {
-    fn drain<'a>(&self, s: &'a mut String) -> CharDrain<'a> {
+    fn drain<'a>(&self, s: &'a mut String) -> Drain<'a> {
         assert!(self.start <= s.len(), "Range out of bounds");
         (self.start..s.len()).drain(s)
     }
 }
 
 impl DrainRange for RangeTo<usize> {
-    fn drain<'a>(&self, s: &'a mut String) -> CharDrain<'a> {
+    fn drain<'a>(&self, s: &'a mut String) -> Drain<'a> {
         (0..self.end).drain(s)
     }
 }
 
 impl DrainRange for RangeFull {
-    fn drain<'a>(&self, s: &'a mut String) -> CharDrain<'a> {
+    fn drain<'a>(&self, s: &'a mut String) -> Drain<'a> {
         (0..s.len()).drain(s)
     }
 }
 
 impl DrainRange for usize {
-    fn drain<'a>(&self, s: &'a mut String) -> CharDrain<'a> {
+    fn drain<'a>(&self, s: &'a mut String) -> Drain<'a> {
         (*self..*self+1).drain(s)
     }
 }
 
 /// An iterator that drains part of string.
 #[unsafe_no_drop_flag]
-pub struct CharDrain<'a> {
+pub struct Drain<'a> {
     tail: usize,
-    start: *mut u8,
-    end:   *mut u8,
+    start: *const u8,
+    end:   *const u8,
     chars: Chars<'a>,
 }
 
-unsafe impl<'a> Sync for CharDrain<'a> {}
-unsafe impl<'a> Send for CharDrain<'a> {}
+unsafe impl<'a> Sync for Drain<'a> {}
+unsafe impl<'a> Send for Drain<'a> {}
 
-impl<'a> Iterator for CharDrain<'a> {
+impl<'a> Iterator for Drain<'a> {
     type Item = char;
 
     #[inline]
@@ -770,20 +771,20 @@ impl<'a> Iterator for CharDrain<'a> {
     }
 }
 
-impl<'a> DoubleEndedIterator for CharDrain<'a> {
+impl<'a> DoubleEndedIterator for Drain<'a> {
     #[inline]
     fn next_back(&mut self) -> Option<char> {
         self.chars.next_back()
     }
 }
 
 #[unsafe_destructor]
-impl<'a> Drop for CharDrain<'a> {
+impl<'a> Drop for Drain<'a> {
     fn drop(&mut self) {
         // self.start == null if drop has already been called, so we can use
         // #[unsafe_no_drop_flag].
         if !self.start.is_null() {
-            unsafe { ptr::copy(self.start, self.end, self.tail); }
+            unsafe { ptr::copy(self.start as *mut _, self.end, self.tail); }
         }
     }
 }
@@ -1561,9 +1562,9 @@ mod tests {
 
     #[test]
     fn test_drain() {
-        let mut s = "Hello World!".to_string();
-        let s2: String = s.drain(6..11).collect();
+        let mut s = "Hello Wörld!".to_string();
+        let s2: String = s.drain(6..12).collect();
         assert_eq!(s, "Hello !");
-        assert_eq!(s2, "World");
+        assert_eq!(s2, "Wörld");
     }
 }

src/libcollections/vec.rs

@@ -1755,10 +1755,10 @@ impl DrainRange for Range<usize> {
         unsafe {
             let tail = vec.len() - self.end;
             vec.set_len(tail + self.start);
-            let ptr = vec.as_mut_ptr();
+            let ptr = vec.as_ptr();
             let (start, end) = if mem::size_of::<T>() == 0 {
                 // make sure that start is not null
-                ((self.start + 1) as *mut T, (self.end + 1) as *mut T)
+                ((self.start + 1) as *const T, (self.end + 1) as *const T)
             } else {
                 (ptr.offset(self.start as isize), ptr.offset(self.end as isize))
             };
@@ -1768,7 +1768,8 @@ impl DrainRange for Range<usize> {
                 end:   end,
                 left:  start,
                 right: end,
-                marker: PhantomData,
+                marker1: PhantomData,
+                marker2: PhantomData,
             }
         }
     }
@@ -1803,13 +1804,14 @@ impl DrainRange for usize {
 #[unsafe_no_drop_flag]
 #[unstable(feature = "collections",
            reason = "recently added as part of collections reform 2")]
-pub struct Drain<'a, T:'a> {
+pub struct Drain<'a, T: 'a> {
     tail: usize,
-    start: *mut T,
-    end:   *mut T,
-    left:  *mut T,
-    right: *mut T,
-    marker: PhantomData<&'a T>,
+    start: *const T,
+    end:   *const T,
+    left:  *const T,
+    right: *const T,
+    marker1: PhantomData<&'a ()>,
+    marker2: PhantomData<T>,
 }
 
 unsafe impl<'a, T: Sync> Sync for Drain<'a, T> {}
@@ -1890,7 +1892,7 @@ impl<'a, T> Drop for Drain<'a, T> {
             for _x in self.by_ref() {}
 
             if mem::size_of::<T>() > 0 {
-                unsafe { ptr::copy(self.start, self.end, self.tail); }
+                unsafe { ptr::copy(self.start as *mut _, self.end, self.tail); }
             }
         }
     }