test: Automatically remove all `~[T]` from tests.

24 files changed, 115 insertions, 114 deletions

diff --git a/src/test/bench/core-std.rs b/src/test/bench/core-std.rs
index 6bf145e7976..edac363eb1a 100644
--- a/src/test/bench/core-std.rs
+++ b/src/test/bench/core-std.rs
@@ -21,6 +21,7 @@ use std::mem::swap;
 use std::os;
 use std::str;
 use std::slice;
+use std::vec;
 use std::io::File;
 
 macro_rules! bench (
@@ -61,8 +62,8 @@ fn maybe_run_test(argv: &[~str], name: ~str, test: ||) {
 }
 
 fn shift_push() {
-    let mut v1 = slice::from_elem(30000, 1);
-    let mut v2 = ~[];
+    let mut v1 = Vec::from_elem(30000, 1);
+    let mut v2 = Vec::new();
 
     while v1.len() > 0 {
         v2.push(v1.shift().unwrap());
@@ -85,7 +86,7 @@ fn read_line() {
 fn vec_plus() {
     let mut r = rand::task_rng();
 
-    let mut v = ~[];
+    let mut v = Vec::new();
     let mut i = 0;
     while i < 1500 {
         let rv = slice::from_elem(r.gen_range(0u, i + 1), i);
@@ -101,15 +102,15 @@ fn vec_plus() {
 fn vec_append() {
     let mut r = rand::task_rng();
 
-    let mut v = ~[];
+    let mut v = Vec::new();
     let mut i = 0;
     while i < 1500 {
         let rv = slice::from_elem(r.gen_range(0u, i + 1), i);
         if r.gen() {
-            v = slice::append(v, rv);
+            v = vec::append(v, rv);
         }
         else {
-            v = slice::append(rv, v);
+            v = vec::append(rv, v);
         }
         i += 1;
     }
@@ -118,7 +119,7 @@ fn vec_append() {
 fn vec_push_all() {
     let mut r = rand::task_rng();
 
-    let mut v = ~[];
+    let mut v = Vec::new();
     for i in range(0u, 1500) {
         let mut rv = slice::from_elem(r.gen_range(0u, i + 1), i);
         if r.gen() {
@@ -132,7 +133,7 @@ fn vec_push_all() {
 }
 
 fn is_utf8_ascii() {
-    let mut v : ~[u8] = ~[];
+    let mut v : Vec<u8> = Vec::new();
     for _ in range(0u, 20000) {
         v.push('b' as u8);
         if !str::is_utf8(v) {
@@ -143,7 +144,7 @@ fn is_utf8_ascii() {
 
 fn is_utf8_multibyte() {
     let s = "b¢€𤭢";
-    let mut v : ~[u8]= ~[];
+    let mut v : Vec<u8> = Vec::new();
     for _ in range(0u, 5000) {
         v.push_all(s.as_bytes());
         if !str::is_utf8(v) {
diff --git a/src/test/bench/core-uint-to-str.rs b/src/test/bench/core-uint-to-str.rs
index db86be1dfd4..07571b17905 100644
--- a/src/test/bench/core-uint-to-str.rs
+++ b/src/test/bench/core-uint-to-str.rs
@@ -14,9 +14,9 @@ use std::uint;
 fn main() {
     let args = os::args();
     let args = if os::getenv("RUST_BENCH").is_some() {
-        ~[~"", ~"10000000"]
+        vec!(~"", ~"10000000")
     } else if args.len() <= 1u {
-        ~[~"", ~"100000"]
+        vec!(~"", ~"100000")
     } else {
         args
     };
diff --git a/src/test/bench/msgsend-pipes-shared.rs b/src/test/bench/msgsend-pipes-shared.rs
index be081afc39e..ea07320dd94 100644
--- a/src/test/bench/msgsend-pipes-shared.rs
+++ b/src/test/bench/msgsend-pipes-shared.rs
@@ -59,7 +59,7 @@ fn run(args: &[~str]) {
     let workers = from_str::<uint>(args[2]).unwrap();
     let num_bytes = 100;
     let start = time::precise_time_s();
-    let mut worker_results = ~[];
+    let mut worker_results = Vec::new();
     for _ in range(0u, workers) {
         let to_child = to_child.clone();
         let mut builder = task::task();
@@ -96,9 +96,9 @@ fn run(args: &[~str]) {
 fn main() {
     let args = os::args();
     let args = if os::getenv("RUST_BENCH").is_some() {
-        ~[~"", ~"1000000", ~"10000"]
+        vec!(~"", ~"1000000", ~"10000")
     } else if args.len() <= 1u {
-        ~[~"", ~"10000", ~"4"]
+        vec!(~"", ~"10000", ~"4")
     } else {
         args.clone()
     };
diff --git a/src/test/bench/msgsend-pipes.rs b/src/test/bench/msgsend-pipes.rs
index 518b2d4c9ef..7e2c5ba46b2 100644
--- a/src/test/bench/msgsend-pipes.rs
+++ b/src/test/bench/msgsend-pipes.rs
@@ -53,7 +53,7 @@ fn run(args: &[~str]) {
     let workers = from_str::<uint>(args[2]).unwrap();
     let num_bytes = 100;
     let start = time::precise_time_s();
-    let mut worker_results = ~[];
+    let mut worker_results = Vec::new();
     let from_parent = if workers == 1 {
         let (to_child, from_parent) = channel();
         let mut builder = task::task();
@@ -106,9 +106,9 @@ fn run(args: &[~str]) {
 fn main() {
     let args = os::args();
     let args = if os::getenv("RUST_BENCH").is_some() {
-        ~[~"", ~"1000000", ~"8"]
+        vec!(~"", ~"1000000", ~"8")
     } else if args.len() <= 1u {
-        ~[~"", ~"10000", ~"4"]
+        vec!(~"", ~"10000", ~"4")
     } else {
         args.clone()
     };
diff --git a/src/test/bench/msgsend-ring-mutex-arcs.rs b/src/test/bench/msgsend-ring-mutex-arcs.rs
index 6bf25f2149c..7cd904d7d14 100644
--- a/src/test/bench/msgsend-ring-mutex-arcs.rs
+++ b/src/test/bench/msgsend-ring-mutex-arcs.rs
@@ -25,7 +25,7 @@ use std::os;
 use std::uint;
 
 // A poor man's pipe.
-type pipe = MutexArc<~[uint]>;
+type pipe = MutexArc<Vec<uint> >;
 
 fn send(p: &pipe, msg: uint) {
     unsafe {
@@ -47,7 +47,7 @@ fn recv(p: &pipe) -> uint {
 }
 
 fn init() -> (pipe,pipe) {
-    let m = MutexArc::new(~[]);
+    let m = MutexArc::new(Vec::new());
     ((&m).clone(), m)
 }
 
@@ -71,9 +71,9 @@ fn thread_ring(i: uint, count: uint, num_chan: pipe, num_port: pipe) {
 fn main() {
     let args = os::args();
     let args = if os::getenv("RUST_BENCH").is_some() {
-        ~[~"", ~"100", ~"10000"]
+        vec!(~"", ~"100", ~"10000")
     } else if args.len() <= 1u {
-        ~[~"", ~"10", ~"100"]
+        vec!(~"", ~"10", ~"100")
     } else {
         args.clone()
     };
@@ -86,7 +86,7 @@ fn main() {
     let start = time::precise_time_s();
 
     // create the ring
-    let mut futures = ~[];
+    let mut futures = Vec::new();
 
     for i in range(1u, num_tasks) {
         //println!("spawning %?", i);
diff --git a/src/test/bench/msgsend-ring-rw-arcs.rs b/src/test/bench/msgsend-ring-rw-arcs.rs
index 90d7da65e1f..c615c510465 100644
--- a/src/test/bench/msgsend-ring-rw-arcs.rs
+++ b/src/test/bench/msgsend-ring-rw-arcs.rs
@@ -24,7 +24,7 @@ use std::os;
 use std::uint;
 
 // A poor man's pipe.
-type pipe = RWArc<~[uint]>;
+type pipe = RWArc<Vec<uint> >;
 
 fn send(p: &pipe, msg: uint) {
     p.write_cond(|state, cond| {
@@ -42,7 +42,7 @@ fn recv(p: &pipe) -> uint {
 }
 
 fn init() -> (pipe,pipe) {
-    let x = RWArc::new(~[]);
+    let x = RWArc::new(Vec::new());
     ((&x).clone(), x)
 }
 
@@ -66,9 +66,9 @@ fn thread_ring(i: uint, count: uint, num_chan: pipe, num_port: pipe) {
 fn main() {
     let args = os::args();
     let args = if os::getenv("RUST_BENCH").is_some() {
-        ~[~"", ~"100", ~"10000"]
+        vec!(~"", ~"100", ~"10000")
     } else if args.len() <= 1u {
-        ~[~"", ~"10", ~"100"]
+        vec!(~"", ~"10", ~"100")
     } else {
         args.clone()
     };
@@ -81,7 +81,7 @@ fn main() {
     let start = time::precise_time_s();
 
     // create the ring
-    let mut futures = ~[];
+    let mut futures = Vec::new();
 
     for i in range(1u, num_tasks) {
         //println!("spawning %?", i);
diff --git a/src/test/bench/shootout-ackermann.rs b/src/test/bench/shootout-ackermann.rs
index 889d663fb5b..00075415f49 100644
--- a/src/test/bench/shootout-ackermann.rs
+++ b/src/test/bench/shootout-ackermann.rs
@@ -25,9 +25,9 @@ fn ack(m: int, n: int) -> int {
 fn main() {
     let args = os::args();
     let args = if os::getenv("RUST_BENCH").is_some() {
-        ~[~"", ~"12"]
+        vec!(~"", ~"12")
     } else if args.len() <= 1u {
-        ~[~"", ~"8"]
+        vec!(~"", ~"8")
     } else {
         args
     };
diff --git a/src/test/bench/shootout-chameneos-redux.rs b/src/test/bench/shootout-chameneos-redux.rs
index 51aff969996..c4671b4203f 100644
--- a/src/test/bench/shootout-chameneos-redux.rs
+++ b/src/test/bench/shootout-chameneos-redux.rs
@@ -39,7 +39,7 @@ fn show_color(cc: color) -> ~str {
     }
 }
 
-fn show_color_list(set: ~[color]) -> ~str {
+fn show_color_list(set: vec!(color)) -> ~str {
     let mut out = ~"";
     for col in set.iter() {
         out.push_char(' ');
@@ -132,7 +132,7 @@ fn creature(
     }
 }
 
-fn rendezvous(nn: uint, set: ~[color]) {
+fn rendezvous(nn: uint, set: vec!(color)) {
 
     // these ports will allow us to hear from the creatures
     let (to_rendezvous, from_creatures) = channel::<CreatureInfo>();
@@ -141,7 +141,7 @@ fn rendezvous(nn: uint, set: ~[color]) {
     // these channels will be passed to the creatures so they can talk to us
 
     // these channels will allow us to talk to each creature by 'name'/index
-    let to_creature: ~[Sender<Option<CreatureInfo>>] =
+    let to_creature: Vec<Sender<Option<CreatureInfo>>> =
         set.iter().enumerate().map(|(ii, col)| {
             // create each creature as a listener with a port, and
             // give us a channel to talk to each
@@ -179,7 +179,7 @@ fn rendezvous(nn: uint, set: ~[color]) {
     }
 
     // save each creature's meeting stats
-    let mut report = ~[];
+    let mut report = Vec::new();
     for _to_one in to_creature.iter() {
         report.push(from_creatures_log.recv());
     }
@@ -199,9 +199,9 @@ fn rendezvous(nn: uint, set: ~[color]) {
 fn main() {
     let args = os::args();
     let args = if os::getenv("RUST_BENCH").is_some() {
-        ~[~"", ~"200000"]
+        vec!(~"", ~"200000")
     } else if args.len() <= 1u {
-        ~[~"", ~"600"]
+        vec!(~"", ~"600")
     } else {
         args
     };
@@ -211,9 +211,9 @@ fn main() {
     print_complements();
     println!("");
 
-    rendezvous(nn, ~[Blue, Red, Yellow]);
+    rendezvous(nn, vec!(Blue, Red, Yellow));
     println!("");
 
     rendezvous(nn,
-        ~[Blue, Red, Yellow, Red, Yellow, Blue, Red, Yellow, Red, Blue]);
+        vec!(Blue, Red, Yellow, Red, Yellow, Blue, Red, Yellow, Red, Blue));
 }
diff --git a/src/test/bench/shootout-fasta-redux.rs b/src/test/bench/shootout-fasta-redux.rs
index fead298bc86..a21963ee0a9 100644
--- a/src/test/bench/shootout-fasta-redux.rs
+++ b/src/test/bench/shootout-fasta-redux.rs
@@ -59,8 +59,8 @@ static HOMO_SAPIENS: [AminoAcid, ..4] = [
 ];
 
 // FIXME: Use map().
-fn sum_and_scale(a: &'static [AminoAcid]) -> ~[AminoAcid] {
-    let mut result = ~[];
+fn sum_and_scale(a: &'static [AminoAcid]) -> Vec<AminoAcid> {
+    let mut result = Vec::new();
     let mut p = 0f32;
     for a_i in a.iter() {
         let mut a_i = *a_i;
diff --git a/src/test/bench/shootout-fasta.rs b/src/test/bench/shootout-fasta.rs
index ae0bd069c90..76ac8407d60 100644
--- a/src/test/bench/shootout-fasta.rs
+++ b/src/test/bench/shootout-fasta.rs
@@ -36,8 +36,7 @@ impl MyRandom {
 
 struct AAGen<'a> {
     rng: &'a mut MyRandom,
-    data: ~[(u32, u8)]
-}
+    data: Vec<(u32, u8)> }
 impl<'a> AAGen<'a> {
     fn new<'b>(rng: &'b mut MyRandom, aa: &[(char, f32)]) -> AAGen<'b> {
         let mut cum = 0.;
diff --git a/src/test/bench/shootout-fibo.rs b/src/test/bench/shootout-fibo.rs
index 785481819aa..eec54198c04 100644
--- a/src/test/bench/shootout-fibo.rs
+++ b/src/test/bench/shootout-fibo.rs
@@ -21,9 +21,9 @@ fn fib(n: int) -> int {
 fn main() {
     let args = os::args();
     let args = if os::getenv("RUST_BENCH").is_some() {
-        ~[~"", ~"40"]
+        vec!(~"", ~"40")
     } else if args.len() <= 1u {
-        ~[~"", ~"30"]
+        vec!(~"", ~"30")
     } else {
         args
     };
diff --git a/src/test/bench/shootout-k-nucleotide-pipes.rs b/src/test/bench/shootout-k-nucleotide-pipes.rs
index 0b5a19aaec8..1b1a41e610c 100644
--- a/src/test/bench/shootout-k-nucleotide-pipes.rs
+++ b/src/test/bench/shootout-k-nucleotide-pipes.rs
@@ -42,19 +42,19 @@ fn f64_cmp(x: f64, y: f64) -> Ordering {
 }
 
 // given a map, print a sorted version of it
-fn sort_and_fmt(mm: &HashMap<~[u8], uint>, total: uint) -> ~str {
+fn sort_and_fmt(mm: &HashMap<Vec<u8> , uint>, total: uint) -> ~str {
    fn pct(xx: uint, yy: uint) -> f64 {
       return (xx as f64) * 100.0 / (yy as f64);
    }
 
    // sort by key, then by value
-   fn sortKV(mut orig: ~[(~[u8],f64)]) -> ~[(~[u8],f64)] {
+   fn sortKV(mut orig: Vec<(Vec<u8> ,f64)> ) -> Vec<(Vec<u8> ,f64)> {
         orig.sort_by(|&(ref a, _), &(ref b, _)| a.cmp(b));
         orig.sort_by(|&(_, a), &(_, b)| f64_cmp(b, a));
         orig
    }
 
-   let mut pairs = ~[];
+   let mut pairs = Vec::new();
 
    // map -> [(k,%)]
    for (key, &val) in mm.iter() {
@@ -76,7 +76,7 @@ fn sort_and_fmt(mm: &HashMap<~[u8], uint>, total: uint) -> ~str {
 }
 
 // given a map, search for the frequency of a pattern
-fn find(mm: &HashMap<~[u8], uint>, key: ~str) -> uint {
+fn find(mm: &HashMap<Vec<u8> , uint>, key: ~str) -> uint {
    let key = key.into_ascii().to_lower().into_str();
    match mm.find_equiv(&key.as_bytes()) {
       option::None      => { return 0u; }
@@ -85,7 +85,7 @@ fn find(mm: &HashMap<~[u8], uint>, key: ~str) -> uint {
 }
 
 // given a map, increment the counter for a key
-fn update_freq(mm: &mut HashMap<~[u8], uint>, key: &[u8]) {
+fn update_freq(mm: &mut HashMap<Vec<u8> , uint>, key: &[u8]) {
     let key = key.to_owned();
     let newval = match mm.pop(&key) {
         Some(v) => v + 1,
@@ -97,7 +97,7 @@ fn update_freq(mm: &mut HashMap<~[u8], uint>, key: &[u8]) {
 // given a ~[u8], for each window call a function
 // i.e., for "hello" and windows of size four,
 // run it("hell") and it("ello"), then return "llo"
-fn windows_with_carry(bb: &[u8], nn: uint, it: |window: &[u8]|) -> ~[u8] {
+fn windows_with_carry(bb: &[u8], nn: uint, it: |window: &[u8]|) -> Vec<u8> {
    let mut ii = 0u;
 
    let len = bb.len();
@@ -110,18 +110,18 @@ fn windows_with_carry(bb: &[u8], nn: uint, it: |window: &[u8]|) -> ~[u8] {
 }
 
 fn make_sequence_processor(sz: uint,
-                           from_parent: &Receiver<~[u8]>,
+                           from_parent: &Receiver<Vec<u8>>,
                            to_parent: &Sender<~str>) {
-   let mut freqs: HashMap<~[u8], uint> = HashMap::new();
-   let mut carry: ~[u8] = ~[];
+   let mut freqs: HashMap<Vec<u8>, uint> = HashMap::new();
+   let mut carry = Vec::new();
    let mut total: uint = 0u;
 
-   let mut line: ~[u8];
+   let mut line: Vec<u8> ;
 
    loop {
 
       line = from_parent.recv();
-      if line == ~[] { break; }
+      if line == Vec::new() { break; }
 
        carry = windows_with_carry(carry + line, sz, |window| {
          update_freq(&mut freqs, window);
@@ -156,9 +156,9 @@ fn main() {
     let mut rdr = BufferedReader::new(rdr);
 
     // initialize each sequence sorter
-    let sizes = ~[1u,2,3,4,6,12,18];
-    let mut streams = slice::from_fn(sizes.len(), |_| Some(channel::<~str>()));
-    let mut from_child = ~[];
+    let sizes = vec!(1u,2,3,4,6,12,18);
+    let mut streams = Vec::from_fn(sizes.len(), |_| Some(channel::<~str>()));
+    let mut from_child = Vec::new();
     let to_child  = sizes.iter().zip(streams.mut_iter()).map(|(sz, stream_ref)| {
         let sz = *sz;
         let stream = replace(stream_ref, None);
@@ -173,7 +173,7 @@ fn main() {
         });
 
         to_child
-    }).collect::<~[Sender<~[u8]>]>();
+    }).collect::<Vec<Sender<Vec<u8> >> >();
 
 
    // latch stores true after we've started
@@ -215,7 +215,7 @@ fn main() {
 
    // finish...
    for (ii, _sz) in sizes.iter().enumerate() {
-       to_child[ii].send(~[]);
+       to_child[ii].send(Vec::new());
    }
 
    // now fetch and print result messages
diff --git a/src/test/bench/shootout-k-nucleotide.rs b/src/test/bench/shootout-k-nucleotide.rs
index 1a981480ebe..d2cf4599df2 100644
--- a/src/test/bench/shootout-k-nucleotide.rs
+++ b/src/test/bench/shootout-k-nucleotide.rs
@@ -50,7 +50,7 @@ impl Code {
     // FIXME: Inefficient.
     fn unpack(&self, frame: i32) -> ~str {
         let mut key = self.hash();
-        let mut result = ~[];
+        let mut result = Vec::new();
         for _ in range(0, frame) {
             result.push(unpack_symbol((key as u8) & 3));
             key >>= 2;
@@ -92,8 +92,7 @@ struct Entry {
 
 struct Table {
     count: i32,
-    items: ~[Option<~Entry>]
-}
+    items: Vec<Option<~Entry>> }
 
 struct Items<'a> {
     cur: Option<&'a Entry>,
@@ -237,7 +236,7 @@ fn generate_frequencies(frequencies: &mut Table,
 }
 
 fn print_frequencies(frequencies: &Table, frame: i32) {
-    let mut vector = ~[];
+    let mut vector = Vec::new();
     for entry in frequencies.iter() {
         vector.push((entry.code, entry.count));
     }
diff --git a/src/test/bench/shootout-meteor.rs b/src/test/bench/shootout-meteor.rs
index 97f2c887515..81b712cf9c6 100644
--- a/src/test/bench/shootout-meteor.rs
+++ b/src/test/bench/shootout-meteor.rs
@@ -63,7 +63,7 @@ impl<'a, T> Iterator<&'a T> for ListIterator<'a, T> {
 // corresponding mirrored piece), with, as minimum coordinates, (0,
 // 0).  If all is false, only generate half of the possibilities (used
 // to break the symetry of the board).
-fn transform(piece: ~[(int, int)], all: bool) -> ~[~[(int, int)]] {
+fn transform(piece: Vec<(int, int)> , all: bool) -> vec!(Vec<(int, int)> ) {
     let mut res =
         // rotations
         iterate(piece, |rot| rot.iter().map(|&(y, x)| (x + y, -y)).collect())
@@ -107,25 +107,25 @@ fn mask(dy: int, dx: int, id: uint, p: &[(int, int)]) -> Option<u64> {
 // Makes every possible masks.  masks[id][i] correspond to every
 // possible masks for piece with identifier id with minimum coordinate
 // (i/5, i%5).
-fn make_masks() -> ~[~[~[u64]]] {
-    let pieces = ~[
-        ~[(0,0),(0,1),(0,2),(0,3),(1,3)],
-        ~[(0,0),(0,2),(0,3),(1,0),(1,1)],
-        ~[(0,0),(0,1),(0,2),(1,2),(2,1)],
-        ~[(0,0),(0,1),(0,2),(1,1),(2,1)],
-        ~[(0,0),(0,2),(1,0),(1,1),(2,1)],
-        ~[(0,0),(0,1),(0,2),(1,1),(1,2)],
-        ~[(0,0),(0,1),(1,1),(1,2),(2,1)],
-        ~[(0,0),(0,1),(0,2),(1,0),(1,2)],
-        ~[(0,0),(0,1),(0,2),(1,2),(1,3)],
-        ~[(0,0),(0,1),(0,2),(0,3),(1,2)]];
-    let mut res = ~[];
+fn make_masks() -> Vec<Vec<Vec<u64> > > {
+    let pieces = vec!(
+        vec!((0,0),(0,1),(0,2),(0,3),(1,3)),
+        vec!((0,0),(0,2),(0,3),(1,0),(1,1)),
+        vec!((0,0),(0,1),(0,2),(1,2),(2,1)),
+        vec!((0,0),(0,1),(0,2),(1,1),(2,1)),
+        vec!((0,0),(0,2),(1,0),(1,1),(2,1)),
+        vec!((0,0),(0,1),(0,2),(1,1),(1,2)),
+        vec!((0,0),(0,1),(1,1),(1,2),(2,1)),
+        vec!((0,0),(0,1),(0,2),(1,0),(1,2)),
+        vec!((0,0),(0,1),(0,2),(1,2),(1,3)),
+        vec!((0,0),(0,1),(0,2),(0,3),(1,2)));
+    let mut res = Vec::new();
     for (id, p) in pieces.move_iter().enumerate() {
         // To break the central symetry of the problem, every
         // transformation must be taken except for one piece (piece 3
         // here).
         let trans = transform(p, id != 3);
-        let mut cur_piece = ~[];
+        let mut cur_piece = Vec::new();
         for dy in range(0, 10) {
             for dx in range(0, 5) {
                 let masks =
@@ -142,7 +142,7 @@ fn make_masks() -> ~[~[~[u64]]] {
 
 // Check if all coordinates can be covered by an unused piece and that
 // all unused piece can be placed on the board.
-fn is_board_unfeasible(board: u64, masks: &[~[~[u64]]]) -> bool {
+fn is_board_unfeasible(board: u64, masks: &[Vec<Vec<u64> > ]) -> bool {
     let mut coverable = board;
     for i in range(0, 50).filter(|&i| board & 1 << i == 0) {
         for (cur_id, pos_masks) in masks.iter().enumerate() {
@@ -159,7 +159,7 @@ fn is_board_unfeasible(board: u64, masks: &[~[~[u64]]]) -> bool {
 }
 
 // Filter the masks that we can prove to result to unfeasible board.
-fn filter_masks(masks: &[~[~[u64]]]) -> ~[~[~[u64]]] {
+fn filter_masks(masks: &[Vec<Vec<u64> > ]) -> Vec<Vec<Vec<u64> > > {
     masks.iter().map(
         |p| p.iter().map(
             |p| p.iter()
@@ -180,7 +180,7 @@ fn get_id(m: u64) -> u8 {
 
 // Converts a list of mask to a ~str.
 fn to_utf8(raw_sol: &List<u64>) -> ~str {
-    let mut sol: ~[u8] = std::slice::from_elem(50, '.' as u8);
+    let mut sol: Vec<u8> = Vec::from_elem(50, '.' as u8);
     for &m in raw_sol.iter() {
         let id = get_id(m);
         for i in range(0, 50) {
@@ -237,7 +237,7 @@ fn handle_sol(raw_sol: &List<u64>, data: &mut Data) -> bool {
 // Search for every solutions.  Returns false if the search was
 // stopped before the end.
 fn search(
-    masks: &[~[~[u64]]],
+    masks: &[Vec<Vec<u64> > ],
     board: u64,
     mut i: int,
     cur: List<u64>,
diff --git a/src/test/bench/shootout-nbody.rs b/src/test/bench/shootout-nbody.rs
index ce49b8b2141..72ae6c4d014 100644
--- a/src/test/bench/shootout-nbody.rs
+++ b/src/test/bench/shootout-nbody.rs
@@ -148,9 +148,9 @@ fn offset_momentum(bodies: &mut [Planet, ..N_BODIES]) {
 fn main() {
     let args = os::args();
     let args = if os::getenv("RUST_BENCH").is_some() {
-        ~[~"", ~"1000"]
+        vec!(~"", ~"1000")
     } else if args.len() <= 1u {
-        ~[~"", ~"1000"]
+        vec!(~"", ~"1000")
     } else {
         args
     };
diff --git a/src/test/bench/shootout-pfib.rs b/src/test/bench/shootout-pfib.rs
index 78cd5f4c30a..6c3b75ef473 100644
--- a/src/test/bench/shootout-pfib.rs
+++ b/src/test/bench/shootout-pfib.rs
@@ -51,8 +51,8 @@ struct Config {
     stress: bool
 }
 
-fn parse_opts(argv: ~[~str]) -> Config {
-    let opts = ~[getopts::optflag("", "stress", "")];
+fn parse_opts(argv: Vec<~str> ) -> Config {
+    let opts = vec!(getopts::optflag("", "stress", ""));
 
     let opt_args = argv.slice(1, argv.len());
 
@@ -75,7 +75,7 @@ fn stress_task(id: int) {
 }
 
 fn stress(num_tasks: int) {
-    let mut results = ~[];
+    let mut results = Vec::new();
     for i in range(0, num_tasks) {
         let mut builder = task::task();
         results.push(builder.future_result());
@@ -91,9 +91,9 @@ fn stress(num_tasks: int) {
 fn main() {
     let args = os::args();
     let args = if os::getenv("RUST_BENCH").is_some() {
-        ~[~"", ~"20"]
+        vec!(~"", ~"20")
     } else if args.len() <= 1u {
-        ~[~"", ~"8"]
+        vec!(~"", ~"8")
     } else {
         args
     };
diff --git a/src/test/bench/shootout-spectralnorm.rs b/src/test/bench/shootout-spectralnorm.rs
index ea8253f6e42..a387c6d146a 100644
--- a/src/test/bench/shootout-spectralnorm.rs
+++ b/src/test/bench/shootout-spectralnorm.rs
@@ -29,8 +29,10 @@ fn dot(v: &[f64], u: &[f64]) -> f64 {
     sum
 }
 
-fn mult(v: RWArc<~[f64]>, out: RWArc<~[f64]>, f: fn(&~[f64], uint) -> f64) {
-    // We lanch in different tasks the work to be done.  To finish
+fn mult(v: RWArc<Vec<f64>>,
+        out: RWArc<Vec<f64>>,
+        f: fn(&Vec<f64>, uint) -> f64) {
+    // We launch in different tasks the work to be done.  To finish
     // this fuction, we need to wait for the completion of every
     // tasks.  To do that, we give to each tasks a wait_chan that we
     // drop at the end of the work.  At the end of this function, we
@@ -58,7 +60,7 @@ fn mult(v: RWArc<~[f64]>, out: RWArc<~[f64]>, f: fn(&~[f64], uint) -> f64) {
     for () in rx.iter() {}
 }
 
-fn mult_Av_impl(v: &~[f64], i: uint) -> f64 {
+fn mult_Av_impl(v: &Vec<f64> , i: uint) -> f64 {
     let mut sum = 0.;
     for (j, &v_j) in v.iter().enumerate() {
         sum += v_j / A(i, j);
@@ -66,11 +68,11 @@ fn mult_Av_impl(v: &~[f64], i: uint) -> f64 {
     sum
 }
 
-fn mult_Av(v: RWArc<~[f64]>, out: RWArc<~[f64]>) {
+fn mult_Av(v: RWArc<Vec<f64> >, out: RWArc<Vec<f64> >) {
     mult(v, out, mult_Av_impl);
 }
 
-fn mult_Atv_impl(v: &~[f64], i: uint) -> f64 {
+fn mult_Atv_impl(v: &Vec<f64> , i: uint) -> f64 {
     let mut sum = 0.;
     for (j, &v_j) in v.iter().enumerate() {
         sum += v_j / A(j, i);
@@ -78,11 +80,11 @@ fn mult_Atv_impl(v: &~[f64], i: uint) -> f64 {
     sum
 }
 
-fn mult_Atv(v: RWArc<~[f64]>, out: RWArc<~[f64]>) {
+fn mult_Atv(v: RWArc<Vec<f64> >, out: RWArc<Vec<f64> >) {
     mult(v, out, mult_Atv_impl);
 }
 
-fn mult_AtAv(v: RWArc<~[f64]>, out: RWArc<~[f64]>, tmp: RWArc<~[f64]>) {
+fn mult_AtAv(v: RWArc<Vec<f64> >, out: RWArc<Vec<f64> >, tmp: RWArc<Vec<f64> >) {
     mult_Av(v, tmp.clone());
     mult_Atv(tmp, out);
 }
diff --git a/src/test/bench/shootout-threadring.rs b/src/test/bench/shootout-threadring.rs
index 7f2cd368219..cfb950090a2 100644
--- a/src/test/bench/shootout-threadring.rs
+++ b/src/test/bench/shootout-threadring.rs
@@ -55,7 +55,7 @@ fn main() {
     use std::from_str::FromStr;
 
     let args = if os::getenv("RUST_BENCH").is_some() {
-        ~[~"", ~"2000000", ~"503"]
+        vec!(~"", ~"2000000", ~"503")
     }
     else {
         os::args()
diff --git a/src/test/bench/std-smallintmap.rs b/src/test/bench/std-smallintmap.rs
index 98deeec7e18..674b6a8b36a 100644
--- a/src/test/bench/std-smallintmap.rs
+++ b/src/test/bench/std-smallintmap.rs
@@ -32,9 +32,9 @@ fn check_sequential(min: uint, max: uint, map: &SmallIntMap<uint>) {
 fn main() {
     let args = os::args();
     let args = if os::getenv("RUST_BENCH").is_some() {
-        ~[~"", ~"100000", ~"100"]
+        vec!(~"", ~"100000", ~"100")
     } else if args.len() <= 1u {
-        ~[~"", ~"10000", ~"50"]
+        vec!(~"", ~"10000", ~"50")
     } else {
         args
     };
diff --git a/src/test/bench/sudoku.rs b/src/test/bench/sudoku.rs
index ba94290bd03..79eee4006ce 100644
--- a/src/test/bench/sudoku.rs
+++ b/src/test/bench/sudoku.rs
@@ -36,7 +36,7 @@ use std::slice;
 //
 
 // internal type of sudoku grids
-type grid = ~[~[u8]];
+type grid = Vec<Vec<u8> > ;
 
 struct Sudoku {
     grid: grid
@@ -68,9 +68,9 @@ impl Sudoku {
     pub fn read(mut reader: BufferedReader<StdReader>) -> Sudoku {
         assert!(reader.read_line().unwrap() == ~"9,9"); /* assert first line is exactly "9,9" */
 
-        let mut g = slice::from_fn(10u, { |_i| ~[0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8] });
+        let mut g = slice::from_fn(10u, { |_i| vec!(0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8) });
         for line in reader.lines() {
-            let comps: ~[&str] = line.unwrap().trim().split(',').collect();
+            let comps: Vec<&str> = line.trim().split(',').collect();
 
             if comps.len() == 3u {
                 let row     = from_str::<uint>(comps[0]).unwrap() as u8;
@@ -96,7 +96,7 @@ impl Sudoku {
 
     // solve sudoku grid
     pub fn solve(&mut self) {
-        let mut work: ~[(u8, u8)] = ~[]; /* queue of uncolored fields */
+        let mut work: Vec<(u8, u8)> = Vec::new(); /* queue of uncolored fields */
         for row in range(0u8, 9u8) {
             for col in range(0u8, 9u8) {
                 let color = self.grid[row][col];
diff --git a/src/test/bench/task-perf-alloc-unwind.rs b/src/test/bench/task-perf-alloc-unwind.rs
index e0938a8ae03..1a33391a3d2 100644
--- a/src/test/bench/task-perf-alloc-unwind.rs
+++ b/src/test/bench/task-perf-alloc-unwind.rs
@@ -50,7 +50,7 @@ struct State {
     managed: @nillist,
     unique: ~nillist,
     tuple: (@nillist, ~nillist),
-    vec: ~[@nillist],
+    vec: vec!(@nillist),
     res: r
 }
 
@@ -82,7 +82,7 @@ fn recurse_or_fail(depth: int, st: Option<State>) {
                 managed: @Nil,
                 unique: ~Nil,
                 tuple: (@Nil, ~Nil),
-                vec: ~[@Nil],
+                vec: vec!(@Nil),
                 res: r(@Nil)
             }
           }
diff --git a/src/test/bench/task-perf-jargon-metal-smoke.rs b/src/test/bench/task-perf-jargon-metal-smoke.rs
index 0bad9b507f9..9a57be54362 100644
--- a/src/test/bench/task-perf-jargon-metal-smoke.rs
+++ b/src/test/bench/task-perf-jargon-metal-smoke.rs
@@ -41,9 +41,9 @@ fn child_generation(gens_left: uint, tx: comm::Sender<()>) {
 fn main() {
     let args = os::args();
     let args = if os::getenv("RUST_BENCH").is_some() {
-        ~[~"", ~"100000"]
+        vec!(~"", ~"100000")
     } else if args.len() <= 1 {
-        ~[~"", ~"100"]
+        vec!(~"", ~"100")
     } else {
         args.clone()
     };
diff --git a/src/test/bench/task-perf-one-million.rs b/src/test/bench/task-perf-one-million.rs
index 75975b76ecb..39648f7a161 100644
--- a/src/test/bench/task-perf-one-million.rs
+++ b/src/test/bench/task-perf-one-million.rs
@@ -19,7 +19,7 @@ use std::slice;
 
 fn calc(children: uint, parent_wait_chan: &Sender<Sender<Sender<int>>>) {
 
-    let wait_ports: ~[Receiver<Sender<Sender<int>>>] = slice::from_fn(children, |_| {
+    let wait_ports: Vec<Reciever<Sender<Sender<int>>>> = vec::from_fn(children, |_| {
         let (wait_port, wait_chan) = stream::<Sender<Sender<int>>>();
         task::spawn(proc() {
             calc(children / 2, &wait_chan);
@@ -27,14 +27,14 @@ fn calc(children: uint, parent_wait_chan: &Sender<Sender<Sender<int>>>) {
         wait_port
     });
 
-    let child_start_chans: ~[Sender<Sender<int>>] =
+    let child_start_chans: Vec<Sender<Sender<int>>> =
         wait_ports.move_iter().map(|port| port.recv()).collect();
 
     let (start_port, start_chan) = stream::<Sender<int>>();
     parent_wait_chan.send(start_chan);
     let parent_result_chan: Sender<int> = start_port.recv();
 
-    let child_sum_ports: ~[Receiver<int>] =
+    let child_sum_ports: Vec<Reciever<int>> =
         child_start_chans.move_iter().map(|child_start_chan| {
             let (child_sum_port, child_sum_chan) = stream::<int>();
             child_start_chan.send(child_sum_chan);
@@ -49,9 +49,9 @@ fn calc(children: uint, parent_wait_chan: &Sender<Sender<Sender<int>>>) {
 fn main() {
     let args = os::args();
     let args = if os::getenv("RUST_BENCH").is_some() {
-        ~[~"", ~"30"]
+        vec!(~"", ~"30")
     } else if args.len() <= 1u {
-        ~[~"", ~"10"]
+        vec!(~"", ~"10")
     } else {
         args
     };
diff --git a/src/test/bench/task-perf-spawnalot.rs b/src/test/bench/task-perf-spawnalot.rs
index e322aceb5e6..3a45e88b81a 100644
--- a/src/test/bench/task-perf-spawnalot.rs
+++ b/src/test/bench/task-perf-spawnalot.rs
@@ -25,9 +25,9 @@ fn g() { }
 fn main() {
     let args = os::args();
     let args = if os::getenv("RUST_BENCH").is_some() {
-        ~[~"", ~"400"]
+        vec!(~"", ~"400")
     } else if args.len() <= 1u {
-        ~[~"", ~"10"]
+        vec!(~"", ~"10")
     } else {
         args
     };