auto merge of #13028 : thestinger/rust/vec_ng, r=huonw

Closes #12771

8 files changed, 46 insertions, 33 deletions

diff --git a/src/libstd/ascii.rs b/src/libstd/ascii.rs
index 33638fffc6d..63632770230 100644
--- a/src/libstd/ascii.rs
+++ b/src/libstd/ascii.rs
@@ -20,7 +20,7 @@ use cast;
 use fmt;
 use iter::Iterator;
 use slice::{ImmutableVector, MutableVector, Vector};
-use vec_ng::Vec;
+use vec::Vec;
 use option::{Option, Some, None};
 
 /// Datatype to hold one ascii character. It wraps a `u8`, with the highest bit always zero.
@@ -482,7 +482,7 @@ mod tests {
     use super::*;
     use str::from_char;
     use char::from_u32;
-    use vec_ng::Vec;
+    use vec::Vec;
 
     macro_rules! v2ascii (
         ( [$($e:expr),*]) => (&[$(Ascii{chr:$e}),*]);
diff --git a/src/libstd/hash/mod.rs b/src/libstd/hash/mod.rs
index d329c15a7d7..3791aa38b82 100644
--- a/src/libstd/hash/mod.rs
+++ b/src/libstd/hash/mod.rs
@@ -71,7 +71,7 @@ use option::{Option, Some, None};
 use rc::Rc;
 use str::{Str, StrSlice};
 use slice::{Vector, ImmutableVector};
-use vec_ng::Vec;
+use vec::Vec;
 
 /// Reexport the `sip::hash` function as our default hasher.
 pub use hash = self::sip::hash;
diff --git a/src/libstd/io/fs.rs b/src/libstd/io/fs.rs
index aab2f8c887c..870f33733f4 100644
--- a/src/libstd/io/fs.rs
+++ b/src/libstd/io/fs.rs
@@ -63,7 +63,7 @@ use result::{Ok, Err};
 use path;
 use path::{Path, GenericPath};
 use slice::{OwnedVector, ImmutableVector};
-use vec_ng::Vec;
+use vec::Vec;
 
 /// Unconstrained file access type that exposes read and write operations
 ///
diff --git a/src/libstd/lib.rs b/src/libstd/lib.rs
index c6a1d710a52..302f899efda 100644
--- a/src/libstd/lib.rs
+++ b/src/libstd/lib.rs
@@ -84,6 +84,9 @@
 #[cfg(test)] pub use ops = realstd::ops;
 #[cfg(test)] pub use cmp = realstd::cmp;
 
+#[cfg(stage0)]
+pub use vec_ng = vec;
+
 pub mod macros;
 
 mod rtdeps;
@@ -120,7 +123,7 @@ pub mod char;
 pub mod tuple;
 
 pub mod slice;
-pub mod vec_ng;
+pub mod vec;
 pub mod str;
 
 pub mod ascii;
diff --git a/src/libstd/macros.rs b/src/libstd/macros.rs
index 6d96ea94d31..d183fae3ac6 100644
--- a/src/libstd/macros.rs
+++ b/src/libstd/macros.rs
@@ -265,12 +265,12 @@ macro_rules! try(
     ($e:expr) => (match $e { Ok(e) => e, Err(e) => return Err(e) })
 )
 
-/// Create a `std::vec_ng::Vec` containing the arguments.
+/// Create a `std::vec::Vec` containing the arguments.
 #[macro_export]
 macro_rules! vec(
     ($($e:expr),*) => ({
         // leading _ to allow empty construction without a warning.
-        let mut _temp = ::std::vec_ng::Vec::new();
+        let mut _temp = ::std::vec::Vec::new();
         $(_temp.push($e);)*
         _temp
     })
diff --git a/src/libstd/rt/local_heap.rs b/src/libstd/rt/local_heap.rs
index 91452f5aa0d..a682a6141b1 100644
--- a/src/libstd/rt/local_heap.rs
+++ b/src/libstd/rt/local_heap.rs
@@ -22,7 +22,7 @@ use rt::local::Local;
 use rt::task::Task;
 use raw;
 use slice::ImmutableVector;
-use vec_ng::Vec;
+use vec::Vec;
 
 // This has no meaning with out rtdebug also turned on.
 #[cfg(rtdebug)]
diff --git a/src/libstd/str.rs b/src/libstd/str.rs
index 92e86a5cccb..37aad3f9411 100644
--- a/src/libstd/str.rs
+++ b/src/libstd/str.rs
@@ -101,7 +101,7 @@ use ptr::RawPtr;
 use from_str::FromStr;
 use slice;
 use slice::{OwnedVector, OwnedCloneableVector, ImmutableVector, MutableVector};
-use vec_ng::Vec;
+use vec::Vec;
 use default::Default;
 use raw::Repr;
 
diff --git a/src/libstd/vec_ng.rs b/src/libstd/vec.rs
index 553f528745b..5f4f4960a93 100644
--- a/src/libstd/vec_ng.rs
+++ b/src/libstd/vec.rs
@@ -7,7 +7,7 @@
 // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
-//! A growable, owned vector
+//! An owned, growable vector.
 
 use cast::{forget, transmute};
 use clone::Clone;
@@ -30,18 +30,29 @@ use raw::Slice;
 use slice::{ImmutableEqVector, ImmutableVector, Items, MutItems, MutableVector};
 use slice::{MutableTotalOrdVector};
 
-/// An owned, growable vector
+/// An owned, growable vector.
 ///
-/// `Vec<T>` is the replacement for the deprecated `~[T]` type. The API is
-/// largely the same. The `vec!` macro is provided to make initialization
-/// easier.
+/// # Examples
 ///
-/// # Example
+/// ```rust
+/// # use std::vec::Vec;
+/// let mut vec = Vec::new();
+/// vec.push(1);
+/// vec.push(2);
+///
+/// assert_eq!(vec.len(), 2);
+/// assert_eq!(vec.get(0), &1);
+///
+/// assert_eq!(vec.pop(), Some(2));
+/// assert_eq!(vec.len(), 1);
+/// ```
+///
+/// The `vec!` macro is provided to make initialization more convenient:
 ///
 /// ```rust
 /// let mut vec = vec!(1, 2, 3);
 /// vec.push(4);
-/// println!("{}", vec); // prints [1, 2, 3, 4]
+/// assert_eq!(vec, vec!(1, 2, 3, 4));
 /// ```
 #[unsafe_no_drop_flag]
 pub struct Vec<T> {
@@ -58,7 +69,7 @@ impl<T> Vec<T> {
     /// # Example
     ///
     /// ```rust
-    /// # use std::vec_ng::Vec;
+    /// # use std::vec::Vec;
     /// let mut vec: Vec<int> = Vec::new();
     /// ```
     #[inline]
@@ -74,7 +85,7 @@ impl<T> Vec<T> {
     /// # Example
     ///
     /// ```rust
-    /// # use std::vec_ng::Vec;
+    /// # use std::vec::Vec;
     /// let vec: Vec<int> = Vec::with_capacity(10);
     /// ```
     pub fn with_capacity(capacity: uint) -> Vec<T> {
@@ -87,7 +98,6 @@ impl<T> Vec<T> {
         }
     }
 
-
     /// Creates and initializes a `Vec`.
     ///
     /// Creates a `Vec` of size `length` and initializes the elements to the
@@ -96,7 +106,7 @@ impl<T> Vec<T> {
     /// # Example
     ///
     /// ```rust
-    /// # use std::vec_ng::Vec;
+    /// # use std::vec::Vec;
     /// let vec = Vec::from_fn(3, |idx| idx * 2);
     /// assert_eq!(vec, vec!(0, 2, 4));
     /// ```
@@ -148,7 +158,7 @@ impl<T: Clone> Vec<T> {
     /// # Example
     ///
     /// ```rust
-    /// # use std::vec_ng::Vec;
+    /// # use std::vec::Vec;
     /// let slice = [1, 2, 3];
     /// let vec = Vec::from_slice(slice);
     /// ```
@@ -162,7 +172,7 @@ impl<T: Clone> Vec<T> {
     ///
     /// # Example
     /// ```rust
-    /// # use std::vec_ng::Vec;
+    /// # use std::vec::Vec;
     /// let vec = Vec::from_elem(3, "hi");
     /// println!("{}", vec); // prints [hi, hi, hi]
     /// ```
@@ -344,7 +354,7 @@ impl<T> Vec<T> {
     /// # Example
     ///
     /// ```rust
-    /// # use std::vec_ng::Vec;
+    /// # use std::vec::Vec;
     /// let vec: Vec<int> = Vec::with_capacity(10);
     /// assert_eq!(vec.capacity(), 10);
     /// ```
@@ -363,7 +373,7 @@ impl<T> Vec<T> {
      /// # Example
      ///
      /// ```rust
-     /// # use std::vec_ng::Vec;
+     /// # use std::vec::Vec;
      /// let mut vec: Vec<int> = vec!(1);
      /// vec.reserve_additional(10);
      /// assert!(vec.capacity() >= 11);
@@ -407,7 +417,7 @@ impl<T> Vec<T> {
     /// # Example
     ///
     /// ```rust
-    /// # use std::vec_ng::Vec;
+    /// # use std::vec::Vec;
     /// let mut vec: Vec<int> = Vec::with_capacity(10);
     /// vec.reserve_exact(11);
     /// assert_eq!(vec.capacity(), 11);
@@ -767,13 +777,13 @@ impl<T> Vec<T> {
     ///
     /// # Example
     /// ```rust
-    /// let mut v = ~[~"foo", ~"bar", ~"baz", ~"qux"];
+    /// let mut v = vec!(~"foo", ~"bar", ~"baz", ~"qux");
     ///
     /// assert_eq!(v.swap_remove(1), Some(~"bar"));
-    /// assert_eq!(v, ~[~"foo", ~"qux", ~"baz"]);
+    /// assert_eq!(v, vec!(~"foo", ~"qux", ~"baz"));
     ///
     /// assert_eq!(v.swap_remove(0), Some(~"foo"));
-    /// assert_eq!(v, ~[~"baz", ~"qux"]);
+    /// assert_eq!(v, vec!(~"baz", ~"qux"));
     ///
     /// assert_eq!(v.swap_remove(2), None);
     /// ```
@@ -869,13 +879,13 @@ impl<T> Vec<T> {
     /// # Example
     ///
     /// ```rust
-    /// let mut v = ~[1, 2, 3];
+    /// let mut v = vec!(1, 2, 3);
     /// assert_eq!(v.remove(1), Some(2));
-    /// assert_eq!(v, ~[1, 3]);
+    /// assert_eq!(v, vec!(1, 3));
     ///
     /// assert_eq!(v.remove(4), None);
     /// // v is unchanged:
-    /// assert_eq!(v, ~[1, 3]);
+    /// assert_eq!(v, vec!(1, 3));
     /// ```
     pub fn remove(&mut self, index: uint) -> Option<T> {
         let len = self.len();
@@ -1169,7 +1179,7 @@ impl<T:Eq> Vec<T> {
 ///
 /// ```rust
 /// let vec = vec!(1, 2);
-/// let vec = std::vec_ng::append(vec, [3, 4]);
+/// let vec = std::vec::append(vec, [3, 4]);
 /// assert_eq!(vec, vec!(1, 2, 3, 4));
 /// ```
 #[inline]
@@ -1185,7 +1195,7 @@ pub fn append<T:Clone>(mut first: Vec<T>, second: &[T]) -> Vec<T> {
 ///
 /// ```rust
 /// let vec = vec!(1, 2);
-/// let vec = std::vec_ng::append_one(vec, 3);
+/// let vec = std::vec::append_one(vec, 3);
 /// assert_eq!(vec, vec!(1, 2, 3));
 /// ```
 #[inline]