auto merge of #13090 : thestinger/rust/iter, r=Aatch

This has been rendered obsolete by partial type hints. Since the `~[T]`
type is in the process of being removed, it needs to go away.

7 files changed, 30 insertions, 42 deletions

diff --git a/src/libstd/ascii.rs b/src/libstd/ascii.rs
index 63632770230..85df875dc1d 100644
--- a/src/libstd/ascii.rs
+++ b/src/libstd/ascii.rs
@@ -400,7 +400,7 @@ unsafe fn str_map_bytes(string: ~str, map: &'static [u8]) -> ~str {
 
 #[inline]
 unsafe fn str_copy_map_bytes(string: &str, map: &'static [u8]) -> ~str {
-    let bytes = string.bytes().map(|b| map[b]).to_owned_vec();
+    let bytes = string.bytes().map(|b| map[b]).collect::<~[_]>();
 
     str::raw::from_utf8_owned(bytes)
 }
diff --git a/src/libstd/iter.rs b/src/libstd/iter.rs
index 320383d4f81..ead26fb920c 100644
--- a/src/libstd/iter.rs
+++ b/src/libstd/iter.rs
@@ -463,21 +463,6 @@ pub trait Iterator<A> {
         FromIterator::from_iterator(self)
     }
 
-    /// Loops through the entire iterator, collecting all of the elements into
-    /// a unique vector. This is simply collect() specialized for vectors.
-    ///
-    /// # Example
-    ///
-    /// ```rust
-    /// let a = [1, 2, 3, 4, 5];
-    /// let b: ~[int] = a.iter().map(|&x| x).to_owned_vec();
-    /// assert!(a == b);
-    /// ```
-    #[inline]
-    fn to_owned_vec(&mut self) -> ~[A] {
-        self.collect()
-    }
-
     /// Loops through `n` iterations, returning the `n`th element of the
     /// iterator.
     ///
diff --git a/src/libstd/path/posix.rs b/src/libstd/path/posix.rs
index 512b20ebf4c..3596a07eeb2 100644
--- a/src/libstd/path/posix.rs
+++ b/src/libstd/path/posix.rs
@@ -1179,13 +1179,13 @@ mod tests {
             (s: $path:expr, $exp:expr) => (
                 {
                     let path = Path::new($path);
-                    let comps = path.components().to_owned_vec();
+                    let comps = path.components().collect::<~[&[u8]]>();
                     let exp: &[&str] = $exp;
-                    let exps = exp.iter().map(|x| x.as_bytes()).to_owned_vec();
+                    let exps = exp.iter().map(|x| x.as_bytes()).collect::<~[&[u8]]>();
                     assert!(comps == exps, "components: Expected {:?}, found {:?}",
                             comps, exps);
-                    let comps = path.rev_components().to_owned_vec();
-                    let exps = exps.move_rev_iter().to_owned_vec();
+                    let comps = path.rev_components().collect::<~[&[u8]]>();
+                    let exps = exps.move_rev_iter().collect::<~[&[u8]]>();
                     assert!(comps == exps, "rev_components: Expected {:?}, found {:?}",
                             comps, exps);
                 }
@@ -1193,12 +1193,12 @@ mod tests {
             (v: [$($arg:expr),+], [$([$($exp:expr),*]),*]) => (
                 {
                     let path = Path::new(b!($($arg),+));
-                    let comps = path.components().to_owned_vec();
+                    let comps = path.components().collect::<~[&[u8]]>();
                     let exp: &[&[u8]] = [$(b!($($exp),*)),*];
                     assert!(comps.as_slice() == exp, "components: Expected {:?}, found {:?}",
                             comps.as_slice(), exp);
-                    let comps = path.rev_components().to_owned_vec();
-                    let exp = exp.rev_iter().map(|&x|x).to_owned_vec();
+                    let comps = path.rev_components().collect::<~[&[u8]]>();
+                    let exp = exp.rev_iter().map(|&x|x).collect::<~[&[u8]]>();
                     assert!(comps.as_slice() == exp,
                             "rev_components: Expected {:?}, found {:?}",
                             comps.as_slice(), exp);
@@ -1228,13 +1228,13 @@ mod tests {
             (v: [$($arg:expr),+], $exp:expr) => (
                 {
                     let path = Path::new(b!($($arg),+));
-                    let comps = path.str_components().to_owned_vec();
+                    let comps = path.str_components().collect::<~[Option<&str>]>();
                     let exp: &[Option<&str>] = $exp;
                     assert!(comps.as_slice() == exp,
                             "str_components: Expected {:?}, found {:?}",
                             comps.as_slice(), exp);
-                    let comps = path.rev_str_components().to_owned_vec();
-                    let exp = exp.rev_iter().map(|&x|x).to_owned_vec();
+                    let comps = path.rev_str_components().collect::<~[Option<&str>]>();
+                    let exp = exp.rev_iter().map(|&x|x).collect::<~[Option<&str>]>();
                     assert!(comps.as_slice() == exp,
                             "rev_str_components: Expected {:?}, found {:?}",
                             comps.as_slice(), exp);
diff --git a/src/libstd/path/windows.rs b/src/libstd/path/windows.rs
index 81da2f50f8d..9d65a99a0b5 100644
--- a/src/libstd/path/windows.rs
+++ b/src/libstd/path/windows.rs
@@ -2226,13 +2226,15 @@ mod tests {
             (s: $path:expr, $exp:expr) => (
                 {
                     let path = Path::new($path);
-                    let comps = path.str_components().map(|x|x.unwrap()).to_owned_vec();
+                    let comps = path.str_components().map(|x|x.unwrap())
+                                .collect::<~[&str]>();
                     let exp: &[&str] = $exp;
                     assert!(comps.as_slice() == exp,
                             "str_components: Expected {:?}, found {:?}",
                             comps.as_slice(), exp);
-                    let comps = path.rev_str_components().map(|x|x.unwrap()).to_owned_vec();
-                    let exp = exp.rev_iter().map(|&x|x).to_owned_vec();
+                    let comps = path.rev_str_components().map(|x|x.unwrap())
+                                .collect::<~[&str]>();
+                    let exp = exp.rev_iter().map(|&x|x).collect::<~[&str]>();
                     assert!(comps.as_slice() == exp,
                             "rev_str_components: Expected {:?}, found {:?}",
                             comps.as_slice(), exp);
@@ -2241,13 +2243,14 @@ mod tests {
             (v: [$($arg:expr),+], $exp:expr) => (
                 {
                     let path = Path::new(b!($($arg),+));
-                    let comps = path.str_components().map(|x|x.unwrap()).to_owned_vec();
+                    let comps = path.str_components().map(|x|x.unwrap()).collect::<~[&str]>();
                     let exp: &[&str] = $exp;
                     assert!(comps.as_slice() == exp,
                             "str_components: Expected {:?}, found {:?}",
                             comps.as_slice(), exp);
-                    let comps = path.rev_str_components().map(|x|x.unwrap()).to_owned_vec();
-                    let exp = exp.rev_iter().map(|&x|x).to_owned_vec();
+                    let comps = path.rev_str_components().map(|x|x.unwrap())
+                                .collect::<~[&str]>();
+                    let exp = exp.rev_iter().map(|&x|x).collect::<~[&str]>();
                     assert!(comps.as_slice() == exp,
                             "rev_str_components: Expected {:?}, found {:?}",
                             comps.as_slice(), exp);
@@ -2301,12 +2304,12 @@ mod tests {
             (s: $path:expr, $exp:expr) => (
                 {
                     let path = Path::new($path);
-                    let comps = path.components().to_owned_vec();
+                    let comps = path.components().collect::<~[&[u8]]>();
                     let exp: &[&[u8]] = $exp;
                     assert!(comps.as_slice() == exp, "components: Expected {:?}, found {:?}",
                             comps.as_slice(), exp);
-                    let comps = path.rev_components().to_owned_vec();
-                    let exp = exp.rev_iter().map(|&x|x).to_owned_vec();
+                    let comps = path.rev_components().collect::<~[&[u8]]>();
+                    let exp = exp.rev_iter().map(|&x|x).collect::<~[&[u8]]>();
                     assert!(comps.as_slice() == exp,
                             "rev_components: Expected {:?}, found {:?}",
                             comps.as_slice(), exp);
diff --git a/src/libstd/slice.rs b/src/libstd/slice.rs
index 12718c55923..83f2299ad7b 100644
--- a/src/libstd/slice.rs
+++ b/src/libstd/slice.rs
@@ -436,7 +436,7 @@ impl ElementSwaps {
             emit_reset: true,
             sdir: range(0, length)
                     .map(|i| SizeDirection{ size: i, dir: Neg })
-                    .to_owned_vec()
+                    .collect::<~[_]>()
         }
     }
 }
@@ -3539,7 +3539,7 @@ mod tests {
                         let n = task_rng().gen::<uint>() % 10;
                         counts[n] += 1;
                         (n, counts[n])
-                    }).to_owned_vec();
+                    }).collect::<~[(uint, int)]>();
 
                 // only sort on the first element, so an unstable sort
                 // may mix up the counts.
@@ -4207,7 +4207,7 @@ mod tests {
         assert_eq!(xs.capacity(), 128);
         xs.shrink_to_fit();
         assert_eq!(xs.capacity(), 100);
-        assert_eq!(xs, range(0, 100).to_owned_vec());
+        assert_eq!(xs, range(0, 100).collect::<~[_]>());
     }
 
     #[test]
diff --git a/src/libstd/str.rs b/src/libstd/str.rs
index 0cd5e647831..6a3b4485a24 100644
--- a/src/libstd/str.rs
+++ b/src/libstd/str.rs
@@ -937,7 +937,7 @@ impl<'a> Iterator<UTF16Item> for UTF16Items<'a> {
 ///          0x0073, 0xDD1E, 0x0069, 0x0063,
 ///          0xD834];
 ///
-/// assert_eq!(str::utf16_items(v).to_owned_vec(),
+/// assert_eq!(str::utf16_items(v).collect::<~[_]>(),
 ///            ~[ScalarValue('𝄞'),
 ///              ScalarValue('m'), ScalarValue('u'), ScalarValue('s'),
 ///              LoneSurrogate(0xDD1E),
diff --git a/src/libstd/sync/deque.rs b/src/libstd/sync/deque.rs
index 658ee48af1a..80a5b9ce3bb 100644
--- a/src/libstd/sync/deque.rs
+++ b/src/libstd/sync/deque.rs
@@ -494,7 +494,7 @@ mod tests {
                     }
                 }
             })
-        }).to_owned_vec();
+        }).collect::<~[Thread<()>]>();
 
         while remaining.load(SeqCst) > 0 {
             match w.pop() {
@@ -525,7 +525,7 @@ mod tests {
             Thread::start(proc() {
                 stampede(w, s, 4, 10000);
             })
-        }).to_owned_vec();
+        }).collect::<~[Thread<()>]>();
 
         for thread in threads.move_iter() {
             thread.join();
@@ -556,7 +556,7 @@ mod tests {
                     }
                 }
             })
-        }).to_owned_vec();
+        }).collect::<~[Thread<()>]>();
 
         let mut rng = rand::task_rng();
         let mut expected = 0;