rename std::vec_ng -> std::vec

Closes #12771

src/libstd/ascii.rs

@@ -20,7 +20,7 @@
 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}),*]);

src/libstd/hash/mod.rs

@@ -71,7 +71,7 @@
 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;

src/libstd/io/fs.rs

@@ -63,7 +63,7 @@
 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
 ///

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 tuple;
 
 pub mod slice;
-pub mod vec_ng;
+pub mod vec;
 pub mod str;
 
 pub mod ascii;

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
     })

src/libstd/rt/local_heap.rs

@@ -22,7 +22,7 @@
 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)]

src/libstd/str.rs

@@ -101,7 +101,7 @@ fn main() {
 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;
 

src/libstd/vec.rs

@@ -58,7 +58,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 +74,7 @@ pub fn new() -> 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> {
@@ -96,7 +96,7 @@ pub fn with_capacity(capacity: uint) -> 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 +148,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 +162,7 @@ pub fn from_slice(values: &[T]) -> 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 +344,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 +363,7 @@ pub fn capacity(&self) -> uint {
      /// # 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 +407,7 @@ pub fn reserve(&mut self, capacity: uint) {
     /// # 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);
@@ -1169,7 +1169,7 @@ pub fn dedup(&mut self) {
 ///
 /// ```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 +1185,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]