Minor improvements to Vec (#415)

src/vec/vec-drain.md

@@ -93,7 +93,7 @@ impl<T> IntoIterator for Vec<T> {
             mem::forget(self);
 
             IntoIter {
-                iter: iter,
+                iter,
                 _buf: buf,
             }
         }
@@ -135,8 +135,7 @@ impl<'a, T> Drop for Drain<'a, T> {
 
 impl<T> Vec<T> {
     pub fn drain(&mut self) -> Drain<T> {
-        unsafe {
-            let iter = RawValIter::new(&self);
+        let iter = unsafe { RawValIter::new(&self) };
 
         // this is a mem::forget safety thing. If Drain is forgotten, we just
         // leak the whole Vec's contents. Also we need to do this *eventually*
@@ -144,12 +143,11 @@ impl<T> Vec<T> {
         self.len = 0;
 
         Drain {
-                iter: iter,
+            iter,
             vec: PhantomData,
         }
     }
 }
-}
 ```
 
 For more details on the `mem::forget` problem, see the

src/vec/vec-final.md

@@ -127,7 +127,7 @@ impl<T> Vec<T> {
 
     pub fn insert(&mut self, index: usize, elem: T) {
         assert!(index <= self.len, "index out of bounds");
-        if self.cap() == self.len {
+        if self.len == self.cap() {
             self.buf.grow();
         }
 
@@ -138,14 +138,17 @@ impl<T> Vec<T> {
                 self.len - index,
             );
             ptr::write(self.ptr().add(index), elem);
-            self.len += 1;
         }
+
+        self.len += 1;
     }
 
     pub fn remove(&mut self, index: usize) -> T {
         assert!(index < self.len, "index out of bounds");
-        unsafe {
+
         self.len -= 1;
+
+        unsafe {
             let result = ptr::read(self.ptr().add(index));
             ptr::copy(
                 self.ptr().add(index + 1),
@@ -157,8 +160,7 @@ impl<T> Vec<T> {
     }
 
     pub fn drain(&mut self) -> Drain<T> {
-        unsafe {
-            let iter = RawValIter::new(&self);
+        let iter = unsafe { RawValIter::new(&self) };
 
         // this is a mem::forget safety thing. If Drain is forgotten, we just
         // leak the whole Vec's contents. Also we need to do this *eventually*
@@ -166,12 +168,11 @@ impl<T> Vec<T> {
         self.len = 0;
 
         Drain {
-                iter: iter,
+            iter,
             vec: PhantomData,
         }
     }
 }
-}
 
 impl<T> Drop for Vec<T> {
     fn drop(&mut self) {
@@ -197,18 +198,18 @@ impl<T> IntoIterator for Vec<T> {
     type Item = T;
     type IntoIter = IntoIter<T>;
     fn into_iter(self) -> IntoIter<T> {
-        unsafe {
-            let iter = RawValIter::new(&self);
-            let buf = ptr::read(&self.buf);
+        let (iter, buf) = unsafe {
+            (RawValIter::new(&self), ptr::read(&self.buf))
+        };
+
         mem::forget(self);
 
         IntoIter {
-                iter: iter,
+            iter,
             _buf: buf,
         }
     }
 }
-}
 
 struct RawValIter<T> {
     start: *const T,

src/vec/vec-insert-remove.md

@@ -18,7 +18,7 @@ pub fn insert(&mut self, index: usize, elem: T) {
     // Note: `<=` because it's valid to insert after everything
     // which would be equivalent to push.
     assert!(index <= self.len, "index out of bounds");
-    if self.cap == self.len { self.grow(); }
+    if self.len == self.cap { self.grow(); }
 
     unsafe {
         // ptr::copy(src, dest, len): "copy from src to dest len elems"
@@ -28,8 +28,9 @@ pub fn insert(&mut self, index: usize, elem: T) {
             self.len - index,
         );
         ptr::write(self.ptr.as_ptr().add(index), elem);
-        self.len += 1;
     }
+
+    self.len += 1;
 }
 ```
 

src/vec/vec-into-iter.md

@@ -68,21 +68,19 @@ impl<T> IntoIterator for Vec<T> {
         let cap = vec.cap;
         let len = vec.len;
 
-        unsafe {
         IntoIter {
             buf: ptr,
-                cap: cap,
+            cap,
             start: ptr.as_ptr(),
             end: if cap == 0 {
                 // can't offset off this pointer, it's not allocated!
                 ptr.as_ptr()
             } else {
-                    ptr.as_ptr().add(len)
+                unsafe { ptr.as_ptr().add(len) }
             },
         }
     }
 }
-}
 ```
 
 Here's iterating forward:

src/vec/vec-layout.md

@@ -40,7 +40,6 @@ we get the same results as using `Unique<T>`:
 
 ```rust
 use std::ptr::NonNull;
-use std::marker::PhantomData;
 
 pub struct Vec<T> {
     ptr: NonNull<T>,

src/vec/vec-raw.md

@@ -131,10 +131,9 @@ impl<T> IntoIterator for Vec<T> {
     type Item = T;
     type IntoIter = IntoIter<T>;
     fn into_iter(self) -> IntoIter<T> {
-        unsafe {
         // need to use ptr::read to unsafely move the buf out since it's
         // not Copy, and Vec implements Drop (so we can't destructure it).
-            let buf = ptr::read(&self.buf);
+        let buf = unsafe { ptr::read(&self.buf) };
         let len = self.len;
         mem::forget(self);
 
@@ -144,13 +143,12 @@ impl<T> IntoIterator for Vec<T> {
                 // can't offset off of a pointer unless it's part of an allocation
                 buf.ptr.as_ptr()
             } else {
-                    buf.ptr.as_ptr().add(len)
+                unsafe { buf.ptr.as_ptr().add(len) }
             },
             _buf: buf,
         }
     }
 }
-}
 ```
 
 Much better.