Update the rest of the compiler with ~[T] changes

5 files changed, 32 insertions, 34 deletions

diff --git a/src/libserialize/base64.rs b/src/libserialize/base64.rs
index 5a780b06e8a..92622e6c59f 100644
--- a/src/libserialize/base64.rs
+++ b/src/libserialize/base64.rs
@@ -79,7 +79,7 @@ impl<'a> ToBase64 for &'a [u8] {
             UrlSafe => URLSAFE_CHARS
         };
 
-        let mut v: ~[u8] = ~[];
+        let mut v = Vec::new();
         let mut i = 0;
         let mut cur_length = 0;
         let len = self.len();
@@ -146,7 +146,7 @@ impl<'a> ToBase64 for &'a [u8] {
         }
 
         unsafe {
-            str::raw::from_utf8_owned(v)
+            str::raw::from_utf8_owned(v.move_iter().collect())
         }
     }
 }
@@ -208,7 +208,7 @@ impl<'a> FromBase64 for &'a str {
      * ```
      */
     fn from_base64(&self) -> Result<~[u8], FromBase64Error> {
-        let mut r = ~[];
+        let mut r = Vec::new();
         let mut buf: u32 = 0;
         let mut modulus = 0;
 
@@ -256,7 +256,7 @@ impl<'a> FromBase64 for &'a str {
             _ => return Err(InvalidBase64Length),
         }
 
-        Ok(r)
+        Ok(r.move_iter().collect())
     }
 }
 
@@ -337,12 +337,12 @@ mod tests {
     #[test]
     fn test_base64_random() {
         use self::rand::{task_rng, random, Rng};
-        use std::slice;
 
         for _ in range(0, 1000) {
             let times = task_rng().gen_range(1u, 100);
-            let v = slice::from_fn(times, |_| random::<u8>());
-            assert_eq!(v.to_base64(STANDARD).from_base64().unwrap(), v);
+            let v = Vec::from_fn(times, |_| random::<u8>());
+            assert_eq!(v.as_slice().to_base64(STANDARD).from_base64().unwrap(),
+                       v.as_slice().to_owned());
         }
     }
 
diff --git a/src/libserialize/ebml.rs b/src/libserialize/ebml.rs
index 0efa93011fc..486150f1741 100644
--- a/src/libserialize/ebml.rs
+++ b/src/libserialize/ebml.rs
@@ -1099,8 +1099,7 @@ mod bench {
 
     #[bench]
     pub fn vuint_at_A_aligned(b: &mut Bencher) {
-        use std::slice;
-        let data = slice::from_fn(4*100, |i| {
+        let data = Vec::from_fn(4*100, |i| {
             match i % 2 {
               0 => 0x80u8,
               _ => i as u8,
@@ -1110,7 +1109,7 @@ mod bench {
         b.iter(|| {
             let mut i = 0;
             while i < data.len() {
-                sum += reader::vuint_at(data, i).unwrap().val;
+                sum += reader::vuint_at(data.as_slice(), i).unwrap().val;
                 i += 4;
             }
         });
@@ -1118,8 +1117,7 @@ mod bench {
 
     #[bench]
     pub fn vuint_at_A_unaligned(b: &mut Bencher) {
-        use std::slice;
-        let data = slice::from_fn(4*100+1, |i| {
+        let data = Vec::from_fn(4*100+1, |i| {
             match i % 2 {
               1 => 0x80u8,
               _ => i as u8
@@ -1129,7 +1127,7 @@ mod bench {
         b.iter(|| {
             let mut i = 1;
             while i < data.len() {
-                sum += reader::vuint_at(data, i).unwrap().val;
+                sum += reader::vuint_at(data.as_slice(), i).unwrap().val;
                 i += 4;
             }
         });
@@ -1137,8 +1135,7 @@ mod bench {
 
     #[bench]
     pub fn vuint_at_D_aligned(b: &mut Bencher) {
-        use std::slice;
-        let data = slice::from_fn(4*100, |i| {
+        let data = Vec::from_fn(4*100, |i| {
             match i % 4 {
               0 => 0x10u8,
               3 => i as u8,
@@ -1149,7 +1146,7 @@ mod bench {
         b.iter(|| {
             let mut i = 0;
             while i < data.len() {
-                sum += reader::vuint_at(data, i).unwrap().val;
+                sum += reader::vuint_at(data.as_slice(), i).unwrap().val;
                 i += 4;
             }
         });
@@ -1157,8 +1154,7 @@ mod bench {
 
     #[bench]
     pub fn vuint_at_D_unaligned(b: &mut Bencher) {
-        use std::slice;
-        let data = slice::from_fn(4*100+1, |i| {
+        let data = Vec::from_fn(4*100+1, |i| {
             match i % 4 {
               1 => 0x10u8,
               0 => i as u8,
@@ -1169,7 +1165,7 @@ mod bench {
         b.iter(|| {
             let mut i = 1;
             while i < data.len() {
-                sum += reader::vuint_at(data, i).unwrap().val;
+                sum += reader::vuint_at(data.as_slice(), i).unwrap().val;
                 i += 4;
             }
         });
diff --git a/src/libserialize/hex.rs b/src/libserialize/hex.rs
index 3584b19843b..fa383bef2dc 100644
--- a/src/libserialize/hex.rs
+++ b/src/libserialize/hex.rs
@@ -10,7 +10,6 @@
 
 //! Hex binary-to-text encoding
 use std::str;
-use std::slice;
 use std::fmt;
 
 /// A trait for converting a value to hexadecimal encoding
@@ -39,14 +38,14 @@ impl<'a> ToHex for &'a [u8] {
      * ```
      */
     fn to_hex(&self) -> ~str {
-        let mut v = slice::with_capacity(self.len() * 2);
+        let mut v = Vec::with_capacity(self.len() * 2);
         for &byte in self.iter() {
             v.push(CHARS[(byte >> 4) as uint]);
             v.push(CHARS[(byte & 0xf) as uint]);
         }
 
         unsafe {
-            str::raw::from_utf8_owned(v)
+            str::raw::from_utf8_owned(v.move_iter().collect())
         }
     }
 }
@@ -106,7 +105,7 @@ impl<'a> FromHex for &'a str {
      */
     fn from_hex(&self) -> Result<~[u8], FromHexError> {
         // This may be an overestimate if there is any whitespace
-        let mut b = slice::with_capacity(self.len() / 2);
+        let mut b = Vec::with_capacity(self.len() / 2);
         let mut modulus = 0;
         let mut buf = 0u8;
 
@@ -132,7 +131,7 @@ impl<'a> FromHex for &'a str {
         }
 
         match modulus {
-            0 => Ok(b),
+            0 => Ok(b.move_iter().collect()),
             _ => Err(InvalidHexLength),
         }
     }
diff --git a/src/libserialize/json.rs b/src/libserialize/json.rs
index 02afdb713ff..606f2b12af1 100644
--- a/src/libserialize/json.rs
+++ b/src/libserialize/json.rs
@@ -1230,11 +1230,11 @@ impl<T : Iterator<char>> Parser<T> {
         self.bump();
         self.parse_whitespace();
 
-        let mut values = ~[];
+        let mut values = Vec::new();
 
         if self.ch_is(']') {
             self.bump();
-            return Ok(List(values));
+            return Ok(List(values.move_iter().collect()));
         }
 
         loop {
@@ -1252,7 +1252,7 @@ impl<T : Iterator<char>> Parser<T> {
                 self.bump();
             } else if self.ch_is(']') {
                 self.bump();
-                return Ok(List(values));
+                return Ok(List(values.move_iter().collect()));
             } else {
                 return self.error(~"expected `,` or `]`")
             }
@@ -1332,14 +1332,14 @@ pub fn from_str(s: &str) -> DecodeResult<Json> {
 
 /// A structure to decode JSON to values in rust.
 pub struct Decoder {
-    stack: ~[Json],
+    stack: Vec<Json>,
 }
 
 impl Decoder {
     /// Creates a new decoder instance for decoding the specified JSON value.
     pub fn new(json: Json) -> Decoder {
         Decoder {
-            stack: ~[json]
+            stack: vec!(json),
         }
     }
 }
diff --git a/src/libserialize/serialize.rs b/src/libserialize/serialize.rs
index 6cda8d9ffb5..09b30077f6f 100644
--- a/src/libserialize/serialize.rs
+++ b/src/libserialize/serialize.rs
@@ -16,7 +16,6 @@ Core encoding and decoding interfaces.
 
 use std::path;
 use std::rc::Rc;
-use std::slice;
 
 pub trait Encoder<E> {
     // Primitive types:
@@ -443,11 +442,15 @@ impl<E, S:Encoder<E>,T:Encodable<S, E>> Encodable<S, E> for ~[T] {
 impl<E, D:Decoder<E>,T:Decodable<D, E>> Decodable<D, E> for ~[T] {
     fn decode(d: &mut D) -> Result<~[T], E> {
         d.read_seq(|d, len| {
-            let mut v: ~[T] = slice::with_capacity(len);
+            let mut v: Vec<T> = Vec::with_capacity(len);
             for i in range(0, len) {
                 v.push(try!(d.read_seq_elt(i, |d| Decodable::decode(d))));
             }
-            Ok(v)
+            println!("-------");
+            println!("{}", v.len());
+            let k = v.move_iter().collect::<~[T]>();
+            println!("{}", k.len());
+            Ok(k)
         })
     }
 }
@@ -594,11 +597,11 @@ pub trait DecoderHelpers<E> {
 impl<E, D:Decoder<E>> DecoderHelpers<E> for D {
     fn read_to_vec<T>(&mut self, f: |&mut D| -> Result<T, E>) -> Result<~[T], E> {
         self.read_seq(|this, len| {
-            let mut v = slice::with_capacity(len);
+            let mut v = Vec::with_capacity(len);
             for i in range(0, len) {
                 v.push(try!(this.read_seq_elt(i, |this| f(this))));
             }
-            Ok(v)
+            Ok(v.move_iter().collect())
         })
     }
 }