Make vectors uglier ([]/~). Sorry. Should be temporary. Closes #2725.

author: Michael Sullivan <sully@msully.net> 2012-06-25 20:00:46 -0700
committer: Michael Sullivan <sully@msully.net> 2012-06-25 20:00:46 -0700
commit: 329eca6044fdf376a7a89ec7a96dba7a8b884cf7 (patch)
tree: 7008814278a066914b6ba36818388d5212ffda9f /src/test
parent: c087aaf56b1109163126fea4c2760f8414ffbe56 (diff)
download: rust-329eca6044fdf376a7a89ec7a96dba7a8b884cf7.tar.gz
rust-329eca6044fdf376a7a89ec7a96dba7a8b884cf7.zip
242 files changed, 614 insertions, 614 deletions
diff --git a/src/test/auxiliary/cci_class_6.rs b/src/test/auxiliary/cci_class_6.rs
index 15fa3e3e785..8460b670753 100644
--- a/src/test/auxiliary/cci_class_6.rs
+++ b/src/test/auxiliary/cci_class_6.rs
@@ -2,17 +2,17 @@ mod kitties {
 
 class cat<U> {
   priv {
-    let mut info : [U];
+    let mut info : [U]/~;
     let mut meows : uint;
   }
 
   let how_hungry : int;
 
-  new(in_x : uint, in_y : int, -in_info: [U])
+  new(in_x : uint, in_y : int, -in_info: [U]/~)
     { self.meows = in_x; self.how_hungry = in_y;
       self.info <- in_info; }
 
-  fn speak<T>(stuff: [T]) {
+  fn speak<T>(stuff: [T]/~) {
     self.meows += stuff.len();
   }
   fn meow_count() -> uint { self.meows }
diff --git a/src/test/auxiliary/cci_iter_lib.rs b/src/test/auxiliary/cci_iter_lib.rs
index 50d9df243e7..af575dc00f6 100644
--- a/src/test/auxiliary/cci_iter_lib.rs
+++ b/src/test/auxiliary/cci_iter_lib.rs
@@ -1,7 +1,7 @@
 #[link(name="cci_iter_lib", vers="0.0")];
 
 #[inline]
-fn iter<T>(v: [T], f: fn(T)) {
+fn iter<T>(v: [T]/~, f: fn(T)) {
     let mut i = 0u;
     let n = vec::len(v);
     while i < n {
diff --git a/src/test/auxiliary/cci_no_inline_lib.rs b/src/test/auxiliary/cci_no_inline_lib.rs
index 42f959a4a7d..468ebeb198c 100644
--- a/src/test/auxiliary/cci_no_inline_lib.rs
+++ b/src/test/auxiliary/cci_no_inline_lib.rs
@@ -1,7 +1,7 @@
 #[link(name="cci_no_inline_lib", vers="0.0")];
 
 // same as cci_iter_lib, more-or-less, but not marked inline
-fn iter(v: [uint], f: fn(uint)) {
+fn iter(v: [uint]/~, f: fn(uint)) {
     let mut i = 0u;
     let n = vec::len(v);
     while i < n {
diff --git a/src/test/auxiliary/issue2378a.rs b/src/test/auxiliary/issue2378a.rs
index 35269a2d653..dfe0f582435 100644
--- a/src/test/auxiliary/issue2378a.rs
+++ b/src/test/auxiliary/issue2378a.rs
@@ -1,7 +1,7 @@
 enum maybe<T> { just(T), nothing }
 
 impl methods<T:copy> for maybe<T> {
-    fn [](idx: uint) -> T {
+    fn []/~(idx: uint) -> T {
         alt self {
           just(t) { t }
           nothing { fail; }
diff --git a/src/test/auxiliary/issue2378b.rs b/src/test/auxiliary/issue2378b.rs
index 9cfe4d3a368..e26be8c6973 100644
--- a/src/test/auxiliary/issue2378b.rs
+++ b/src/test/auxiliary/issue2378b.rs
@@ -6,7 +6,7 @@ import issue2378a::methods;
 type two_maybes<T> = {a: maybe<T>, b: maybe<T>};
 
 impl methods<T:copy> for two_maybes<T> {
-    fn [](idx: uint) -> (T, T) {
+    fn []/~(idx: uint) -> (T, T) {
         (self.a[idx], self.b[idx])
     }
 }
\ No newline at end of file
diff --git a/src/test/bench/core-uint-to-str.rs b/src/test/bench/core-uint-to-str.rs
index 026ce3fe061..a711ae5dd46 100644
--- a/src/test/bench/core-uint-to-str.rs
+++ b/src/test/bench/core-uint-to-str.rs
@@ -1,4 +1,4 @@
-fn main(args: [str]) {
+fn main(args: [str]/~) {
     let args = if os::getenv("RUST_BENCH").is_some() {
         ["", "10000000"]
     } else if args.len() <= 1u {
diff --git a/src/test/bench/core-vec-append.rs b/src/test/bench/core-vec-append.rs
index cde1c76e344..e46cf25fade 100644
--- a/src/test/bench/core-vec-append.rs
+++ b/src/test/bench/core-vec-append.rs
@@ -4,15 +4,15 @@ use std;
 import dvec::{dvec, extensions};
 import io::writer_util;
 
-fn collect_raw(num: uint) -> [uint] {
-    let mut result = [];
+fn collect_raw(num: uint) -> [uint]/~ {
+    let mut result = []/~;
     for uint::range(0u, num) { |i|
         vec::push(result, i);
     }
     ret result;
 }
 
-fn collect_dvec(num: uint) -> [mut uint] {
+fn collect_dvec(num: uint) -> [mut uint]/~ {
     let result = dvec();
     for uint::range(0u, num) { |i|
         result.push(i);
@@ -20,7 +20,7 @@ fn collect_dvec(num: uint) -> [mut uint] {
     ret dvec::unwrap(result);
 }
 
-fn main(args: [str]) {
+fn main(args: [str]/~) {
     let args = if os::getenv("RUST_BENCH").is_some() {
         ["", "50000000"]
     } else if args.len() <= 1u {
diff --git a/src/test/bench/graph500-bfs.rs b/src/test/bench/graph500-bfs.rs
index 56733b29178..edad5e0dbba 100644
--- a/src/test/bench/graph500-bfs.rs
+++ b/src/test/bench/graph500-bfs.rs
@@ -16,10 +16,10 @@ import comm::*;
 import int::abs;
 
 type node_id = i64;
-type graph = [[node_id]];
-type bfs_result = [node_id];
+type graph = [[node_id]/~]/~;
+type bfs_result = [node_id]/~;
 
-fn make_edges(scale: uint, edgefactor: uint) -> [(node_id, node_id)] {
+fn make_edges(scale: uint, edgefactor: uint) -> [(node_id, node_id)]/~ {
     let r = rand::xorshift();
 
     fn choose_edge(i: node_id, j: node_id, scale: uint, r: rand::rng)
@@ -65,7 +65,7 @@ fn make_edges(scale: uint, edgefactor: uint) -> [(node_id, node_id)] {
     }
 }
 
-fn make_graph(N: uint, edges: [(node_id, node_id)]) -> graph {
+fn make_graph(N: uint, edges: [(node_id, node_id)]/~) -> graph {
     let graph = vec::from_fn(N) {|_i| 
         map::hashmap::<node_id, ()>({|x| x as uint }, {|x, y| x == y })
     };
@@ -82,7 +82,7 @@ fn make_graph(N: uint, edges: [(node_id, node_id)]) -> graph {
     }
 }
 
-fn gen_search_keys(graph: graph, n: uint) -> [node_id] {
+fn gen_search_keys(graph: graph, n: uint) -> [node_id]/~ {
     let keys = map::hashmap::<node_id, ()>({|x| x as uint }, {|x, y| x == y });
     let r = rand::rng();
 
@@ -102,7 +102,7 @@ fn gen_search_keys(graph: graph, n: uint) -> [node_id] {
 
 Nodes that are unreachable have a parent of -1."]
 fn bfs(graph: graph, key: node_id) -> bfs_result {
-    let marks : [mut node_id] 
+    let marks : [mut node_id]/~ 
         = vec::to_mut(vec::from_elem(vec::len(graph), -1i64));
 
     let Q = deque::create();
@@ -278,7 +278,7 @@ fn pbfs(&&graph: arc::arc<graph>, key: node_id) -> bfs_result {
 }
 
 #[doc="Performs at least some of the validation in the Graph500 spec."]
-fn validate(edges: [(node_id, node_id)], 
+fn validate(edges: [(node_id, node_id)]/~, 
             root: node_id, tree: bfs_result) -> bool {
     // There are 5 things to test. Below is code for each of them.
 
@@ -293,7 +293,7 @@ fn validate(edges: [(node_id, node_id)],
     let mut status = true;
     let level = tree.map() {|parent| 
         let mut parent = parent;
-        let mut path = [];
+        let mut path = []/~;
 
         if parent == -1i64 {
             // This node was not in the tree.
@@ -371,7 +371,7 @@ fn validate(edges: [(node_id, node_id)],
     true
 }
 
-fn main(args: [str]) {
+fn main(args: [str]/~) {
     let args = if os::getenv("RUST_BENCH").is_some() {
         ["", "15", "48"]
     } else if args.len() <= 1u {
diff --git a/src/test/bench/msgsend-ring-new.rs b/src/test/bench/msgsend-ring-new.rs
index cba62f2ada1..b8e74520b8f 100644
--- a/src/test/bench/msgsend-ring-new.rs
+++ b/src/test/bench/msgsend-ring-new.rs
@@ -21,7 +21,7 @@ fn thread_ring(i: uint,
     };
 }
 
-fn main(args: [str]) {
+fn main(args: [str]/~) {
     let args = if os::getenv("RUST_BENCH").is_some() {
         ["", "100", "10000"]
     } else if args.len() <= 1u {
@@ -39,7 +39,7 @@ fn main(args: [str]) {
     let start = time::precise_time_s();
 
     // create the ring
-    let mut futures = [];
+    let mut futures = []/~;
 
     for uint::range(1u, num_tasks) {|i|
         let get_chan = port();
@@ -50,7 +50,7 @@ fn main(args: [str]) {
                 let p = port();
                 get_chan_chan.send(chan(p));
                 thread_ring(i, msg_per_task, num_chan,  p)
-            }];
+            }]/~;
         }
         
         num_chan = get_chan.recv();
diff --git a/src/test/bench/msgsend-ring.rs b/src/test/bench/msgsend-ring.rs
index 442b6e62dd1..5b59005e572 100644
--- a/src/test/bench/msgsend-ring.rs
+++ b/src/test/bench/msgsend-ring.rs
@@ -21,7 +21,7 @@ fn thread_ring(i: uint,
     };
 }
 
-fn main(args: [str]) {
+fn main(args: [str]/~) {
     let args = if os::getenv("RUST_BENCH").is_some() {
         ["", "100", "10000"]
     } else if args.len() <= 1u {
@@ -39,7 +39,7 @@ fn main(args: [str]) {
     let start = time::precise_time_s();
 
     // create the ring
-    let mut futures = [];
+    let mut futures = []/~;
 
     for uint::range(1u, num_tasks) {|i|
         let get_chan = port();
@@ -49,7 +49,7 @@ fn main(args: [str]) {
             let p = port();
             get_chan_chan.send(chan(p));
             thread_ring(i, msg_per_task, num_chan,  p)
-        }];
+        }]/~;
         
         num_chan = get_chan.recv();
     };
diff --git a/src/test/bench/msgsend.rs b/src/test/bench/msgsend.rs
index b6a6ba60a9f..cea712635a0 100644
--- a/src/test/bench/msgsend.rs
+++ b/src/test/bench/msgsend.rs
@@ -27,7 +27,7 @@ fn server(requests: comm::port<request>, responses: comm::chan<uint>) {
     comm::send(responses, count);
 }
 
-fn run(args: [str]) {
+fn run(args: [str]/~) {
     let from_child = comm::port();
     let to_parent = comm::chan(from_child);
     let to_child = task::spawn_listener {|po|
@@ -37,7 +37,7 @@ fn run(args: [str]) {
     let workers = option::get(uint::from_str(args[2]));
     let start = std::time::precise_time_s();
     let to_child = to_child;
-    let mut worker_results = [];
+    let mut worker_results = []/~;
     for uint::range(0u, workers) {|_i|
         let builder = task::builder();
         vec::push(worker_results, task::future_result(builder));
@@ -58,7 +58,7 @@ fn run(args: [str]) {
     io::stdout().write_str(#fmt("Throughput=%f per sec\n", thruput));
 }
 
-fn main(args: [str]) {
+fn main(args: [str]/~) {
     let args = if os::getenv("RUST_BENCH").is_some() {
         ["", "1000000", "10000"]
     } else if args.len() <= 1u {
diff --git a/src/test/bench/shootout-ackermann.rs b/src/test/bench/shootout-ackermann.rs
index 8969bdfc0b7..8f1f95b2581 100644
--- a/src/test/bench/shootout-ackermann.rs
+++ b/src/test/bench/shootout-ackermann.rs
@@ -12,7 +12,7 @@ fn ack(m: int, n: int) -> int {
     }
 }
 
-fn main(args: [str]) {
+fn main(args: [str]/~) {
     let args = if os::getenv("RUST_BENCH").is_some() {
         ["", "12"]
     } else if args.len() <= 1u {
diff --git a/src/test/bench/shootout-binarytrees.rs b/src/test/bench/shootout-binarytrees.rs
index 6486602cc6e..b2769a36e89 100644
--- a/src/test/bench/shootout-binarytrees.rs
+++ b/src/test/bench/shootout-binarytrees.rs
@@ -22,7 +22,7 @@ fn bottom_up_tree(arena: &a.arena::arena, item: int, depth: int) -> &a.tree {
     ret new(*arena) nil;
 }
 
-fn main(args: [str]) {
+fn main(args: [str]/~) {
     let args = if os::getenv("RUST_BENCH").is_some() {
         ["", "17"]
     } else if args.len() <= 1u {
diff --git a/src/test/bench/shootout-fannkuchredux.rs b/src/test/bench/shootout-fannkuchredux.rs
index 654f75d8260..7a518e8c394 100644
--- a/src/test/bench/shootout-fannkuchredux.rs
+++ b/src/test/bench/shootout-fannkuchredux.rs
@@ -58,7 +58,7 @@ fn fannkuch(n: int) -> int {
     ret flips;
 }
 
-fn main(args: [str]) {
+fn main(args: [str]/~) {
     let args = if os::getenv("RUST_BENCH").is_some() {
         ["", "10"]
     } else if args.len() <= 1u {
diff --git a/src/test/bench/shootout-fasta.rs b/src/test/bench/shootout-fasta.rs
index 4910673cb29..0670f928adb 100644
--- a/src/test/bench/shootout-fasta.rs
+++ b/src/test/bench/shootout-fasta.rs
@@ -23,16 +23,16 @@ fn myrandom_next(r: myrandom, mx: u32) -> u32 {
 
 type aminoacids = {ch: char, prob: u32};
 
-fn make_cumulative(aa: [aminoacids]) -> [aminoacids] {
+fn make_cumulative(aa: [aminoacids]/~) -> [aminoacids]/~ {
     let mut cp: u32 = 0u32;
-    let mut ans: [aminoacids] = [];
-    for aa.each {|a| cp += a.prob; ans += [{ch: a.ch, prob: cp}]; }
+    let mut ans: [aminoacids]/~ = []/~;
+    for aa.each {|a| cp += a.prob; ans += [{ch: a.ch, prob: cp}]/~; }
     ret ans;
 }
 
-fn select_random(r: u32, genelist: [aminoacids]) -> char {
+fn select_random(r: u32, genelist: [aminoacids]/~) -> char {
     if r < genelist[0].prob { ret genelist[0].ch; }
-    fn bisect(v: [aminoacids], lo: uint, hi: uint, target: u32) -> char {
+    fn bisect(v: [aminoacids]/~, lo: uint, hi: uint, target: u32) -> char {
         if hi > lo + 1u {
             let mid: uint = lo + (hi - lo) / 2u;
             if target < v[mid].prob {
@@ -43,7 +43,7 @@ fn select_random(r: u32, genelist: [aminoacids]) -> char {
     ret bisect(genelist, 0u, vec::len::<aminoacids>(genelist) - 1u, r);
 }
 
-fn make_random_fasta(wr: io::writer, id: str, desc: str, genelist: [aminoacids], n: int) {
+fn make_random_fasta(wr: io::writer, id: str, desc: str, genelist: [aminoacids]/~, n: int) {
     wr.write_line(">" + id + " " + desc);
     let rng = @{mut last: std::rand::rng().next()};
     let mut op: str = "";
@@ -74,7 +74,7 @@ fn make_repeat_fasta(wr: io::writer, id: str, desc: str, s: str, n: int) unsafe
 
 fn acid(ch: char, prob: u32) -> aminoacids { ret {ch: ch, prob: prob}; }
 
-fn main(args: [str]) {
+fn main(args: [str]/~) {
     let args = if os::getenv("RUST_BENCH").is_some() {
         // alioth tests k-nucleotide with this data at 25,000,000
         ["", "5000000"]
@@ -85,22 +85,22 @@ fn main(args: [str]) {
     };
 
     let writer = if os::getenv("RUST_BENCH").is_some() {
-        result::get(io::file_writer("./shootout-fasta.data", [io::truncate, io::create]))
+        result::get(io::file_writer("./shootout-fasta.data", [io::truncate, io::create]/~))
     } else {
         io::stdout()
     };
 
     let n = int::from_str(args[1]).get();
 
-    let iub: [aminoacids] =
+    let iub: [aminoacids]/~ =
         make_cumulative([acid('a', 27u32), acid('c', 12u32), acid('g', 12u32),
                          acid('t', 27u32), acid('B', 2u32), acid('D', 2u32),
                          acid('H', 2u32), acid('K', 2u32), acid('M', 2u32),
                          acid('N', 2u32), acid('R', 2u32), acid('S', 2u32),
-                         acid('V', 2u32), acid('W', 2u32), acid('Y', 2u32)]);
-    let homosapiens: [aminoacids] =
+                         acid('V', 2u32), acid('W', 2u32), acid('Y', 2u32)]/~);
+    let homosapiens: [aminoacids]/~ =
         make_cumulative([acid('a', 30u32), acid('c', 20u32), acid('g', 20u32),
-                         acid('t', 30u32)]);
+                         acid('t', 30u32)]/~);
     let alu: str =
         "GGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGG" +
             "GAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGA" +
diff --git a/src/test/bench/shootout-fibo.rs b/src/test/bench/shootout-fibo.rs
index df621254284..2f076343cfd 100644
--- a/src/test/bench/shootout-fibo.rs
+++ b/src/test/bench/shootout-fibo.rs
@@ -8,7 +8,7 @@ fn fib(n: int) -> int {
     }
 }
 
-fn main(args: [str]) {
+fn main(args: [str]/~) {
     let args = if os::getenv("RUST_BENCH").is_some() {
         ["", "40"]
     } else if args.len() <= 1u {
diff --git a/src/test/bench/shootout-k-nucleotide.rs b/src/test/bench/shootout-k-nucleotide.rs
index 26e8b938468..b6811db4b62 100644
--- a/src/test/bench/shootout-k-nucleotide.rs
+++ b/src/test/bench/shootout-k-nucleotide.rs
@@ -10,7 +10,7 @@ import std::map::hashmap;
 import std::sort;
 
 // 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<[u8]/~, uint>, total: uint) -> str { 
    fn pct(xx: uint, yy: uint) -> float {
       ret (xx as float) * 100f / (yy as float);
    }
@@ -28,14 +28,14 @@ fn sort_and_fmt(mm: hashmap<[u8], uint>, total: uint) -> str {
    }
 
    // sort by key, then by value
-   fn sortKV<TT: copy, UU: copy>(orig: [(TT,UU)]) -> [(TT,UU)] {
+   fn sortKV<TT: copy, UU: copy>(orig: [(TT,UU)]/~) -> [(TT,UU)]/~ {
       ret sort::merge_sort(le_by_val, sort::merge_sort(le_by_key, orig));
    }
 
-   let mut pairs = [];
+   let mut pairs = []/~;
 
    // map -> [(k,%)]
-   mm.each(fn&(key: [u8], val: uint) -> bool {
+   mm.each(fn&(key: [u8]/~, val: uint) -> bool {
       vec::push(pairs, (key, pct(val, total)));
       ret true;
    });
@@ -44,7 +44,7 @@ fn sort_and_fmt(mm: hashmap<[u8], uint>, total: uint) -> str {
    
    let mut buffer = "";
 
-   pairs_sorted.each(fn&(kv: ([u8], float)) -> bool unsafe {
+   pairs_sorted.each(fn&(kv: ([u8]/~, float)) -> bool unsafe {
       let (k,v) = kv;
       buffer += (#fmt["%s %0.3f\n", str::to_upper(str::unsafe::from_bytes(k)), v]);
       ret true;
@@ -54,7 +54,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<[u8]/~, uint>, key: str) -> uint {
    alt mm.find(str::bytes(str::to_lower(key))) {
       option::none      { ret 0u; }
       option::some(num) { ret num; }
@@ -62,17 +62,17 @@ fn find(mm: hashmap<[u8], uint>, key: str) -> uint {
 }
 
 // given a map, increment the counter for a key
-fn update_freq(mm: hashmap<[u8], uint>, key: [u8]) {
+fn update_freq(mm: hashmap<[u8]/~, uint>, key: [u8]/~) {
    alt mm.find(key) {
       option::none      { mm.insert(key, 1u      ); }
       option::some(val) { mm.insert(key, 1u + val); }
    }
 }
 
-// given a [u8], for each window call a function
+// 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: [const u8], nn: uint, it: fn(window: [u8])) -> [u8] {
+fn windows_with_carry(bb: [const u8]/~, nn: uint, it: fn(window: [u8]/~)) -> [u8]/~ {
    let mut ii = 0u;
 
    let len = vec::len(bb);
@@ -84,18 +84,18 @@ fn windows_with_carry(bb: [const u8], nn: uint, it: fn(window: [u8])) -> [u8] {
    ret vec::slice(bb, len - (nn - 1u), len); 
 }
 
-fn make_sequence_processor(sz: uint, from_parent: comm::port<[u8]>, to_parent: comm::chan<str>) {
+fn make_sequence_processor(sz: uint, from_parent: comm::port<[u8]/~>, to_parent: comm::chan<str>) {
    
-   let freqs: hashmap<[u8], uint> = map::bytes_hash();
-   let mut carry: [u8] = [];
+   let freqs: hashmap<[u8]/~, uint> = map::bytes_hash();
+   let mut carry: [u8]/~ = []/~;
    let mut total: uint = 0u;
 
-   let mut line: [u8];
+   let mut line: [u8]/~;
 
    loop {
 
       line = comm::recv(from_parent);
-      if line == [] { break; }
+      if line == []/~ { break; }
 
       carry = windows_with_carry(carry + line, sz, { |window|
          update_freq(freqs, window);
@@ -119,7 +119,7 @@ fn make_sequence_processor(sz: uint, from_parent: comm::port<[u8]>, to_parent: c
 }
 
 // given a FASTA file on stdin, process sequence THREE
-fn main(args: [str]) {
+fn main(args: [str]/~) {
    let rdr = if os::getenv("RUST_BENCH").is_some() {
        // FIXME: Using this compile-time env variable is a crummy way to
        // get to this massive data set, but #include_bin chokes on it (#2598)
@@ -135,10 +135,10 @@ fn main(args: [str]) {
 
 
    // initialize each sequence sorter
-   let sizes = [1u,2u,3u,4u,6u,12u,18u];
+   let sizes = [1u,2u,3u,4u,6u,12u,18u]/~;
    let from_child = vec::map (sizes, { |_sz|     comm::port() });
    let to_parent  = vec::mapi(sizes, { |ii, _sz| comm::chan(from_child[ii]) });
-   let to_child   = vec::mapi(sizes, fn@(ii: uint, sz: uint) -> comm::chan<[u8]> {
+   let to_child   = vec::mapi(sizes, fn@(ii: uint, sz: uint) -> comm::chan<[u8]/~> {
       ret task::spawn_listener { |from_parent|
          make_sequence_processor(sz, from_parent, to_parent[ii]);
       };
diff --git a/src/test/bench/shootout-mandelbrot.rs b/src/test/bench/shootout-mandelbrot.rs
index 7254b5bbb9e..8b91f8310e7 100644
--- a/src/test/bench/shootout-mandelbrot.rs
+++ b/src/test/bench/shootout-mandelbrot.rs
@@ -17,7 +17,7 @@ import io::writer_util;
 import std::map::hashmap;
 
 type cmplx = {re: f64, im: f64};
-type line = {i: uint, b: [u8]};
+type line = {i: uint, b: [u8]/~};
 
 impl arith for cmplx {
     fn *(x: cmplx) -> cmplx {
@@ -65,7 +65,7 @@ fn fillbyte(x: cmplx, incr: f64) -> u8 {
 
 fn chanmb(i: uint, size: uint, ch: comm::chan<line>) -> ()
 {
-    let mut crv = [];
+    let mut crv = []/~;
     let incr = 2f64/(size as f64);
     let y = incr*(i as f64) - 1f64;
     let xincr = 8f64*incr;
@@ -101,7 +101,7 @@ fn writer(path: str, writech: comm::chan<comm::chan<line>>, size: uint)
         _ {
             result::get(
                 io::file_writer(path,
-                [io::create, io::truncate]))
+                [io::create, io::truncate]/~))
         }
     };
     cout.write_line("P4");
@@ -121,7 +121,7 @@ fn writer(path: str, writech: comm::chan<comm::chan<line>>, size: uint)
                     #debug("WS %u", prev);
                     // FIXME (#2280): this temporary shouldn't be
                     // necessary, but seems to be, for borrowing.
-                    let v : [u8] = lines.get(prev);
+                    let v : [u8]/~ = lines.get(prev);
                     cout.write(v);
                     done += 1_u;
                     lines.remove(prev);
@@ -140,7 +140,7 @@ fn writer(path: str, writech: comm::chan<comm::chan<line>>, size: uint)
     }
 }
 
-fn main(args: [str]) {
+fn main(args: [str]/~) {
     let args = if os::getenv("RUST_BENCH").is_some() {
         ["", "4000", "10"]
     } else {
diff --git a/src/test/bench/shootout-nbody.rs b/src/test/bench/shootout-nbody.rs
index 9cc506887e4..518d1c39d85 100644
--- a/src/test/bench/shootout-nbody.rs
+++ b/src/test/bench/shootout-nbody.rs
@@ -13,7 +13,7 @@ native mod libc {
     fn sqrt(n: float) -> float;
 }
 
-fn main(args: [str]) {
+fn main(args: [str]/~) {
     let args = if os::getenv("RUST_BENCH").is_some() {
         ["", "4000000"]
     } else if args.len() <= 1u {
@@ -22,7 +22,7 @@ fn main(args: [str]) {
         args
     };
     let n = int::from_str(args[1]).get();
-    let bodies: [Body::props] = NBodySystem::MakeNBodySystem();
+    let bodies: [Body::props]/~ = NBodySystem::MakeNBodySystem();
     io::println(#fmt("%f", NBodySystem::energy(bodies)));
     let mut i: int = 0;
     while i < n { NBodySystem::advance(bodies, 0.01); i += 1; }
@@ -34,11 +34,11 @@ fn main(args: [str]) {
 
 mod NBodySystem {
 
-    fn MakeNBodySystem() -> [Body::props] {
+    fn MakeNBodySystem() -> [Body::props]/~ {
         // these each return a Body::props
-        let bodies: [Body::props] =
+        let bodies: [Body::props]/~ =
             [Body::sun(), Body::jupiter(), Body::saturn(), Body::uranus(),
-             Body::neptune()];
+             Body::neptune()]/~;
 
         let mut px: float = 0.0;
         let mut py: float = 0.0;
@@ -59,7 +59,7 @@ mod NBodySystem {
         ret bodies;
     }
 
-    fn advance(bodies: [Body::props], dt: float) {
+    fn advance(bodies: [Body::props]/~, dt: float) {
 
         let mut i: int = 0;
         while i < 5 {
@@ -98,7 +98,7 @@ mod NBodySystem {
         b.z += dt * b.vz;
     }
 
-    fn energy(bodies: [Body::props]) -> float unsafe {
+    fn energy(bodies: [Body::props]/~) -> float unsafe {
         let mut dx: float;
         let mut dy: float;
         let mut dz: float;
diff --git a/src/test/bench/shootout-pfib.rs b/src/test/bench/shootout-pfib.rs
index bb922c93e61..b81d27df5b5 100644
--- a/src/test/bench/shootout-pfib.rs
+++ b/src/test/bench/shootout-pfib.rs
@@ -46,8 +46,8 @@ fn fib(n: int) -> int {
 
 type config = {stress: bool};
 
-fn parse_opts(argv: [str]) -> config {
-    let opts = [getopts::optflag("stress")];
+fn parse_opts(argv: [str]/~) -> config {
+    let opts = [getopts::optflag("stress")]/~;
 
     let opt_args = vec::slice(argv, 1u, vec::len(argv));
 
@@ -69,16 +69,16 @@ fn stress_task(&&id: int) {
 }
 
 fn stress(num_tasks: int) {
-    let mut results = [];
+    let mut results = []/~;
     for range(0, num_tasks) {|i|
         let builder = task::builder();
-        results += [task::future_result(builder)];
+        results += [task::future_result(builder)]/~;
         task::run(builder) {|| stress_task(i); }
     }
     for results.each {|r| future::get(r); }
 }
 
-fn main(args: [str]) {
+fn main(args: [str]/~) {
     let args = if os::getenv("RUST_BENCH").is_some() {
         ["", "20"]
     } else if args.len() <= 1u {
diff --git a/src/test/bench/shootout-spectralnorm.rs b/src/test/bench/shootout-spectralnorm.rs
index 22b2b332586..37e3380554b 100644
--- a/src/test/bench/shootout-spectralnorm.rs
+++ b/src/test/bench/shootout-spectralnorm.rs
@@ -6,7 +6,7 @@ fn eval_A(i: uint, j: uint) -> float {
     1.0/(((i+j)*(i+j+1u)/2u+i+1u) as float)
 }
 
-fn eval_A_times_u(u: [const float], Au: [mut float]) {
+fn eval_A_times_u(u: [const float]/~, Au: [mut float]/~) {
     let N = vec::len(u);
     let mut i = 0u;
     while i < N {
@@ -20,7 +20,7 @@ fn eval_A_times_u(u: [const float], Au: [mut float]) {
     }
 }
 
-fn eval_At_times_u(u: [const float], Au: [mut float]) {
+fn eval_At_times_u(u: [const float]/~, Au: [mut float]/~) {
     let N = vec::len(u);
     let mut i = 0u;
     while i < N {
@@ -34,13 +34,13 @@ fn eval_At_times_u(u: [const float], Au: [mut float]) {
     }
 }
 
-fn eval_AtA_times_u(u: [const float], AtAu: [mut float]) {
+fn eval_AtA_times_u(u: [const float]/~, AtAu: [mut float]/~) {
     let v = vec::to_mut(vec::from_elem(vec::len(u), 0.0));
     eval_A_times_u(u, v);
     eval_At_times_u(v, AtAu);
 }
 
-fn main(args: [str]) {
+fn main(args: [str]/~) {
     let args = if os::getenv("RUST_BENCH").is_some() {
         ["", "2000"]
     } else if args.len() <= 1u {
diff --git a/src/test/bench/shootout-threadring.rs b/src/test/bench/shootout-threadring.rs
index 5f9219d0804..9d8c5cc165b 100644
--- a/src/test/bench/shootout-threadring.rs
+++ b/src/test/bench/shootout-threadring.rs
@@ -37,7 +37,7 @@ fn roundtrip(id: int, p: comm::port<int>, ch: comm::chan<int>) {
     }
 }
 
-fn main(args: [str]) {
+fn main(args: [str]/~) {
     let args = if os::getenv("RUST_BENCH").is_some() {
         ["", "2000000"]
     } else if args.len() <= 1u {
diff --git a/src/test/bench/std-smallintmap.rs b/src/test/bench/std-smallintmap.rs
index 86b13dfc171..b043264ff93 100644
--- a/src/test/bench/std-smallintmap.rs
+++ b/src/test/bench/std-smallintmap.rs
@@ -17,7 +17,7 @@ fn check_sequential(min: uint, max: uint, map: smallintmap<uint>) {
     }
 }
 
-fn main(args: [str]) {
+fn main(args: [str]/~) {
     let args = if os::getenv("RUST_BENCH").is_some() {
         ["", "100000", "100"]
     } else if args.len() <= 1u {
diff --git a/src/test/bench/sudoku.rs b/src/test/bench/sudoku.rs
index 3973905c807..5b3b104a342 100644
--- a/src/test/bench/sudoku.rs
+++ b/src/test/bench/sudoku.rs
@@ -22,7 +22,7 @@ import io::{writer_util, reader_util};
 export grid_t, read_grid, solve_grid, write_grid;
 
 // internal type of sudoku grids
-type grid = [[mut u8]];
+type grid = [[mut u8]/~]/~;
 
 // exported type of sudoku grids
 enum grid_t { grid_ctor(grid), }
@@ -92,11 +92,11 @@ fn solve_grid(g: grid_t) {
         }
     }
 
-    let mut work: [(u8, u8)] = []; /* queue of uncolored fields */
+    let mut work: [(u8, u8)]/~ = []/~; /* queue of uncolored fields */
     for u8::range(0u8, 9u8) { |row|
         for u8::range(0u8, 9u8) { |col|
             let color = (*g)[row][col];
-            if color == 0u8 { work += [(row, col)]; }
+            if color == 0u8 { work += [(row, col)]/~; }
         }
     }
 
@@ -126,7 +126,7 @@ fn write_grid(f: io::writer, g: grid_t) {
      }
 }
 
-fn main(args: [str]) {
+fn main(args: [str]/~) {
     let grid = if vec::len(args) == 1u {
         // FIXME create sudoku inline since nested vec consts dont work yet
         // (#571)
diff --git a/src/test/bench/task-perf-alloc-unwind.rs b/src/test/bench/task-perf-alloc-unwind.rs
index aee9b148cca..f10e198e29f 100644
--- a/src/test/bench/task-perf-alloc-unwind.rs
+++ b/src/test/bench/task-perf-alloc-unwind.rs
@@ -36,7 +36,7 @@ enum st {
         fn_box: fn@() -> @nillist,
         fn_unique: fn~() -> ~nillist,
         tuple: (@nillist, ~nillist),
-        vec: [@nillist],
+        vec: [@nillist]/~,
         res: r
     })
 }
@@ -62,7 +62,7 @@ fn recurse_or_fail(depth: int, st: option<st>) {
                 fn_box: fn@() -> @nillist { @nil::<()> },
                 fn_unique: fn~() -> ~nillist { ~nil::<()> },
                 tuple: (@nil, ~nil),
-                vec: [@nil],
+                vec: [@nil]/~,
                 res: r(@nil)
             })
           }
@@ -77,7 +77,7 @@ fn recurse_or_fail(depth: int, st: option<st>) {
                 fn_unique: fn~() -> ~nillist { ~cons((), @*fn_unique()) },
                 tuple: (@cons((), first(st.tuple)),
                         ~cons((), @*second(st.tuple))),
-                vec: st.vec + [@cons((), st.vec.last())],
+                vec: st.vec + [@cons((), st.vec.last())]/~,
                 res: r(@cons((), st.res._l))
             })
           }
diff --git a/src/test/bench/task-perf-one-million.rs b/src/test/bench/task-perf-one-million.rs
index 5faf7f85857..14896a3e73e 100644
--- a/src/test/bench/task-perf-one-million.rs
+++ b/src/test/bench/task-perf-one-million.rs
@@ -9,7 +9,7 @@ enum msg {
 fn calc(children: uint, parent_ch: comm::chan<msg>) {
     let port = comm::port();
     let chan = comm::chan(port);
-    let mut child_chs = [];
+    let mut child_chs = []/~;
     let mut sum = 0;
 
     iter::repeat (children) {||
@@ -45,7 +45,7 @@ fn calc(children: uint, parent_ch: comm::chan<msg>) {
     comm::send(parent_ch, done(sum + 1));
 }
 
-fn main(args: [str]) {
+fn main(args: [str]/~) {
     let args = if os::getenv("RUST_BENCH").is_some() {
         ["", "100000"]
     } else if args.len() <= 1u {
@@ -69,4 +69,4 @@ fn main(args: [str]) {
       done(sum) { sum }
     };
     #error("How many tasks? %d tasks.", sum);
-}
\ No newline at end of file
+}
diff --git a/src/test/bench/task-perf-spawnalot.rs b/src/test/bench/task-perf-spawnalot.rs
index c3dd93ce117..686a2175061 100644
--- a/src/test/bench/task-perf-spawnalot.rs
+++ b/src/test/bench/task-perf-spawnalot.rs
@@ -8,7 +8,7 @@ fn f(&&n: uint) {
 
 fn g() { }
 
-fn main(args: [str]) {
+fn main(args: [str]/~) {
     let args = if os::getenv("RUST_BENCH").is_some() {
         ["", "400"]
     } else if args.len() <= 1u {
diff --git a/src/test/bench/task-perf-word-count-generic.rs b/src/test/bench/task-perf-word-count-generic.rs
index c4e51902628..e4528333373 100644
--- a/src/test/bench/task-perf-word-count-generic.rs
+++ b/src/test/bench/task-perf-word-count-generic.rs
@@ -92,12 +92,12 @@ mod map_reduce {
 
     fn start_mappers<K1: copy send, K2: copy send, V: copy send>(
         map: mapper<K1, K2, V>,
-        ctrl: chan<ctrl_proto<K2, V>>, inputs: [K1])
-        -> [joinable_task]
+        ctrl: chan<ctrl_proto<K2, V>>, inputs: [K1]/~)
+        -> [joinable_task]/~
     {
-        let mut tasks = [];
+        let mut tasks = []/~;
         for inputs.each {|i|
-            tasks += [spawn_joinable {|| map_task(map, ctrl, i)}];
+            tasks += [spawn_joinable {|| map_task(map, ctrl, i)}]/~;
         }
         ret tasks;
     }
@@ -176,7 +176,7 @@ mod map_reduce {
     fn map_reduce<K1: copy send, K2: copy send, V: copy send>(
         map: mapper<K1, K2, V>,
         reduce: reducer<K2, V>,
-        inputs: [K1])
+        inputs: [K1]/~)
     {
         let ctrl = port();
 
@@ -209,7 +209,7 @@ mod map_reduce {
                     let r = reduce, kk = k;
                     tasks += [
                         spawn_joinable {|| reduce_task(r, kk, ch) }
-                    ];
+                    ]/~;
                     c = recv(p);
                     treemap::insert(reducers, k, c);
                   }
@@ -229,7 +229,7 @@ mod map_reduce {
     }
 }
 
-fn main(argv: [str]) {
+fn main(argv: [str]/~) {
     if vec::len(argv) < 2u {
         let out = io::stdout();
 
diff --git a/src/test/bench/task-perf-word-count.rs b/src/test/bench/task-perf-word-count.rs
index 12fd0943b4c..a1493badbf3 100644
--- a/src/test/bench/task-perf-word-count.rs
+++ b/src/test/bench/task-perf-word-count.rs
@@ -58,12 +58,12 @@ mod map_reduce {
 
     enum reduce_proto { emit_val(int), done, ref, release, }
 
-    fn start_mappers(ctrl: chan<ctrl_proto>, -inputs: [str]) ->
-       [future::future<task::task_result>] {
-        let mut results = [];
+    fn start_mappers(ctrl: chan<ctrl_proto>, -inputs: [str]/~) ->
+       [future::future<task::task_result>]/~ {
+        let mut results = []/~;
         for inputs.each {|i|
             let builder = task::builder();
-            results += [task::future_result(builder)];
+            results += [task::future_result(builder)]/~;
             task::run(builder) {|| map_task(ctrl, i)}
         }
         ret results;
@@ -128,7 +128,7 @@ mod map_reduce {
         reduce(key, {||get(p, state)});
     }
 
-    fn map_reduce(-inputs: [str]) {
+    fn map_reduce(-inputs: [str]/~) {
         let ctrl = port::<ctrl_proto>();
 
         // This task becomes the master control task. It task::_spawns
@@ -161,7 +161,7 @@ mod map_reduce {
                     let p = port();
                     let ch = chan(p);
                     let builder = task::builder();
-                    results += [task::future_result(builder)];
+                    results += [task::future_result(builder)]/~;
                     task::run(builder) {||reduce_task(k, ch)}
                     c = recv(p);
                     reducers.insert(k, c);
@@ -178,9 +178,9 @@ mod map_reduce {
     }
 }
 
-fn main(argv: [str]) {
+fn main(argv: [str]/~) {
     let inputs = if vec::len(argv) < 2u {
-        [input1(), input2(), input3()]
+        [input1(), input2(), input3()]/~
     } else {
         vec::map(vec::slice(argv, 1u, vec::len(argv)),
                  {|f| result::get(io::read_whole_file_str(f)) })
diff --git a/src/test/compile-fail/ambig_impl_unify.rs b/src/test/compile-fail/ambig_impl_unify.rs
index 2f020742d54..038ade94bd4 100644
--- a/src/test/compile-fail/ambig_impl_unify.rs
+++ b/src/test/compile-fail/ambig_impl_unify.rs
@@ -1,12 +1,12 @@
-impl methods for [uint] {
+impl methods for [uint]/~ {
     fn foo() -> int {1} //! NOTE candidate #1 is `methods::foo`
 }
 
-impl methods for [int] {
+impl methods for [int]/~ {
     fn foo() -> int {2} //! NOTE candidate #2 is `methods::foo`
 }
 
 fn main() {
-    let x = [];
+    let x = []/~;
     x.foo(); //! ERROR multiple applicable methods in scope
 }
\ No newline at end of file
diff --git a/src/test/compile-fail/assign-super.rs b/src/test/compile-fail/assign-super.rs
index b50f2d95f56..70532cef3ae 100644
--- a/src/test/compile-fail/assign-super.rs
+++ b/src/test/compile-fail/assign-super.rs
@@ -1,5 +1,5 @@
 fn main() {
-    let mut x: [mut int] = [mut 3];
-    let y: [int] = [3];
+    let mut x: [mut int]/~ = [mut 3]/~;
+    let y: [int]/~ = [3]/~;
     x = y; //! ERROR values differ in mutability
 }
\ No newline at end of file
diff --git a/src/test/compile-fail/attr-bad-meta.rs b/src/test/compile-fail/attr-bad-meta.rs
index ec883d5ba20..f1f04c8ae98 100644
--- a/src/test/compile-fail/attr-bad-meta.rs
+++ b/src/test/compile-fail/attr-bad-meta.rs
@@ -2,4 +2,4 @@
 
 // asterisk is bogus
 #[attr*]
-mod m { }
\ No newline at end of file
+mod m { }
diff --git a/src/test/compile-fail/bad-expr-path.rs b/src/test/compile-fail/bad-expr-path.rs
index d70d935f602..34690d29a3c 100644
--- a/src/test/compile-fail/bad-expr-path.rs
+++ b/src/test/compile-fail/bad-expr-path.rs
@@ -2,4 +2,4 @@
 
 mod m1 { }
 
-fn main(args: [str]) { log(debug, m1::a); }
+fn main(args: [str]/~) { log(debug, m1::a); }
diff --git a/src/test/compile-fail/bad-expr-path2.rs b/src/test/compile-fail/bad-expr-path2.rs
index da6cfb652b5..14bcfdf8352 100644
--- a/src/test/compile-fail/bad-expr-path2.rs
+++ b/src/test/compile-fail/bad-expr-path2.rs
@@ -4,4 +4,4 @@ mod m1 {
     mod a { }
 }
 
-fn main(args: [str]) { log(debug, m1::a); }
+fn main(args: [str]/~) { log(debug, m1::a); }
diff --git a/src/test/compile-fail/bad-main.rs b/src/test/compile-fail/bad-main.rs
index 06bcbf5d9c2..775f1137e1b 100644
--- a/src/test/compile-fail/bad-main.rs
+++ b/src/test/compile-fail/bad-main.rs
@@ -1,3 +1,3 @@
-// error-pattern:expecting `native fn([str])
+// error-pattern:expecting `native fn([str]/~)
 
 fn main(x: int) { }
diff --git a/src/test/compile-fail/bad-module.rs b/src/test/compile-fail/bad-module.rs
index 662e3108bf0..d96ea37cc78 100644
--- a/src/test/compile-fail/bad-module.rs
+++ b/src/test/compile-fail/bad-module.rs
@@ -1,4 +1,4 @@
 // error-pattern: unresolved import
 import thing;
 
-fn main() { let foo = thing::len([]); }
+fn main() { let foo = thing::len([]/~); }
diff --git a/src/test/compile-fail/block-arg-as-stmt-with-value.rs b/src/test/compile-fail/block-arg-as-stmt-with-value.rs
index dfa39082a94..76519ff6dad 100644
--- a/src/test/compile-fail/block-arg-as-stmt-with-value.rs
+++ b/src/test/compile-fail/block-arg-as-stmt-with-value.rs
@@ -1,6 +1,6 @@
 
 fn compute1() -> float {
-    let v = [0f, 1f, 2f, 3f];
+    let v = [0f, 1f, 2f, 3f]/~;
 
     vec::foldl(0f, v) { |x, y| x + y } - 10f
     //!^ ERROR mismatched types: expected `()`
diff --git a/src/test/compile-fail/block-must-not-have-result-for.rs b/src/test/compile-fail/block-must-not-have-result-for.rs
index e4830ea519e..e069a356aae 100644
--- a/src/test/compile-fail/block-must-not-have-result-for.rs
+++ b/src/test/compile-fail/block-must-not-have-result-for.rs
@@ -1,7 +1,7 @@
 // error-pattern:mismatched types: expected `()` but found `bool`
 
 fn main() {
-    for vec::each([0]) {|_i|
+    for vec::each([0]/~) {|_i|
         true
     }
 }
\ No newline at end of file
diff --git a/src/test/compile-fail/borrowck-assign-comp-idx.rs b/src/test/compile-fail/borrowck-assign-comp-idx.rs
index a83f727369e..e2a7610ddc6 100644
--- a/src/test/compile-fail/borrowck-assign-comp-idx.rs
+++ b/src/test/compile-fail/borrowck-assign-comp-idx.rs
@@ -1,7 +1,7 @@
 type point = { x: int, y: int };
 
 fn a() {
-    let mut p = [mut 1];
+    let mut p = [mut 1]/~;
 
     // Create an immutable pointer into p's contents:
     let _q: &int = &p[0]; //! NOTE loan of mutable vec content granted here
@@ -15,7 +15,7 @@ fn b() {
     // here we alias the mutable vector into an imm slice and try to
     // modify the original:
 
-    let mut p = [mut 1];
+    let mut p = [mut 1]/~;
 
     borrow(p) {|| //! NOTE loan of mutable vec content granted here
         p[0] = 5; //! ERROR assigning to mutable vec content prohibited due to outstanding loan
@@ -25,7 +25,7 @@ fn b() {
 fn c() {
     // Legal because the scope of the borrow does not include the
     // modification:
-    let mut p = [mut 1];
+    let mut p = [mut 1]/~;
     borrow(p, {||});
     p[0] = 5;
 }
diff --git a/src/test/compile-fail/borrowck-binding-mutbl.rs b/src/test/compile-fail/borrowck-binding-mutbl.rs
index 183106aa28e..0da9a8a860f 100644
--- a/src/test/compile-fail/borrowck-binding-mutbl.rs
+++ b/src/test/compile-fail/borrowck-binding-mutbl.rs
@@ -1,8 +1,8 @@
-fn impure(_v: [int]) {
+fn impure(_v: [int]/~) {
 }
 
 fn main() {
-    let x = {mut f: [3]};
+    let x = {mut f: [3]/~};
 
     alt x {
       {f: v} => {
diff --git a/src/test/compile-fail/borrowck-loan-vec-content.rs b/src/test/compile-fail/borrowck-loan-vec-content.rs
index 80e23570a0d..2e54f948de2 100644
--- a/src/test/compile-fail/borrowck-loan-vec-content.rs
+++ b/src/test/compile-fail/borrowck-loan-vec-content.rs
@@ -7,13 +7,13 @@ fn takes_imm_elt(_v: &int, f: fn()) {
 }
 
 fn has_mut_vec_and_does_not_try_to_change_it() {
-    let v = [mut 1, 2, 3];
+    let v = [mut 1, 2, 3]/~;
     takes_imm_elt(&v[0]) {||
     }
 }
 
 fn has_mut_vec_but_tries_to_change_it() {
-    let v = [mut 1, 2, 3];
+    let v = [mut 1, 2, 3]/~;
     takes_imm_elt(&v[0]) {|| //! NOTE loan of mutable vec content granted here
         v[1] = 4; //! ERROR assigning to mutable vec content prohibited due to outstanding loan
     }
@@ -24,7 +24,7 @@ fn takes_const_elt(_v: &const int, f: fn()) {
 }
 
 fn has_mut_vec_and_tries_to_change_it() {
-    let v = [mut 1, 2, 3];
+    let v = [mut 1, 2, 3]/~;
     takes_const_elt(&const v[0]) {||
         v[1] = 4;
     }
diff --git a/src/test/compile-fail/borrowck-mut-vec-as-imm-slice-bad.rs b/src/test/compile-fail/borrowck-mut-vec-as-imm-slice-bad.rs
index c14c35189b5..8735e8e48ba 100644
--- a/src/test/compile-fail/borrowck-mut-vec-as-imm-slice-bad.rs
+++ b/src/test/compile-fail/borrowck-mut-vec-as-imm-slice-bad.rs
@@ -4,11 +4,11 @@ fn want_slice(v: [int]/&) -> int {
     ret sum;
 }
 
-fn has_mut_vec(+v: @[mut int]) -> int {
+fn has_mut_vec(+v: @[mut int]/~) -> int {
     want_slice(*v) //! ERROR illegal borrow unless pure: creating immutable alias to aliasable, mutable memory
         //!^ NOTE impure due to access to impure function
 }
 
 fn main() {
-    assert has_mut_vec(@[mut 1, 2, 3]) == 6;
+    assert has_mut_vec(@[mut 1, 2, 3]/~) == 6;
 }
\ No newline at end of file
diff --git a/src/test/compile-fail/empty-vec-trailing-comma.rs b/src/test/compile-fail/empty-vec-trailing-comma.rs
index e7bb6b704a1..2d01da0f485 100644
--- a/src/test/compile-fail/empty-vec-trailing-comma.rs
+++ b/src/test/compile-fail/empty-vec-trailing-comma.rs
@@ -1,3 +1,3 @@
 fn main() {
-    let v = [,]; //! ERROR unexpected token: ','
+    let v = [,]/~; //! ERROR unexpected token: ','
 }
diff --git a/src/test/compile-fail/fail-type-err.rs b/src/test/compile-fail/fail-type-err.rs
index e0d3680a381..2bf07c0bf91 100644
--- a/src/test/compile-fail/fail-type-err.rs
+++ b/src/test/compile-fail/fail-type-err.rs
@@ -1,2 +1,2 @@
 // error-pattern:expected `str` but found `[int]/~`
-fn main() { fail [0i]; }
+fn main() { fail [0i]/~; }
diff --git a/src/test/compile-fail/import.rs b/src/test/compile-fail/import.rs
index b789a25e7a7..992f4e66eb8 100644
--- a/src/test/compile-fail/import.rs
+++ b/src/test/compile-fail/import.rs
@@ -4,4 +4,4 @@ import zed::baz;
 mod zed {
     fn bar() { #debug("bar"); }
 }
-fn main(args: [str]) { bar(); }
+fn main(args: [str]/~) { bar(); }
diff --git a/src/test/compile-fail/import2.rs b/src/test/compile-fail/import2.rs
index ef81ebfcb4b..ea0c2dcd9b0 100644
--- a/src/test/compile-fail/import2.rs
+++ b/src/test/compile-fail/import2.rs
@@ -4,4 +4,4 @@ mod baz { }
 mod zed {
     fn bar() { #debug("bar3"); }
 }
-fn main(args: [str]) { bar(); }
+fn main(args: [str]/~) { bar(); }
diff --git a/src/test/compile-fail/import3.rs b/src/test/compile-fail/import3.rs
index 35a9c587373..9bb941c6daf 100644
--- a/src/test/compile-fail/import3.rs
+++ b/src/test/compile-fail/import3.rs
@@ -1,4 +1,4 @@
 // error-pattern: unresolved modulename
 import main::bar;
 
-fn main(args: [str]) { #debug("foo"); }
+fn main(args: [str]/~) { #debug("foo"); }
diff --git a/src/test/compile-fail/import4.rs b/src/test/compile-fail/import4.rs
index aed46fb1232..ab9a9e2e544 100644
--- a/src/test/compile-fail/import4.rs
+++ b/src/test/compile-fail/import4.rs
@@ -3,4 +3,4 @@
 mod a { import foo = b::foo; export foo; }
 mod b { import foo = a::foo; export foo; }
 
-fn main(args: [str]) { #debug("loop"); }
+fn main(args: [str]/~) { #debug("loop"); }
diff --git a/src/test/compile-fail/infinite-vec-type-recursion.rs b/src/test/compile-fail/infinite-vec-type-recursion.rs
index 709c5b628ee..35d01d0b624 100644
--- a/src/test/compile-fail/infinite-vec-type-recursion.rs
+++ b/src/test/compile-fail/infinite-vec-type-recursion.rs
@@ -1,6 +1,6 @@
 // -*- rust -*-
 // error-pattern: illegal recursive type
 
-type x = [x];
+type x = [x]/~;
 
-fn main() { let b: x = []; }
+fn main() { let b: x = []/~; }
diff --git a/src/test/compile-fail/issue-1655.rs b/src/test/compile-fail/issue-1655.rs
index 1e0887c1645..32785c23167 100644
--- a/src/test/compile-fail/issue-1655.rs
+++ b/src/test/compile-fail/issue-1655.rs
@@ -7,5 +7,5 @@ mod blade_runner {
                 was also a really good movie.
 
                 Alien 3 was crap though."
-    )]
+    )]/~
 }
diff --git a/src/test/compile-fail/issue-2149.rs b/src/test/compile-fail/issue-2149.rs
index 8bd0a2eb614..6363ca5fb6c 100644
--- a/src/test/compile-fail/issue-2149.rs
+++ b/src/test/compile-fail/issue-2149.rs
@@ -1,5 +1,5 @@
-impl monad<A> for [A] {
-    fn bind<B>(f: fn(A) -> [B]) {
+impl monad<A> for [A]/~ {
+    fn bind<B>(f: fn(A) -> [B]/~) {
         let mut r = fail;
         for self.each {|elt| r += f(elt); }
         //!^ WARNING unreachable expression
diff --git a/src/test/compile-fail/issue-2150.rs b/src/test/compile-fail/issue-2150.rs
index 6fc8bf78af6..a4877dad5b9 100644
--- a/src/test/compile-fail/issue-2150.rs
+++ b/src/test/compile-fail/issue-2150.rs
@@ -1,4 +1,4 @@
-fn fail_len(v: [const int]) -> uint {
+fn fail_len(v: [const int]/~) -> uint {
     let mut i = fail;
     for v.each {|x| i += 1u; }
     //!^ WARNING unreachable statement
diff --git a/src/test/compile-fail/issue-2509-a.rs b/src/test/compile-fail/issue-2509-a.rs
index 69970f8dc95..2113a1ec127 100644
--- a/src/test/compile-fail/issue-2509-a.rs
+++ b/src/test/compile-fail/issue-2509-a.rs
@@ -4,6 +4,6 @@ class c { //! ERROR a class must have at least one field
 
 fn main() {
     let a = c();
-    let x = [a];
+    let x = [a]/~;
     let _y = x[0];
 }
diff --git a/src/test/compile-fail/liveness-issue-2163.rs b/src/test/compile-fail/liveness-issue-2163.rs
index 6045a137a9e..e5a7cd0365d 100644
--- a/src/test/compile-fail/liveness-issue-2163.rs
+++ b/src/test/compile-fail/liveness-issue-2163.rs
@@ -1,5 +1,5 @@
-fn main(_s: [str]) {
-    let a: [int] = [];
+fn main(_s: [str]/~) {
+    let a: [int]/~ = []/~;
     vec::each(a) { |_x| //! ERROR not all control paths return a value
     }
 }
diff --git a/src/test/compile-fail/liveness-use-in-index-lvalue.rs b/src/test/compile-fail/liveness-use-in-index-lvalue.rs
index 50d0662f803..fd7ad945a57 100644
--- a/src/test/compile-fail/liveness-use-in-index-lvalue.rs
+++ b/src/test/compile-fail/liveness-use-in-index-lvalue.rs
@@ -1,5 +1,5 @@
 fn test() {
-    let w: [int];
+    let w: [int]/~;
     w[5] = 0; //! ERROR use of possibly uninitialized variable: `w`
 }
 
diff --git a/src/test/compile-fail/lub-in-args.rs b/src/test/compile-fail/lub-in-args.rs
index 8b59d12783b..1b10639445a 100644
--- a/src/test/compile-fail/lub-in-args.rs
+++ b/src/test/compile-fail/lub-in-args.rs
@@ -1,8 +1,8 @@
 fn two_args<T>(x: T, y: T) { }
 
 fn main() {
-    let x: [mut int] = [mut 3];
-    let y: [int] = [3];
+    let x: [mut int]/~ = [mut 3]/~;
+    let y: [int]/~ = [3]/~;
     let a: @mut int = @mut 3;
     let b: @int = @3;
 
diff --git a/src/test/compile-fail/mutable-huh-variance-box.rs b/src/test/compile-fail/mutable-huh-variance-box.rs
index db38c4ad289..7fbb8bca0f7 100644
--- a/src/test/compile-fail/mutable-huh-variance-box.rs
+++ b/src/test/compile-fail/mutable-huh-variance-box.rs
@@ -1,10 +1,10 @@
 // error-pattern: mismatched types
 
 fn main() {
-    let v = @mut [0];
+    let v = @mut [0]/~;
 
-    fn f(&&v: @mut [const int]) {
-        *v = [mut 3]
+    fn f(&&v: @mut [const int]/~) {
+        *v = [mut 3]/~
     }
 
     f(v);
diff --git a/src/test/compile-fail/mutable-huh-variance-deep.rs b/src/test/compile-fail/mutable-huh-variance-deep.rs
index 7de97e59173..1d7de6b078f 100644
--- a/src/test/compile-fail/mutable-huh-variance-deep.rs
+++ b/src/test/compile-fail/mutable-huh-variance-deep.rs
@@ -1,9 +1,9 @@
 // error-pattern: mismatched types
 
 fn main() {
-    let v = [mut @mut ~mut [0]];
+    let v = [mut @mut ~mut [0]/~]/~;
 
-    fn f(&&v: [mut @mut ~mut [const int]]) {
+    fn f(&&v: [mut @mut ~mut [const int]/~]/~) {
     }
 
     f(v);
diff --git a/src/test/compile-fail/mutable-huh-variance-ptr.rs b/src/test/compile-fail/mutable-huh-variance-ptr.rs
index 852b474eebb..2b807f6cc24 100644
--- a/src/test/compile-fail/mutable-huh-variance-ptr.rs
+++ b/src/test/compile-fail/mutable-huh-variance-ptr.rs
@@ -3,12 +3,12 @@
 use std;
 
 fn main() {
-    let a = [0];
-    let v: *mut [int] = ptr::mut_addr_of(a);
+    let a = [0]/~;
+    let v: *mut [int]/~ = ptr::mut_addr_of(a);
 
-    fn f(&&v: *mut [const int]) {
+    fn f(&&v: *mut [const int]/~) {
         unsafe {
-            *v = [mut 3]
+            *v = [mut 3]/~
         }
     }
 
diff --git a/src/test/compile-fail/mutable-huh-variance-rec.rs b/src/test/compile-fail/mutable-huh-variance-rec.rs
index 78143f7fbc6..326dcd2c1ae 100644
--- a/src/test/compile-fail/mutable-huh-variance-rec.rs
+++ b/src/test/compile-fail/mutable-huh-variance-rec.rs
@@ -1,10 +1,10 @@
 // error-pattern: mismatched types
 
 fn main() {
-    let v = {mut g: [0]};
+    let v = {mut g: [0]/~};
 
-    fn f(&&v: {mut g: [const int]}) {
-        v.g = [mut 3]
+    fn f(&&v: {mut g: [const int]/~}) {
+        v.g = [mut 3]/~
     }
 
     f(v);
diff --git a/src/test/compile-fail/mutable-huh-variance-unique.rs b/src/test/compile-fail/mutable-huh-variance-unique.rs
index cd8d2ca6f10..2cc0bcb6145 100644
--- a/src/test/compile-fail/mutable-huh-variance-unique.rs
+++ b/src/test/compile-fail/mutable-huh-variance-unique.rs
@@ -1,10 +1,10 @@
 // error-pattern: mismatched types
 
 fn main() {
-    let v = ~mut [0];
+    let v = ~mut [0]/~;
 
-    fn f(&&v: ~mut [const int]) {
-        *v = [mut 3]
+    fn f(&&v: ~mut [const int]/~) {
+        *v = [mut 3]/~
     }
 
     f(v);
diff --git a/src/test/compile-fail/mutable-huh-variance-vec1.rs b/src/test/compile-fail/mutable-huh-variance-vec1.rs
index 3519127ab1b..ba25fbbb9d7 100644
--- a/src/test/compile-fail/mutable-huh-variance-vec1.rs
+++ b/src/test/compile-fail/mutable-huh-variance-vec1.rs
@@ -1,10 +1,10 @@
 fn main() {
     // Note: explicit type annot is required here
     // because otherwise the inference gets smart
-    // and assigns a type of [mut [const int]].
-    let v: [mut [int]] = [mut [0]];
+    // and assigns a type of [mut [const int]/~]/~.
+    let v: [mut [int]/~]/~ = [mut [0]/~]/~;
 
-    fn f(&&v: [mut [const int]]) {
+    fn f(&&v: [mut [const int]/~]/~) {
         v[0] = [mut 3]
     }
 
diff --git a/src/test/compile-fail/mutable-huh-variance-vec2.rs b/src/test/compile-fail/mutable-huh-variance-vec2.rs
index 09c3565e8b2..cab07b804e6 100644
--- a/src/test/compile-fail/mutable-huh-variance-vec2.rs
+++ b/src/test/compile-fail/mutable-huh-variance-vec2.rs
@@ -1,10 +1,10 @@
 fn main() {
     // Note: explicit type annot is required here
     // because otherwise the inference gets smart
-    // and assigns a type of [mut [const int]].
-    let v: [mut [mut int]] = [mut [mut 0]];
+    // and assigns a type of [mut [const int]/~]/~.
+    let v: [mut [mut int]/~]/~ = [mut [mut 0]/~]/~;
 
-    fn f(&&v: [mut [const int]]) {
+    fn f(&&v: [mut [const int]/~]/~) {
         v[0] = [3]
     }
 
diff --git a/src/test/compile-fail/mutable-huh-variance-vec3.rs b/src/test/compile-fail/mutable-huh-variance-vec3.rs
index 97b6ccabdfd..afba07126cf 100644
--- a/src/test/compile-fail/mutable-huh-variance-vec3.rs
+++ b/src/test/compile-fail/mutable-huh-variance-vec3.rs
@@ -1,10 +1,10 @@
 fn main() {
     // Note: explicit type annot is required here
     // because otherwise the inference gets smart
-    // and assigns a type of [mut [const int]].
+    // and assigns a type of [mut [const int]/~]/~.
     let v: [mut[mut[int]]] = [mut [mut [0]]];
 
-    fn f(&&v: [mut [mut [const int]]]) {
+    fn f(&&v: [mut [mut [const int]/~]/~]/~) {
         v[0][1] = [mut 3]
     }
 
diff --git a/src/test/compile-fail/mutable-huh-variance-vec4.rs b/src/test/compile-fail/mutable-huh-variance-vec4.rs
index 74b6ad9ff62..a7394928076 100644
--- a/src/test/compile-fail/mutable-huh-variance-vec4.rs
+++ b/src/test/compile-fail/mutable-huh-variance-vec4.rs
@@ -3,26 +3,26 @@ fn main() {
     // Note: here we do not have any type annotations
     // but we do express conflicting requirements:
 
-    let v = [mut [0]];
-    let w = [mut [mut 0]];
-    let x = [mut [mut 0]];
+    let v = [mut [0]/~]/~;
+    let w = [mut [mut 0]/~]/~;
+    let x = [mut [mut 0]/~]/~;
 
-    fn f(&&v: [mut [int]]) {
+    fn f(&&v: [mut [int]/~]/~) {
         v[0] = [3]
     }
 
-    fn g(&&v: [const [const int]]) {
+    fn g(&&v: [const [const int]/~]/~) {
     }
 
-    fn h(&&v: [mut [mut int]]) {
+    fn h(&&v: [mut [mut int]/~]/~) {
         v[0] = [mut 3]
     }
 
-    fn i(&&v: [mut [const int]]) {
+    fn i(&&v: [mut [const int]/~]/~) {
         v[0] = [mut 3]
     }
 
-    fn j(&&v: [[const int]]) {
+    fn j(&&v: [[const int]/~]/~) {
     }
 
     f(v);
@@ -38,7 +38,7 @@ fn main() {
     j(w); //! ERROR (values differ in mutability)
 
     // Note that without adding f() or h() to the mix, it is valid for
-    // x to have the type [mut [const int]], and thus we can safely
+    // x to have the type [mut [const int]/~]/~, and thus we can safely
     // call g() and i() but not j():
     g(x);
     i(x);
diff --git a/src/test/compile-fail/mutable-huh-vec-assign.rs b/src/test/compile-fail/mutable-huh-vec-assign.rs
index 0f2845a8bd0..3a94c6d9b17 100644
--- a/src/test/compile-fail/mutable-huh-vec-assign.rs
+++ b/src/test/compile-fail/mutable-huh-vec-assign.rs
@@ -1,10 +1,10 @@
 fn main() {
-    fn f(&&v: [const int]) {
+    fn f(&&v: [const int]/~) {
         // This shouldn't be possible
         v[0] = 1 //! ERROR assigning to const vec content
     }
 
-    let v = [0];
+    let v = [0]/~;
 
     f(v);
 }
diff --git a/src/test/compile-fail/nested-ty-params.rs b/src/test/compile-fail/nested-ty-params.rs
index c8d08ad320d..12e2205c3b2 100644
--- a/src/test/compile-fail/nested-ty-params.rs
+++ b/src/test/compile-fail/nested-ty-params.rs
@@ -1,5 +1,5 @@
 // error-pattern:attempt to use a type argument out of scope
-fn hd<U>(v: [U]) -> U {
+fn hd<U>(v: [U]/~) -> U {
     fn hd1(w: [U]) -> U { ret w[0]; }
 
     ret hd1(v);
diff --git a/src/test/compile-fail/no-capture-arc.rs b/src/test/compile-fail/no-capture-arc.rs
index 6c8c80dab0a..ec489529739 100644
--- a/src/test/compile-fail/no-capture-arc.rs
+++ b/src/test/compile-fail/no-capture-arc.rs
@@ -3,7 +3,7 @@
 import comm::*;
 
 fn main() {
-    let v = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
+    let v = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]/~;
     let arc_v = arc::arc(v);
     
     task::spawn() {||
diff --git a/src/test/compile-fail/no-reuse-move-arc.rs b/src/test/compile-fail/no-reuse-move-arc.rs
index fa88111d274..2369edd43dc 100644
--- a/src/test/compile-fail/no-reuse-move-arc.rs
+++ b/src/test/compile-fail/no-reuse-move-arc.rs
@@ -1,7 +1,7 @@
 import comm::*;
 
 fn main() {
-    let v = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
+    let v = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]/~;
     let arc_v = arc::arc(v);
 
     task::spawn() {|move arc_v| //! NOTE move of variable occurred here
diff --git a/src/test/compile-fail/non-const.rs b/src/test/compile-fail/non-const.rs
index c438a5bafba..ab542f3bc1e 100644
--- a/src/test/compile-fail/non-const.rs
+++ b/src/test/compile-fail/non-const.rs
@@ -17,8 +17,8 @@ class r2 {
 fn main() {
     foo({f: 3});
     foo({mut f: 3}); //! ERROR missing `const`
-    foo([1]);
-    foo([mut 1]); //! ERROR missing `const`
+    foo([1]/~);
+    foo([mut 1]/~); //! ERROR missing `const`
     foo(~1);
     foo(~mut 1); //! ERROR missing `const`
     foo(@1);
diff --git a/src/test/compile-fail/non-copyable-void.rs b/src/test/compile-fail/non-copyable-void.rs
index 91a625b05d0..07b93989ba7 100644
--- a/src/test/compile-fail/non-copyable-void.rs
+++ b/src/test/compile-fail/non-copyable-void.rs
@@ -1,5 +1,5 @@
 fn main() {
-    let x : *[int] = ptr::addr_of([1,2,3]);
+    let x : *[int]/~ = ptr::addr_of([1,2,3]/~);
     let y : *libc::c_void = x as *libc::c_void;
     unsafe {
         let _z = *y;
diff --git a/src/test/compile-fail/nonsense-constraints.rs b/src/test/compile-fail/nonsense-constraints.rs
index b3ac40be24a..e05581aa10b 100644
--- a/src/test/compile-fail/nonsense-constraints.rs
+++ b/src/test/compile-fail/nonsense-constraints.rs
@@ -3,10 +3,10 @@
 use std;
 import uint;
 
-fn enum_chars(start: u8, end: u8) : uint::le(start, end) -> [char] {
+fn enum_chars(start: u8, end: u8) : uint::le(start, end) -> [char]/~ {
     let i = start;
-    let r = [];
-    while i <= end { r += [i as char]; i += 1u as u8; }
+    let r = []/~;
+    while i <= end { r += [i as char]/~; i += 1u as u8; }
     ret r;
 }
 
diff --git a/src/test/compile-fail/pattern-tyvar-2.rs b/src/test/compile-fail/pattern-tyvar-2.rs
index 6ebc4a27626..162240ed8aa 100644
--- a/src/test/compile-fail/pattern-tyvar-2.rs
+++ b/src/test/compile-fail/pattern-tyvar-2.rs
@@ -6,7 +6,7 @@ import option::some;
 
 // error-pattern: mismatched types
 
-enum bar { t1((), option<[int]>), t2, }
+enum bar { t1((), option<[int]/~>), t2, }
 
 fn foo(t: bar) -> int { alt t { t1(_, some(x)) { ret x * 3; } _ { fail; } } }
 
diff --git a/src/test/compile-fail/pattern-tyvar.rs b/src/test/compile-fail/pattern-tyvar.rs
index 607e32685f3..60c555413ae 100644
--- a/src/test/compile-fail/pattern-tyvar.rs
+++ b/src/test/compile-fail/pattern-tyvar.rs
@@ -5,7 +5,7 @@ import option::some;
 
 // error-pattern: mismatched types
 
-enum bar { t1((), option<[int]>), t2, }
+enum bar { t1((), option<[int]/~>), t2, }
 
 fn foo(t: bar) {
     alt t {
diff --git a/src/test/compile-fail/qquote-1.rs b/src/test/compile-fail/qquote-1.rs
index 0750a7c9dfd..c88bf563e71 100644
--- a/src/test/compile-fail/qquote-1.rs
+++ b/src/test/compile-fail/qquote-1.rs
@@ -29,7 +29,7 @@ impl of fake_ext_ctxt for fake_session {
 }
 
 fn mk_ctxt() -> fake_ext_ctxt {
-    let opts : fake_options = {cfg: []};
+    let opts : fake_options = {cfg: []/~};
     {opts: @opts, parse_sess: new_parse_sess()} as fake_ext_ctxt
 }
 
diff --git a/src/test/compile-fail/qquote-2.rs b/src/test/compile-fail/qquote-2.rs
index a4871e5d497..af5cf1c3fab 100644
--- a/src/test/compile-fail/qquote-2.rs
+++ b/src/test/compile-fail/qquote-2.rs
@@ -29,7 +29,7 @@ impl of fake_ext_ctxt for fake_session {
 }
 
 fn mk_ctxt() -> fake_ext_ctxt {
-    let opts : fake_options = {cfg: []};
+    let opts : fake_options = {cfg: []/~};
     {opts: @opts, parse_sess: new_parse_sess()} as fake_ext_ctxt
 }
 
diff --git a/src/test/compile-fail/regions-escape-loop-via-vec.rs b/src/test/compile-fail/regions-escape-loop-via-vec.rs
index b44c38e68f8..309cb030233 100644
--- a/src/test/compile-fail/regions-escape-loop-via-vec.rs
+++ b/src/test/compile-fail/regions-escape-loop-via-vec.rs
@@ -2,10 +2,10 @@
 // This generates a ton of error msgs at the moment.
 fn broken() -> int {
     let mut x = 3;
-    let mut y = [&mut x]; //! ERROR reference is not valid
+    let mut y = [&mut x]/~; //! ERROR reference is not valid
     while x < 10 {
         let mut z = x;
-        y += [&mut z];
+        y += [&mut z]/~;
         x += 1;
     }
     vec::foldl(0, y) {|v, p| v + *p }
diff --git a/src/test/compile-fail/seq-args.rs b/src/test/compile-fail/seq-args.rs
index 4273675e4da..0587e21e5aa 100644
--- a/src/test/compile-fail/seq-args.rs
+++ b/src/test/compile-fail/seq-args.rs
@@ -2,7 +2,7 @@ use std;
 fn main() {
 iface seq { }
 
-impl <T> of seq<T> for [T] { //! ERROR wrong number of type arguments
+impl <T> of seq<T> for [T]/~ { //! ERROR wrong number of type arguments
     /* ... */
 }
 impl of seq<bool> for u32 {
diff --git a/src/test/compile-fail/tag-that-dare-not-speak-its-name.rs b/src/test/compile-fail/tag-that-dare-not-speak-its-name.rs
index 01d428c7917..a7b0bb7175d 100644
--- a/src/test/compile-fail/tag-that-dare-not-speak-its-name.rs
+++ b/src/test/compile-fail/tag-that-dare-not-speak-its-name.rs
@@ -5,7 +5,7 @@
 
 use core;
 
-fn last<T: copy>(v: [const T]) -> core::option<T> {
+fn last<T: copy>(v: [const T]/~) -> core::option<T> {
     fail;
 }
 
diff --git a/src/test/compile-fail/tstate-unsat-in-called-fn-expr.rs b/src/test/compile-fail/tstate-unsat-in-called-fn-expr.rs
index 010ac92f7b0..24cfa527e95 100644
--- a/src/test/compile-fail/tstate-unsat-in-called-fn-expr.rs
+++ b/src/test/compile-fail/tstate-unsat-in-called-fn-expr.rs
@@ -2,7 +2,7 @@ fn foo(v: [int]) : vec::is_empty(v) { #debug("%d", v[0]); }
 
 fn main() {
     let f = fn@() {
-        let v = [1];
+        let v = [1]/~;
         foo(v); //! ERROR unsatisfied precondition constraint
     }();
     log(error, f);
diff --git a/src/test/compile-fail/tstate-unsat-in-fn-expr.rs b/src/test/compile-fail/tstate-unsat-in-fn-expr.rs
index b9cd2582537..753655d354c 100644
--- a/src/test/compile-fail/tstate-unsat-in-fn-expr.rs
+++ b/src/test/compile-fail/tstate-unsat-in-fn-expr.rs
@@ -2,7 +2,7 @@ fn foo(v: [int]) : vec::is_empty(v) { #debug("%d", v[0]); }
 
 fn main() {
     let f = fn@() {
-        let v = [1];
+        let v = [1]/~;
         foo(v); //! ERROR unsatisfied precondition constraint
     };
     log(error, f());
diff --git a/src/test/compile-fail/unique-vec-res.rs b/src/test/compile-fail/unique-vec-res.rs
index 92dcd538aa7..5159d0ddbfe 100644
--- a/src/test/compile-fail/unique-vec-res.rs
+++ b/src/test/compile-fail/unique-vec-res.rs
@@ -6,15 +6,15 @@ class r {
   drop { *(self.i) = *(self.i) + 1; }
 }
 
-fn f<T>(+i: [T], +j: [T]) {
+fn f<T>(+i: [T]/~, +j: [T]/~) {
     let k = i + j;
 }
 
 fn main() {
     let i1 = @mut 0;
     let i2 = @mut 1;
-    let r1 <- [~r(i1)];
-    let r2 <- [~r(i2)];
+    let r1 <- [~r(i1)]/~;
+    let r2 <- [~r(i2)]/~;
     f(r1, r2);
     log(debug, (r2, *i1));
     log(debug, (r1, *i2));
diff --git a/src/test/compile-fail/vec-add.rs b/src/test/compile-fail/vec-add.rs
index 6642112d998..583ffb9c197 100644
--- a/src/test/compile-fail/vec-add.rs
+++ b/src/test/compile-fail/vec-add.rs
@@ -4,19 +4,19 @@
 // the right hand side in all cases. We are getting compiler errors
 // about this now, so I'm xfailing the test for now. -eholk
 
-fn add(i: [int], m: [mut int], c: [const int]) {
+fn add(i: [int]/~, m: [mut int]/~, c: [const int]/~) {
 
     // Check that:
     //  (1) vectors of any two mutabilities can be added
     //  (2) result has mutability of lhs
 
-   add(i + [3],
-       m + [3],
-       [3]);
+   add(i + [3]/~,
+       m + [3]/~,
+       [3]/~);
 
-   add(i + [mut 3],
-       m + [mut 3],
-       [mut 3]);
+   add(i + [mut 3]/~,
+       m + [mut 3]/~,
+       [mut 3]/~);
 
    add(i + i,
        m + i,
@@ -30,33 +30,33 @@ fn add(i: [int], m: [mut int], c: [const int]) {
        m + c,
        c);
 
-   add(m + [3], //! ERROR mismatched types
-       m + [3],
-       m + [3]);
+   add(m + [3]/~, //! ERROR mismatched types
+       m + [3]/~,
+       m + [3]/~);
 
-   add(i + [3],
-       i + [3], //! ERROR mismatched types
-       i + [3]);
+   add(i + [3]/~,
+       i + [3]/~, //! ERROR mismatched types
+       i + [3]/~);
 
-   add(c + [3], //! ERROR mismatched types
+   add(c + [3]/~, //! ERROR mismatched types
                 //!^ ERROR binary operation + cannot be applied
-       c + [3], //! ERROR binary operation + cannot be applied
+       c + [3]/~, //! ERROR binary operation + cannot be applied
                 //!^ mismatched types
-       [3]);
+       [3]/~);
 
-   add(m + [mut 3], //! ERROR mismatched types
-       m + [mut 3],
-       m + [mut 3]);
+   add(m + [mut 3]/~, //! ERROR mismatched types
+       m + [mut 3]/~,
+       m + [mut 3]/~);
 
-   add(i + [mut 3],
-       i + [mut 3], //! ERROR mismatched types
-       i + [mut 3]);
+   add(i + [mut 3]/~,
+       i + [mut 3]/~, //! ERROR mismatched types
+       i + [mut 3]/~);
 
-   add(c + [mut 3], //! ERROR binary operation + cannot be applied
+   add(c + [mut 3]/~, //! ERROR binary operation + cannot be applied
                     //!^ mismatched types
-       c + [mut 3], //! ERROR binary operation + cannot be applied
+       c + [mut 3]/~, //! ERROR binary operation + cannot be applied
                     //!^ mismatched types
-       [mut 3]);
+       [mut 3]/~);
 
    add(m + i, //! ERROR mismatched types
        m + i,
diff --git a/src/test/compile-fail/vec-concat-bug.rs b/src/test/compile-fail/vec-concat-bug.rs
index 510bef1cae0..40e6e2b0358 100644
--- a/src/test/compile-fail/vec-concat-bug.rs
+++ b/src/test/compile-fail/vec-concat-bug.rs
@@ -1,8 +1,8 @@
-fn concat<T: copy>(v: [const [const T]]) -> [T] {
-    let mut r = [];
+fn concat<T: copy>(v: [const [const T]/~]/~) -> [T]/~ {
+    let mut r = []/~;
 
     // Earlier versions of our type checker accepted this:
-    vec::iter(v) {|&&inner: [T]|
+    vec::iter(v) {|&&inner: [T]/~|
         //!^ ERROR values differ in mutability
         r += inner;
     }
diff --git a/src/test/compile-fail/vec-field.rs b/src/test/compile-fail/vec-field.rs
index 7eb7e118b39..936b14b6c7d 100644
--- a/src/test/compile-fail/vec-field.rs
+++ b/src/test/compile-fail/vec-field.rs
@@ -2,7 +2,7 @@
 // issue #367
 
 fn f() {
-    let v = [1i];
+    let v = [1i]/~;
     log(debug, v.some_field_name); //type error
 }
 
diff --git a/src/test/compile-fail/vec-res-add.rs b/src/test/compile-fail/vec-res-add.rs
index f6388b19798..4ce5ad3cbf0 100644
--- a/src/test/compile-fail/vec-res-add.rs
+++ b/src/test/compile-fail/vec-res-add.rs
@@ -8,8 +8,8 @@ class r {
 
 fn main() {
     // This can't make sense as it would copy the classes
-    let i <- [r(0)];
-    let j <- [r(1)];
+    let i <- [r(0)]/~;
+    let j <- [r(1)]/~;
     let k = i + j;
     log(debug, j);
 }
diff --git a/src/test/compile-fail/vector-no-ann.rs b/src/test/compile-fail/vector-no-ann.rs
index 8d4478d949f..c68995a6854 100644
--- a/src/test/compile-fail/vector-no-ann.rs
+++ b/src/test/compile-fail/vector-no-ann.rs
@@ -1,3 +1,3 @@
 fn main() {
-    let _foo = []; //! ERROR unconstrained type
+    let _foo = []/~; //! ERROR unconstrained type
 }
diff --git a/src/test/pretty/blank-lines.rs b/src/test/pretty/blank-lines.rs
index 13cf815e80d..837b85280ec 100644
--- a/src/test/pretty/blank-lines.rs
+++ b/src/test/pretty/blank-lines.rs
@@ -1,5 +1,5 @@
 // pp-exact
-fn f() -> [int] {
+fn f() -> [int]/~ {
     let picard = 0;
 
     let data = 1;
@@ -7,7 +7,7 @@ fn f() -> [int] {
     let worf = 2;
 
 
-    let enterprise = [picard, data, worf];
+    let enterprise = [picard, data, worf]/~;
 
 
 
diff --git a/src/test/pretty/block-disambig.rs b/src/test/pretty/block-disambig.rs
index 4157515b41c..a6e0cc7f610 100644
--- a/src/test/pretty/block-disambig.rs
+++ b/src/test/pretty/block-disambig.rs
@@ -39,9 +39,9 @@ fn test8() -> int {
 fn test9() { let regs = @mut 0; alt check true { true { } } *regs += 1; }
 
 fn test10() -> int {
-    let regs = @mut [0];
+    let regs = @mut [0]/~;
     alt check true { true { } }
     (*regs)[0]
 }
 
-fn test11() -> [int] { if true { } [1, 2] }
+fn test11() -> [int]/~ { if true { } [1, 2]/~ }
diff --git a/src/test/pretty/vec-comments.pp b/src/test/pretty/vec-comments.pp
index 2cd5fffdf75..5492484d0c8 100644
--- a/src/test/pretty/vec-comments.pp
+++ b/src/test/pretty/vec-comments.pp
@@ -9,11 +9,11 @@ fn main() {
          // Comment
          1,
          // Comment
-         2];
+         2]/~;
     let v2 =
         [0, // Comment
          1, // Comment
-         2]; // Comment
+         2]/~; // Comment
     let v3 =
         [
          /* Comment */
@@ -21,9 +21,9 @@ fn main() {
          /* Comment */
          1,
          /* Comment */
-         2];
+         2]/~;
     let v4 =
         [0, /* Comment */
          1, /* Comment */
-         2]; /* Comment */
+         2]/~; /* Comment */
 }
diff --git a/src/test/pretty/vec-comments.rs b/src/test/pretty/vec-comments.rs
index 2cd5fffdf75..5492484d0c8 100644
--- a/src/test/pretty/vec-comments.rs
+++ b/src/test/pretty/vec-comments.rs
@@ -9,11 +9,11 @@ fn main() {
          // Comment
          1,
          // Comment
-         2];
+         2]/~;
     let v2 =
         [0, // Comment
          1, // Comment
-         2]; // Comment
+         2]/~; // Comment
     let v3 =
         [
          /* Comment */
@@ -21,9 +21,9 @@ fn main() {
          /* Comment */
          1,
          /* Comment */
-         2];
+         2]/~;
     let v4 =
         [0, /* Comment */
          1, /* Comment */
-         2]; /* Comment */
+         2]/~; /* Comment */
 }
diff --git a/src/test/pretty/vec-type.pp b/src/test/pretty/vec-type.pp
index 60265eebcf7..af111a64c3f 100644
--- a/src/test/pretty/vec-type.pp
+++ b/src/test/pretty/vec-type.pp
@@ -1,5 +1,5 @@
 // pp-exact:vec-type.pp
 
-fn f1(x: [int]) { }
+fn f1(x: [int]/~) { }
 
-fn g1() { f1([1, 2, 3]); }
+fn g1() { f1([1, 2, 3]/~); }
diff --git a/src/test/pretty/vec-type.rs b/src/test/pretty/vec-type.rs
index 60265eebcf7..af111a64c3f 100644
--- a/src/test/pretty/vec-type.rs
+++ b/src/test/pretty/vec-type.rs
@@ -1,5 +1,5 @@
 // pp-exact:vec-type.pp
 
-fn f1(x: [int]) { }
+fn f1(x: [int]/~) { }
 
-fn g1() { f1([1, 2, 3]); }
+fn g1() { f1([1, 2, 3]/~); }
diff --git a/src/test/run-fail/bug-2470-bounds-check-overflow-2.rs b/src/test/run-fail/bug-2470-bounds-check-overflow-2.rs
index 215fd53ce5e..dcea4e893f6 100644
--- a/src/test/run-fail/bug-2470-bounds-check-overflow-2.rs
+++ b/src/test/run-fail/bug-2470-bounds-check-overflow-2.rs
@@ -2,7 +2,7 @@
 // error-pattern:bounds check
 
 fn main() {
-    let x = [1u,2u,3u];
+    let x = [1u,2u,3u]/~;
 
     // This should cause a bounds-check failure, but may not if we do our
     // bounds checking by comparing a scaled index value to the vector's
diff --git a/src/test/run-fail/bug-2470-bounds-check-overflow-3.rs b/src/test/run-fail/bug-2470-bounds-check-overflow-3.rs
index 26737f8a9fa..a547bc1a3f3 100644
--- a/src/test/run-fail/bug-2470-bounds-check-overflow-3.rs
+++ b/src/test/run-fail/bug-2470-bounds-check-overflow-3.rs
@@ -3,7 +3,7 @@
 
 #[cfg(target_arch="x86")]
 fn main() {
-    let x = [1u,2u,3u];
+    let x = [1u,2u,3u]/~;
 
     // This should cause a bounds-check failure, but may not if we do our
     // bounds checking by truncating the index value to the size of the
@@ -23,6 +23,6 @@ fn main() {
 #[cfg(target_arch="x86_64")]
 fn main() {
     // This version just fails anyways, for symmetry on 64-bit hosts.
-    let x = [1u,2u,3u];
+    let x = [1u,2u,3u]/~;
     #error("ov3 0x%x",  x[200]);
 }
diff --git a/src/test/run-fail/bug-2470-bounds-check-overflow.rs b/src/test/run-fail/bug-2470-bounds-check-overflow.rs
index 84bd9ab5c76..710cecd99e2 100644
--- a/src/test/run-fail/bug-2470-bounds-check-overflow.rs
+++ b/src/test/run-fail/bug-2470-bounds-check-overflow.rs
@@ -8,7 +8,7 @@ fn main() {
     // address of the 0th cell in the array (even though the index is
     // huge).
 
-    let x = [1u,2u,3u];
+    let x = [1u,2u,3u]/~;
     vec::unpack_slice(x) {|p, _len|
         let base = p as uint;                     // base = 0x1230 say
         let idx = base / sys::size_of::<uint>();  // idx  = 0x0246 say
diff --git a/src/test/run-fail/unwind-box-vec.rs b/src/test/run-fail/unwind-box-vec.rs
index 7aa411ab017..616a9e75cef 100644
--- a/src/test/run-fail/unwind-box-vec.rs
+++ b/src/test/run-fail/unwind-box-vec.rs
@@ -5,7 +5,7 @@ fn failfn() {
 }
 
 fn main() {
-    let x = @[0, 1, 2, 3, 4, 5];
+    let x = @[0, 1, 2, 3, 4, 5]/~;
     failfn();
     log(error, x);
 }
\ No newline at end of file
diff --git a/src/test/run-fail/unwind-interleaved.rs b/src/test/run-fail/unwind-interleaved.rs
index 0aacf579a6d..d914ff82219 100644
--- a/src/test/run-fail/unwind-interleaved.rs
+++ b/src/test/run-fail/unwind-interleaved.rs
@@ -5,8 +5,8 @@ fn a() { }
 fn b() { fail; }
 
 fn main() {
-    let x = [0];
+    let x = [0]/~;
     a();
-    let y = [0];
+    let y = [0]/~;
     b();
 }
\ No newline at end of file
diff --git a/src/test/run-fail/unwind-misc-1.rs b/src/test/run-fail/unwind-misc-1.rs
index ad6f9feafc3..442efe3be25 100644
--- a/src/test/run-fail/unwind-misc-1.rs
+++ b/src/test/run-fail/unwind-misc-1.rs
@@ -7,16 +7,16 @@ import uint;
 
 fn main() {
     let count = @mut 0u;
-    fn hash(&&s: [@str]) -> uint {
+    fn hash(&&s: [@str]/~) -> uint {
         if (vec::len(s) > 0u && str::eq(*s[0], "boom")) { fail; }
         ret 10u;
     }
-    fn eq(&&s: [@str], &&t: [@str]) -> bool {
+    fn eq(&&s: [@str]/~, &&t: [@str]/~) -> bool {
         ret s == t;
     }
 
     let map = map::hashmap(hash, eq);
-    let mut arr = [];
+    let mut arr = []/~;
     for uint::range(0u, 10u) {|i|
         arr += [@"key stuff"];
         map.insert(arr, arr + [@"value stuff"]);
diff --git a/src/test/run-fail/unwind-partial-box.rs b/src/test/run-fail/unwind-partial-box.rs
index a08bb27811b..7ff5c6ec7f3 100644
--- a/src/test/run-fail/unwind-partial-box.rs
+++ b/src/test/run-fail/unwind-partial-box.rs
@@ -1,6 +1,6 @@
 // error-pattern:fail
 
-fn f() -> [int] { fail; }
+fn f() -> [int]/~ { fail; }
 
 // Voodoo. In unwind-alt we had to do this to trigger the bug. Might
 // have been to do with memory allocation patterns.
diff --git a/src/test/run-fail/unwind-partial-unique.rs b/src/test/run-fail/unwind-partial-unique.rs
index b7f5d1054ec..5f998e802dc 100644
--- a/src/test/run-fail/unwind-partial-unique.rs
+++ b/src/test/run-fail/unwind-partial-unique.rs
@@ -1,6 +1,6 @@
 // error-pattern:fail
 
-fn f() -> [int] { fail; }
+fn f() -> [int]/~ { fail; }
 
 // Voodoo. In unwind-alt we had to do this to trigger the bug. Might
 // have been to do with memory allocation patterns.
diff --git a/src/test/run-fail/unwind-partial-vec.rs b/src/test/run-fail/unwind-partial-vec.rs
index 0e4b27cd836..feb7449c532 100644
--- a/src/test/run-fail/unwind-partial-vec.rs
+++ b/src/test/run-fail/unwind-partial-vec.rs
@@ -1,6 +1,6 @@
 // error-pattern:fail
 
-fn f() -> [int] { fail; }
+fn f() -> [int]/~ { fail; }
 
 // Voodoo. In unwind-alt we had to do this to trigger the bug. Might
 // have been to do with memory allocation patterns.
@@ -9,7 +9,7 @@ fn prime() {
 }
 
 fn partial() {
-    let x = [[0], f(), [0]];
+    let x = [[0]/~, f(), [0]/~]/~;
 }
 
 fn main() {
diff --git a/src/test/run-fail/unwind-rec.rs b/src/test/run-fail/unwind-rec.rs
index c6dd2d0abdf..58fb32cf3e5 100644
--- a/src/test/run-fail/unwind-rec.rs
+++ b/src/test/run-fail/unwind-rec.rs
@@ -1,6 +1,6 @@
 // error-pattern:fail
 
-fn build() -> [int] {
+fn build() -> [int]/~ {
     fail;
 }
 
diff --git a/src/test/run-fail/unwind-rec2.rs b/src/test/run-fail/unwind-rec2.rs
index 4e4afd31a84..10e9cd70323 100644
--- a/src/test/run-fail/unwind-rec2.rs
+++ b/src/test/run-fail/unwind-rec2.rs
@@ -1,10 +1,10 @@
 // error-pattern:fail
 
-fn build1() -> [int] {
-    [0,0,0,0,0,0,0]
+fn build1() -> [int]/~ {
+    [0,0,0,0,0,0,0]/~
 }
 
-fn build2() -> [int] {
+fn build2() -> [int]/~ {
     fail;
 }
 
diff --git a/src/test/run-fail/unwind-tup.rs b/src/test/run-fail/unwind-tup.rs
index 6562c5ded27..219e4d2a311 100644
--- a/src/test/run-fail/unwind-tup.rs
+++ b/src/test/run-fail/unwind-tup.rs
@@ -1,6 +1,6 @@
 // error-pattern:fail
 
-fn fold_local() -> @[int]{
+fn fold_local() -> @[int]/~{
     fail;
 }
 
diff --git a/src/test/run-fail/unwind-tup2.rs b/src/test/run-fail/unwind-tup2.rs
index 0c1d0890b9d..cba38527da9 100644
--- a/src/test/run-fail/unwind-tup2.rs
+++ b/src/test/run-fail/unwind-tup2.rs
@@ -1,10 +1,10 @@
 // error-pattern:fail
 
-fn fold_local() -> @[int]{
-    @[0,0,0,0,0,0]
+fn fold_local() -> @[int]/~{
+    @[0,0,0,0,0,0]/~
 }
 
-fn fold_remote() -> @[int]{
+fn fold_remote() -> @[int]/~{
     fail;
 }
 
diff --git a/src/test/run-fail/vec-overrun.rs b/src/test/run-fail/vec-overrun.rs
index 7a429e08cae..f0d21ec7a73 100644
--- a/src/test/run-fail/vec-overrun.rs
+++ b/src/test/run-fail/vec-overrun.rs
@@ -2,7 +2,7 @@
 
 // error-pattern:bounds check
 fn main() {
-    let v: [int] = [10];
+    let v: [int]/~ = [10]/~;
     let x: int = 0;
     assert (v[x] == 10);
     // Bounds-check failure.
diff --git a/src/test/run-fail/vec-underrun.rs b/src/test/run-fail/vec-underrun.rs
index 9caf82d1ae0..faeeed44603 100644
--- a/src/test/run-fail/vec-underrun.rs
+++ b/src/test/run-fail/vec-underrun.rs
@@ -2,7 +2,7 @@
 
 // error-pattern:bounds check
 fn main() {
-    let v: [int] = [10, 20];
+    let v: [int]/~ = [10, 20]/~;
     let x: int = 0;
     assert (v[x] == 10);
     // Bounds-check failure.
diff --git a/src/test/run-fail/zip-different-lengths.rs b/src/test/run-fail/zip-different-lengths.rs
index 736b61cb935..f41c03e7e76 100644
--- a/src/test/run-fail/zip-different-lengths.rs
+++ b/src/test/run-fail/zip-different-lengths.rs
@@ -6,18 +6,18 @@ import uint;
 import u8;
 import vec::*;
 
-fn enum_chars(start: u8, end: u8) -> [char] {
+fn enum_chars(start: u8, end: u8) -> [char]/~ {
     assert start < end;
     let mut i = start;
-    let mut r = [];
+    let mut r = []/~;
     while i <= end { vec::push(r, i as char); i += 1u as u8; }
     ret r;
 }
 
-fn enum_uints(start: uint, end: uint) -> [uint] {
+fn enum_uints(start: uint, end: uint) -> [uint]/~ {
     assert start < end;
     let mut i = start;
-    let mut r = [];
+    let mut r = []/~;
     while i <= end { vec::push(r, i); i += 1u; }
     ret r;
 }
diff --git a/src/test/run-pass-fulldeps/issue-1926.rs b/src/test/run-pass-fulldeps/issue-1926.rs
index 383a1acec39..856e916ac0c 100644
--- a/src/test/run-pass-fulldeps/issue-1926.rs
+++ b/src/test/run-pass-fulldeps/issue-1926.rs
@@ -39,7 +39,7 @@ impl of fake_ext_ctxt for fake_session {
 }
 
 fn mk_ctxt() -> fake_ext_ctxt {
-    let opts : fake_options = {cfg: []};
+    let opts : fake_options = {cfg: []/~};
     {opts: @opts, parse_sess: new_parse_sess()} as fake_ext_ctxt
 }
 
diff --git a/src/test/run-pass-fulldeps/qquote.rs b/src/test/run-pass-fulldeps/qquote.rs
index 625e3be7ecd..d6da96d0393 100644
--- a/src/test/run-pass-fulldeps/qquote.rs
+++ b/src/test/run-pass-fulldeps/qquote.rs
@@ -19,7 +19,7 @@ iface fake_ext_ctxt {
 type fake_session = ();
 
 impl of fake_ext_ctxt for fake_session {
-    fn cfg() -> ast::crate_cfg { [] }
+    fn cfg() -> ast::crate_cfg { []/~ }
     fn parse_sess() -> parse::parse_sess { parse::new_parse_sess(none) }
 }
 
diff --git a/src/test/run-pass/alloca-from-derived-tydesc.rs b/src/test/run-pass/alloca-from-derived-tydesc.rs
index 1bad1418382..df4fac9945f 100644
--- a/src/test/run-pass/alloca-from-derived-tydesc.rs
+++ b/src/test/run-pass/alloca-from-derived-tydesc.rs
@@ -1,7 +1,7 @@
 enum option<T> { some(T), none, }
 
-type r<T> = {mut v: [option<T>]};
+type r<T> = {mut v: [option<T>]/~};
 
-fn f<T>() -> [T] { ret []; }
+fn f<T>() -> [T]/~ { ret []/~; }
 
-fn main() { let r: r<int> = {mut v: []}; r.v = f(); }
+fn main() { let r: r<int> = {mut v: []/~}; r.v = f(); }
diff --git a/src/test/run-pass/alt-join.rs b/src/test/run-pass/alt-join.rs
index 60ddb99c26a..ecc24877d2f 100644
--- a/src/test/run-pass/alt-join.rs
+++ b/src/test/run-pass/alt-join.rs
@@ -4,12 +4,12 @@ import option;
 
 fn foo<T>(y: option<T>) {
     let mut x: int;
-    let mut rs: [int] = [];
+    let mut rs: [int]/~ = []/~;
     /* tests that x doesn't get put in the precondition for the
        entire if expression */
 
     if true {
-    } else { alt y { none::<T> { x = 17; } _ { x = 42; } } rs += [x]; }
+    } else { alt y { none::<T> { x = 17; } _ { x = 42; } } rs += [x]/~; }
     ret;
 }
 
diff --git a/src/test/run-pass/argv.rs b/src/test/run-pass/argv.rs
index f0a7681acfe..d49f54115ec 100644
--- a/src/test/run-pass/argv.rs
+++ b/src/test/run-pass/argv.rs
@@ -1,5 +1,5 @@
-fn main(args: [str]) {
+fn main(args: [str]/~) {
     let vs: [str] = ["hi", "there", "this", "is", "a", "vec"];
-    let vvs: [[str]] = [args, vs];
+    let vvs: [[str]/~]/~ = [args, vs]/~;
     for vvs.each {|vs| for vs.each {|s| log(debug, s); } }
 }
diff --git a/src/test/run-pass/auto-loop.rs b/src/test/run-pass/auto-loop.rs
index 223aca32bcb..7a795f7cdfe 100644
--- a/src/test/run-pass/auto-loop.rs
+++ b/src/test/run-pass/auto-loop.rs
@@ -1,5 +1,5 @@
 fn main() {
     let mut sum = 0;
-    for vec::each([1, 2, 3, 4, 5]) {|x| sum += x; }
+    for vec::each([1, 2, 3, 4, 5]/~) {|x| sum += x; }
     assert (sum == 15);
 }
diff --git a/src/test/run-pass/auto_serialize.rs b/src/test/run-pass/auto_serialize.rs
index deb87b813d1..6a3d54b5e35 100644
--- a/src/test/run-pass/auto_serialize.rs
+++ b/src/test/run-pass/auto_serialize.rs
@@ -58,7 +58,7 @@ type some_rec = {v: uint_vec};
 enum an_enum = some_rec;
 
 #[auto_serialize]
-type uint_vec = [uint];
+type uint_vec = [uint]/~;
 
 #[auto_serialize]
 type point = {x: uint, y: uint};
@@ -91,7 +91,7 @@ fn main() {
                        deserialize_spanned_uint,
                        serialize_spanned_uint);
 
-    test_ser_and_deser(an_enum({v: [1u, 2u, 3u]}),
+    test_ser_and_deser(an_enum({v: [1u, 2u, 3u]/~}),
                        "an_enum({v: [1u, 2u, 3u]})",
                        serialize_an_enum,
                        deserialize_an_enum,
@@ -103,7 +103,7 @@ fn main() {
                        deserialize_point,
                        serialize_point);
 
-    test_ser_and_deser([1u, 2u, 3u],
+    test_ser_and_deser([1u, 2u, 3u]/~,
                        "[1u, 2u, 3u]",
                        serialize_uint_vec,
                        deserialize_uint_vec,
@@ -132,4 +132,4 @@ fn main() {
                        serialize_c_like,
                        deserialize_c_like,
                        serialize_c_like);
-}
\ No newline at end of file
+}
diff --git a/src/test/run-pass/autobind.rs b/src/test/run-pass/autobind.rs
index 3269af16afa..e4a0db4f15d 100644
--- a/src/test/run-pass/autobind.rs
+++ b/src/test/run-pass/autobind.rs
@@ -1,9 +1,9 @@
 fn f<T: copy>(x: [T]) -> T { ret x[0]; }
 
-fn g(act: fn([int]) -> int) -> int { ret act([1, 2, 3]); }
+fn g(act: fn([int]/~) -> int) -> int { ret act([1, 2, 3]/~); }
 
 fn main() {
     assert (g(f) == 1);
-    let f1: fn([str]) -> str = f;
+    let f1: fn([str]/~) -> str = f;
     assert (f1(["x", "y", "z"]) == "x");
 }
diff --git a/src/test/run-pass/block-arg-can-be-followed-by-binop.rs b/src/test/run-pass/block-arg-can-be-followed-by-binop.rs
index a8e763e96a6..1b00df3b750 100644
--- a/src/test/run-pass/block-arg-can-be-followed-by-binop.rs
+++ b/src/test/run-pass/block-arg-can-be-followed-by-binop.rs
@@ -1,5 +1,5 @@
 fn main() {
-    let v = [-1f, 0f, 1f, 2f, 3f];
+    let v = [-1f, 0f, 1f, 2f, 3f]/~;
 
     // Trailing expressions require parentheses:
     let y = vec::foldl(0f, v) { |x, y| x + y } + 10f;
diff --git a/src/test/run-pass/block-arg-can-be-followed-by-block-arg.rs b/src/test/run-pass/block-arg-can-be-followed-by-block-arg.rs
index 71342eee6e8..57ced911004 100644
--- a/src/test/run-pass/block-arg-can-be-followed-by-block-arg.rs
+++ b/src/test/run-pass/block-arg-can-be-followed-by-block-arg.rs
@@ -1,6 +1,6 @@
 fn main() {
     fn f(i: fn() -> uint) -> uint { i() }
-    let v = [-1f, 0f, 1f, 2f, 3f];
+    let v = [-1f, 0f, 1f, 2f, 3f]/~;
     let z = vec::foldl(f, v) { |x, _y| x } { || 22u };
     assert z == 22u;
 }
diff --git a/src/test/run-pass/block-arg-can-be-followed-by-call.rs b/src/test/run-pass/block-arg-can-be-followed-by-call.rs
index b570a8bdd82..31bb412de3b 100644
--- a/src/test/run-pass/block-arg-can-be-followed-by-call.rs
+++ b/src/test/run-pass/block-arg-can-be-followed-by-call.rs
@@ -1,6 +1,6 @@
 fn main() {
     fn f(i: uint) -> uint { i }
-    let v = [-1f, 0f, 1f, 2f, 3f];
+    let v = [-1f, 0f, 1f, 2f, 3f]/~;
     let z = vec::foldl(f, v) { |x, _y| x } (22u);
     assert z == 22u;
 }
diff --git a/src/test/run-pass/block-arg-in-parentheses.rs b/src/test/run-pass/block-arg-in-parentheses.rs
index 4a5a0fbea07..9d51c993898 100644
--- a/src/test/run-pass/block-arg-in-parentheses.rs
+++ b/src/test/run-pass/block-arg-in-parentheses.rs
@@ -1,26 +1,26 @@
-fn w_semi(v: [int]) -> int {
+fn w_semi(v: [int]/~) -> int {
     // the semicolon causes compiler not to
     // complain about the ignored return value:
     vec::foldl(0, v) {|x,y| x+y};
     -10
 }
 
-fn w_paren1(v: [int]) -> int {
+fn w_paren1(v: [int]/~) -> int {
     (vec::foldl(0, v) {|x,y| x+y}) - 10
 }
 
-fn w_paren2(v: [int]) -> int {
+fn w_paren2(v: [int]/~) -> int {
     (vec::foldl(0, v) {|x,y| x+y} - 10)
 }
 
-fn w_ret(v: [int]) -> int {
+fn w_ret(v: [int]/~) -> int {
     ret vec::foldl(0, v) {|x,y| x+y} - 10;
 }
 
 fn main() {
-    assert w_semi([0, 1, 2, 3]) == -10;
-    assert w_paren1([0, 1, 2, 3]) == -4;
-    assert w_paren2([0, 1, 2, 3]) == -4;
-    assert w_ret([0, 1, 2, 3]) == -4;
+    assert w_semi([0, 1, 2, 3]/~) == -10;
+    assert w_paren1([0, 1, 2, 3]/~) == -4;
+    assert w_paren2([0, 1, 2, 3]/~) == -4;
+    assert w_ret([0, 1, 2, 3]/~) == -4;
 }
 
diff --git a/src/test/run-pass/block-arg.rs b/src/test/run-pass/block-arg.rs
index b13b819b2dc..f33d12f4361 100644
--- a/src/test/run-pass/block-arg.rs
+++ b/src/test/run-pass/block-arg.rs
@@ -1,6 +1,6 @@
 // Check usage and precedence of block arguments in expressions:
 fn main() {
-    let v = [-1f, 0f, 1f, 2f, 3f];
+    let v = [-1f, 0f, 1f, 2f, 3f]/~;
 
     // Statement form does not require parentheses:
     vec::iter(v) { |i|
diff --git a/src/test/run-pass/block-iter-1.rs b/src/test/run-pass/block-iter-1.rs
index 8e868a18612..12b7372227a 100644
--- a/src/test/run-pass/block-iter-1.rs
+++ b/src/test/run-pass/block-iter-1.rs
@@ -1,7 +1,7 @@
-fn iter_vec<T>(v: [T], f: fn(T)) { for v.each {|x| f(x); } }
+fn iter_vec<T>(v: [T]/~, f: fn(T)) { for v.each {|x| f(x); } }
 
 fn main() {
-    let v = [1, 2, 3, 4, 5, 6, 7];
+    let v = [1, 2, 3, 4, 5, 6, 7]/~;
     let mut odds = 0;
     iter_vec(v, {|i|
         log(error, i);
diff --git a/src/test/run-pass/block-iter-2.rs b/src/test/run-pass/block-iter-2.rs
index bcb1ea76151..ac96dbed60f 100644
--- a/src/test/run-pass/block-iter-2.rs
+++ b/src/test/run-pass/block-iter-2.rs
@@ -1,7 +1,7 @@
-fn iter_vec<T>(v: [T], f: fn(T)) { for v.each {|x| f(x); } }
+fn iter_vec<T>(v: [T]/~, f: fn(T)) { for v.each {|x| f(x); } }
 
 fn main() {
-    let v = [1, 2, 3, 4, 5];
+    let v = [1, 2, 3, 4, 5]/~;
     let mut sum = 0;
     iter_vec(v, {|i|
         iter_vec(v, {|j|
diff --git a/src/test/run-pass/block-vec-map2.rs b/src/test/run-pass/block-vec-map2.rs
index 0532f013383..087268010c8 100644
--- a/src/test/run-pass/block-vec-map2.rs
+++ b/src/test/run-pass/block-vec-map2.rs
@@ -3,9 +3,9 @@ import vec;
 
 fn main() {
     let v =
-        vec::map2([1, 2, 3, 4, 5],
-                  [true, false, false, true, true],
+        vec::map2([1, 2, 3, 4, 5]/~,
+                  [true, false, false, true, true]/~,
                   {|i, b| if b { -i } else { i } });
     log(error, v);
-    assert (v == [-1, 2, 3, -4, -5]);
+    assert (v == [-1, 2, 3, -4, -5]/~);
 }
diff --git a/src/test/run-pass/borrowck-mut-vec-as-imm-slice.rs b/src/test/run-pass/borrowck-mut-vec-as-imm-slice.rs
index a6279d12ab8..1795d3b5aed 100644
--- a/src/test/run-pass/borrowck-mut-vec-as-imm-slice.rs
+++ b/src/test/run-pass/borrowck-mut-vec-as-imm-slice.rs
@@ -4,10 +4,10 @@ fn want_slice(v: [int]/&) -> int {
     ret sum;
 }
 
-fn has_mut_vec(+v: [mut int]) -> int {
+fn has_mut_vec(+v: [mut int]/~) -> int {
     want_slice(v)
 }
 
 fn main() {
-    assert has_mut_vec([mut 1, 2, 3]) == 6;
+    assert has_mut_vec([mut 1, 2, 3]/~) == 6;
 }
\ No newline at end of file
diff --git a/src/test/run-pass/break.rs b/src/test/run-pass/break.rs
index 4770b9ce886..008410c22e5 100644
--- a/src/test/run-pass/break.rs
+++ b/src/test/run-pass/break.rs
@@ -6,7 +6,7 @@ fn main() {
     assert (i == 10);
     loop { i += 1; if i == 20 { break; } }
     assert (i == 20);
-    for vec::each([1, 2, 3, 4, 5, 6]) {|x|
+    for vec::each([1, 2, 3, 4, 5, 6]/~) {|x|
         if x == 3 { break; } assert (x <= 3);
     }
     i = 0;
@@ -16,7 +16,7 @@ fn main() {
         i += 1; if i % 2 == 0 { cont; } assert (i % 2 != 0); 
         if i >= 10 { break; }
     }
-    for vec::each([1, 2, 3, 4, 5, 6]) {|x|
+    for vec::each([1, 2, 3, 4, 5, 6]/~) {|x|
         if x % 2 == 0 { cont; }
         assert (x % 2 != 0);
     }
diff --git a/src/test/run-pass/cci_iter_exe.rs b/src/test/run-pass/cci_iter_exe.rs
index 27fd452c8ed..4535e0a8a78 100644
--- a/src/test/run-pass/cci_iter_exe.rs
+++ b/src/test/run-pass/cci_iter_exe.rs
@@ -6,7 +6,7 @@ use cci_iter_lib;
 fn main() {
     //let bt0 = sys::rusti::frame_address(1u32);
     //#debug["%?", bt0];
-    cci_iter_lib::iter([1, 2, 3]) {|i|
+    cci_iter_lib::iter([1, 2, 3]/~) {|i|
         io::print(#fmt["%d", i]);
         //assert bt0 == sys::rusti::frame_address(2u32);
     }
diff --git a/src/test/run-pass/cci_no_inline_exe.rs b/src/test/run-pass/cci_no_inline_exe.rs
index f9863f12b4f..1336cd77c6b 100644
--- a/src/test/run-pass/cci_no_inline_exe.rs
+++ b/src/test/run-pass/cci_no_inline_exe.rs
@@ -12,7 +12,7 @@ fn main() {
     // actually working.
     //let bt0 = sys::frame_address();
     //#debug["%?", bt0];
-    iter([1u, 2u, 3u]) {|i|
+    iter([1u, 2u, 3u]/~) {|i|
         io::print(#fmt["%u\n", i]);
 
         //let bt1 = sys::frame_address();
diff --git a/src/test/run-pass/class-iface-bounded-param.rs b/src/test/run-pass/class-iface-bounded-param.rs
index 4da75037421..e6af2bd60bd 100644
--- a/src/test/run-pass/class-iface-bounded-param.rs
+++ b/src/test/run-pass/class-iface-bounded-param.rs
@@ -19,5 +19,5 @@ fn main() {
     let m = int_hash();
     m.insert(1, 2);
     m.insert(3, 4);
-    assert iter::to_vec(keys(m)) == [1, 3];
+    assert iter::to_vec(keys(m)) == [1, 3]/~;
 }
diff --git a/src/test/run-pass/class-implements-multiple-ifaces.rs b/src/test/run-pass/class-implements-multiple-ifaces.rs
index fe3f160c1f8..3e1a9895665 100644
--- a/src/test/run-pass/class-implements-multiple-ifaces.rs
+++ b/src/test/run-pass/class-implements-multiple-ifaces.rs
@@ -18,7 +18,7 @@ iface bitey {
   fn bite() -> body_part;
 }
 
-fn vec_includes<T>(xs: [T], x: T) -> bool {
+fn vec_includes<T>(xs: [T]/~, x: T) -> bool {
   for each(xs) {|y| if y == x { ret true; }}
   ret false;
 }
@@ -53,7 +53,7 @@ class cat : noisy, scratchy, bitey {
       let t : hashmap<body_part, uint> =
         hashmap::<body_part, uint>(hsher, eqer);
       self.bite_counts = t;
-      iter([finger, toe, nose, ear]) {|p|
+      iter([finger, toe, nose, ear]/~) {|p|
           self.bite_counts.insert(p, 0u);
       };
     }
@@ -61,7 +61,7 @@ class cat : noisy, scratchy, bitey {
   fn speak() -> int { self.meow() as int }
   fn meow_count() -> uint { *self.meows }
   fn scratch() -> option<furniture> {
-    let all = [chair, couch, bed];
+    let all = [chair, couch, bed]/~;
     log(error, self.scratched);
     let mut rslt = none;
     for each(all) {|thing| if !self.scratched.contains(thing) {
@@ -71,7 +71,7 @@ class cat : noisy, scratchy, bitey {
   }
   fn bite() -> body_part {
     #error("In bite()");
-    let all = [toe, nose, ear];
+    let all = [toe, nose, ear]/~;
     let mut min = finger;
     iter(all) {|next|
       #debug("min = %?", min);
@@ -92,7 +92,7 @@ fn annoy_neighbors<T: noisy>(critter: T) {
 }
 
 fn bite_everything<T: bitey>(critter: T) -> bool {
-  let mut left : [body_part] = [finger, toe, nose, ear];
+  let mut left : [body_part]/~ = [finger, toe, nose, ear]/~;
   while vec::len(left) > 0u {
     let part = critter.bite();
     #debug("%? %?", left, part);
diff --git a/src/test/run-pass/class-poly-methods-cross-crate.rs b/src/test/run-pass/class-poly-methods-cross-crate.rs
index 28ddbfdd1e2..b21f1d4f709 100644
--- a/src/test/run-pass/class-poly-methods-cross-crate.rs
+++ b/src/test/run-pass/class-poly-methods-cross-crate.rs
@@ -4,11 +4,11 @@ use cci_class_6;
 import cci_class_6::kitties::*;
 
 fn main() {
-  let nyan : cat<char> = cat::<char>(52u, 99, ['p']);
+  let nyan : cat<char> = cat::<char>(52u, 99, ['p']/~);
   let kitty = cat(1000u, 2, ["tabby"]);
   assert(nyan.how_hungry == 99);
   assert(kitty.how_hungry == 2);
-  nyan.speak([1u,2u,3u]);
+  nyan.speak([1u,2u,3u]/~);
   assert(nyan.meow_count() == 55u);
   kitty.speak(["meow", "mew", "purr", "chirp"]);
   assert(kitty.meow_count() == 1004u);
diff --git a/src/test/run-pass/class-poly-methods.rs b/src/test/run-pass/class-poly-methods.rs
index 0d738913ee5..0b6b3865d56 100644
--- a/src/test/run-pass/class-poly-methods.rs
+++ b/src/test/run-pass/class-poly-methods.rs
@@ -1,27 +1,27 @@
 class cat<U> {
   priv {
-    let mut info : [U];
+    let mut info : [U]/~;
     let mut meows : uint;
   }
 
   let how_hungry : int;
 
-  new(in_x : uint, in_y : int, -in_info: [U])
+  new(in_x : uint, in_y : int, -in_info: [U]/~)
     { self.meows = in_x; self.how_hungry = in_y;
       self.info <- in_info; }
 
-  fn speak<T>(stuff: [T]) {
+  fn speak<T>(stuff: [T]/~) {
     self.meows += stuff.len();
   }
   fn meow_count() -> uint { self.meows }
 }
 
 fn main() {
-  let nyan : cat<int> = cat::<int>(52u, 99, [9]);
+  let nyan : cat<int> = cat::<int>(52u, 99, [9]/~);
   let kitty = cat(1000u, 2, ["tabby"]);
   assert(nyan.how_hungry == 99);
   assert(kitty.how_hungry == 2);
-  nyan.speak([1,2,3]);
+  nyan.speak([1,2,3]/~);
   assert(nyan.meow_count() == 55u);
   kitty.speak(["meow", "mew", "purr", "chirp"]);
   assert(kitty.meow_count() == 1004u);
diff --git a/src/test/run-pass/const-bound.rs b/src/test/run-pass/const-bound.rs
index ac532ea0569..f2a436e0374 100644
--- a/src/test/run-pass/const-bound.rs
+++ b/src/test/run-pass/const-bound.rs
@@ -7,7 +7,7 @@ fn foo<T: copy const>(x: T) -> T { x }
 fn main() {
     foo(1);
     foo("hi");
-    foo([1, 2, 3]);
+    foo([1, 2, 3]/~);
     foo({field: 42});
     foo((1, 2u));
     foo(@1);
diff --git a/src/test/run-pass/cycle-collection4.rs b/src/test/run-pass/cycle-collection4.rs
index ccbcdf6037b..fbe6389fc87 100644
--- a/src/test/run-pass/cycle-collection4.rs
+++ b/src/test/run-pass/cycle-collection4.rs
@@ -1,10 +1,10 @@
 type foo = { mut z : fn@() };
 
 fn nop() { }
-fn nop_foo(_y: [int], _x : @foo) { }
+fn nop_foo(_y: [int]/~, _x : @foo) { }
 
 fn main() {
     let w = @{ mut z: {||nop()} };
-    let x = {||nop_foo([], w)};
+    let x = {||nop_foo([]/~, w)};
     w.z = x;
 }
\ No newline at end of file
diff --git a/src/test/run-pass/deep-vector.rs b/src/test/run-pass/deep-vector.rs
index 7952bf84f77..c7bb5e3f48c 100644
--- a/src/test/run-pass/deep-vector.rs
+++ b/src/test/run-pass/deep-vector.rs
@@ -1998,5 +1998,5 @@ fn main() {
         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
-    ];
+    ]/~;
 }
\ No newline at end of file
diff --git a/src/test/run-pass/deep-vector2.rs b/src/test/run-pass/deep-vector2.rs
index 2db5841ac1d..7a2eaa37f24 100644
--- a/src/test/run-pass/deep-vector2.rs
+++ b/src/test/run-pass/deep-vector2.rs
@@ -7998,5 +7998,5 @@ fn main() {
         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
-    ];
+    ]/~;
 }
\ No newline at end of file
diff --git a/src/test/run-pass/dvec-test.rs b/src/test/run-pass/dvec-test.rs
index 15441ee1034..d3e2038922f 100644
--- a/src/test/run-pass/dvec-test.rs
+++ b/src/test/run-pass/dvec-test.rs
@@ -4,17 +4,17 @@ fn main() {
     let d = dvec();
     d.push(3);
     d.push(4);
-    assert d.get() == [3, 4];
-    d.set([mut 5]);
+    assert d.get() == [3, 4]/~;
+    d.set([mut 5]/~);
     d.push(6);
     d.push(7);
     d.push(8);
     d.push(9);
     d.push(10);
-    d.push_all([11, 12, 13]);
-    d.push_slice([11, 12, 13], 1u, 2u);
+    d.push_all([11, 12, 13]/~);
+    d.push_slice([11, 12, 13]/~, 1u, 2u);
 
-    let exp = [5, 6, 7, 8, 9, 10, 11, 12, 13, 12];
+    let exp = [5, 6, 7, 8, 9, 10, 11, 12, 13, 12]/~;
     assert d.get() == exp;
     assert d.get() == exp;
     assert d.len() == exp.len();
diff --git a/src/test/run-pass/empty-mutable-vec.rs b/src/test/run-pass/empty-mutable-vec.rs
index eaec2ab31d5..cb2c13a8844 100644
--- a/src/test/run-pass/empty-mutable-vec.rs
+++ b/src/test/run-pass/empty-mutable-vec.rs
@@ -1,3 +1,3 @@
 
 
-fn main() { let v: [mut int] = [mut]; }
+fn main() { let v: [mut int]/~ = [mut]/~; }
diff --git a/src/test/run-pass/expr-alt-fail.rs b/src/test/run-pass/expr-alt-fail.rs
index 7dfffcc1120..47c2c46a532 100644
--- a/src/test/run-pass/expr-alt-fail.rs
+++ b/src/test/run-pass/expr-alt-fail.rs
@@ -4,7 +4,7 @@ fn test_simple() {
 }
 
 fn test_box() {
-    let r = alt true { true { [10] } false { fail } };
+    let r = alt true { true { [10]/~ } false { fail } };
     assert (r[0] == 10);
 }
 
diff --git a/src/test/run-pass/expr-fn.rs b/src/test/run-pass/expr-fn.rs
index a3bd2449bb2..a872884f95c 100644
--- a/src/test/run-pass/expr-fn.rs
+++ b/src/test/run-pass/expr-fn.rs
@@ -4,7 +4,7 @@ fn test_int() {
 }
 
 fn test_vec() {
-    fn f() -> [int] { [10, 11] }
+    fn f() -> [int]/~ { [10, 11]/~ }
     assert (f()[1] == 11);
 }
 
diff --git a/src/test/run-pass/for-destruct.rs b/src/test/run-pass/for-destruct.rs
index 71480c47a75..ef28e7255c2 100644
--- a/src/test/run-pass/for-destruct.rs
+++ b/src/test/run-pass/for-destruct.rs
@@ -1,5 +1,5 @@
 fn main() {
-    for vec::each([{x: 10, y: 20}, {x: 30, y: 0}]) {|elt|
+    for vec::each([{x: 10, y: 20}, {x: 30, y: 0}]/~) {|elt|
         assert (elt.x + elt.y == 30);
     }
 }
diff --git a/src/test/run-pass/for-loop-fail.rs b/src/test/run-pass/for-loop-fail.rs
index 177fd1f5c54..0c72a5d05f8 100644
--- a/src/test/run-pass/for-loop-fail.rs
+++ b/src/test/run-pass/for-loop-fail.rs
@@ -1 +1 @@
-fn main() { let x: [int] = []; for x.each {|_i| fail "moop"; } }
+fn main() { let x: [int]/~ = []/~; for x.each {|_i| fail "moop"; } }
diff --git a/src/test/run-pass/foreach-nested.rs b/src/test/run-pass/foreach-nested.rs
index 3cc0a5a82f1..007117b04cb 100644
--- a/src/test/run-pass/foreach-nested.rs
+++ b/src/test/run-pass/foreach-nested.rs
@@ -5,7 +5,7 @@
 fn two(it: fn(int)) { it(0); it(1); }
 
 fn main() {
-    let a: [mut int] = [mut -1, -1, -1, -1];
+    let a: [mut int]/~ = [mut -1, -1, -1, -1]/~;
     let mut p: int = 0;
     two {|i|
         two {|j| a[p] = 10 * i + j; p += 1; };
diff --git a/src/test/run-pass/generic-ivec-leak.rs b/src/test/run-pass/generic-ivec-leak.rs
index 1e7de587fb9..22726635da5 100644
--- a/src/test/run-pass/generic-ivec-leak.rs
+++ b/src/test/run-pass/generic-ivec-leak.rs
@@ -1,4 +1,4 @@
 enum wrapper<T> { wrapped(T), }
 
-fn main() { let w = wrapped([1, 2, 3, 4, 5]); }
+fn main() { let w = wrapped([1, 2, 3, 4, 5]/~); }
 
diff --git a/src/test/run-pass/generic-ivec.rs b/src/test/run-pass/generic-ivec.rs
index 26298de5b94..c7d5828fbcd 100644
--- a/src/test/run-pass/generic-ivec.rs
+++ b/src/test/run-pass/generic-ivec.rs
@@ -1,3 +1,3 @@
 fn f<T>(v: @T) { }
-fn main() { f(@[1, 2, 3, 4, 5]); }
+fn main() { f(@[1, 2, 3, 4, 5]/~); }
 
diff --git a/src/test/run-pass/hashmap-memory.rs b/src/test/run-pass/hashmap-memory.rs
index 9d8e7ec116e..ccbb07fce1f 100644
--- a/src/test/run-pass/hashmap-memory.rs
+++ b/src/test/run-pass/hashmap-memory.rs
@@ -31,9 +31,9 @@ mod map_reduce {
 
     type mapper = native fn(str, putter);
 
-    enum ctrl_proto { find_reducer([u8], chan<int>), mapper_done, }
+    enum ctrl_proto { find_reducer([u8]/~, chan<int>), mapper_done, }
 
-    fn start_mappers(ctrl: chan<ctrl_proto>, inputs: [str]) {
+    fn start_mappers(ctrl: chan<ctrl_proto>, inputs: [str]/~) {
         for inputs.each {|i|
             task::spawn {|| map_task(ctrl, i); };
         }
@@ -63,7 +63,7 @@ mod map_reduce {
         send(ctrl, mapper_done);
     }
 
-    fn map_reduce(inputs: [str]) {
+    fn map_reduce(inputs: [str]/~) {
         let ctrl = port();
 
         // This task becomes the master control task. It spawns others
diff --git a/src/test/run-pass/iface-generic.rs b/src/test/run-pass/iface-generic.rs
index 5ad911d553e..21345ed9850 100644
--- a/src/test/run-pass/iface-generic.rs
+++ b/src/test/run-pass/iface-generic.rs
@@ -12,20 +12,20 @@ impl of to_str for () {
 }
 
 iface map<T> {
-    fn map<U>(f: fn(T) -> U) -> [U];
+    fn map<U>(f: fn(T) -> U) -> [U]/~;
 }
-impl <T> of map<T> for [T] {
-    fn map<U>(f: fn(T) -> U) -> [U] {
-        let mut r = [];
-        for self.each {|x| r += [f(x)]; }
+impl <T> of map<T> for [T]/~ {
+    fn map<U>(f: fn(T) -> U) -> [U]/~ {
+        let mut r = []/~;
+        for self.each {|x| r += [f(x)]/~; }
         r
     }
 }
 
-fn foo<U, T: map<U>>(x: T) -> [str] {
+fn foo<U, T: map<U>>(x: T) -> [str]/~ {
     x.map({|_e| "hi" })
 }
-fn bar<U: to_str, T: map<U>>(x: T) -> [str] {
+fn bar<U: to_str, T: map<U>>(x: T) -> [str]/~ {
     x.map({|_e| _e.to_str() })
 }
 
diff --git a/src/test/run-pass/iface-to-str.rs b/src/test/run-pass/iface-to-str.rs
index cf30cefbd33..1490ec3d93f 100644
--- a/src/test/run-pass/iface-to-str.rs
+++ b/src/test/run-pass/iface-to-str.rs
@@ -6,7 +6,7 @@ impl of to_str for int {
     fn to_str() -> str { int::str(self) }
 }
 
-impl <T: to_str> of to_str for [T] {
+impl <T: to_str> of to_str for [T]/~ {
     fn to_str() -> str {
         "[" + str::connect(vec::map(self, {|e| e.to_str()}), ", ") + "]"
     }
@@ -14,15 +14,15 @@ impl <T: to_str> of to_str for [T] {
 
 fn main() {
     assert 1.to_str() == "1";
-    assert [2, 3, 4].to_str() == "[2, 3, 4]";
+    assert [2, 3, 4]/~.to_str() == "[2, 3, 4]";
 
     fn indirect<T: to_str>(x: T) -> str {
         x.to_str() + "!"
     }
-    assert indirect([10, 20]) == "[10, 20]!";
+    assert indirect([10, 20]/~) == "[10, 20]!";
 
     fn indirect2<T: to_str>(x: T) -> str {
         indirect(x)
     }
-    assert indirect2([1]) == "[1]!";
+    assert indirect2([1]/~) == "[1]!";
 }
diff --git a/src/test/run-pass/impl-variance.rs b/src/test/run-pass/impl-variance.rs
index 5e0b7b26268..b78c8241efa 100644
--- a/src/test/run-pass/impl-variance.rs
+++ b/src/test/run-pass/impl-variance.rs
@@ -1,12 +1,12 @@
-impl extensions<T> for [const T] {
+impl extensions<T> for [const T]/~ {
     fn foo() -> uint { vec::len(self) }
 }
 
 fn main() {
-    let v = [const 0];
+    let v = [const 0]/~;
     assert v.foo() == 1u;
-    let v = [0];
+    let v = [0]/~;
     assert v.foo() == 1u;
-    let v = [mut 0];
+    let v = [mut 0]/~;
     assert v.foo() == 1u;
 }
\ No newline at end of file
diff --git a/src/test/run-pass/import-glob-crate.rs b/src/test/run-pass/import-glob-crate.rs
index c1473b1a0d4..92519f9945f 100644
--- a/src/test/run-pass/import-glob-crate.rs
+++ b/src/test/run-pass/import-glob-crate.rs
@@ -4,6 +4,6 @@ import vec::*;
 
 fn main() {
     let mut v = from_elem(0u, 0);
-    v = vec::append(v, [4, 2]);
-    assert (reversed(v) == [2, 4]);
+    v = vec::append(v, [4, 2]/~);
+    assert (reversed(v) == [2, 4]/~);
 }
diff --git a/src/test/run-pass/import-in-block.rs b/src/test/run-pass/import-in-block.rs
index b8a74753895..33876d9800e 100644
--- a/src/test/run-pass/import-in-block.rs
+++ b/src/test/run-pass/import-in-block.rs
@@ -3,9 +3,9 @@ use std;
 fn main() {
     import vec;
     import vec::to_mut;
-    log(debug, vec::len(to_mut([1, 2])));
+    log(debug, vec::len(to_mut([1, 2]/~)));
     {
         import vec::*;
-        log(debug, len([2]));
+        log(debug, len([2]/~));
     }
 }
diff --git a/src/test/run-pass/import4.rs b/src/test/run-pass/import4.rs
index 42a0bc0fb73..a307e7ac190 100644
--- a/src/test/run-pass/import4.rs
+++ b/src/test/run-pass/import4.rs
@@ -5,4 +5,4 @@ mod zed {
     fn bar() { #debug("bar"); }
 }
 
-fn main(args: [str]) { let zed = 42; bar(); }
+fn main(args: [str]/~) { let zed = 42; bar(); }
diff --git a/src/test/run-pass/import5.rs b/src/test/run-pass/import5.rs
index f1b0c5daac9..11c5a31fdbb 100644
--- a/src/test/run-pass/import5.rs
+++ b/src/test/run-pass/import5.rs
@@ -7,4 +7,4 @@ mod foo {
     }
 }
 
-fn main(args: [str]) { bar(); }
+fn main(args: [str]/~) { bar(); }
diff --git a/src/test/run-pass/import7.rs b/src/test/run-pass/import7.rs
index d8a8e5467ea..a63673214a2 100644
--- a/src/test/run-pass/import7.rs
+++ b/src/test/run-pass/import7.rs
@@ -12,4 +12,4 @@ mod bar {
         mod zed { }
     }
 }
-fn main(args: [str]) { baz(); }
+fn main(args: [str]/~) { baz(); }
diff --git a/src/test/run-pass/infer-fn-tail-expr.rs b/src/test/run-pass/infer-fn-tail-expr.rs
index 4658ea4329c..d9fb1216a4e 100644
--- a/src/test/run-pass/infer-fn-tail-expr.rs
+++ b/src/test/run-pass/infer-fn-tail-expr.rs
@@ -1,5 +1,5 @@
 // issue #680
 
-fn f() -> [int] { [] }
+fn f() -> [int]/~ { []/~ }
 
 fn main() { }
diff --git a/src/test/run-pass/integral-indexing.rs b/src/test/run-pass/integral-indexing.rs
index 0351736b2a3..c41ff28a2d8 100644
--- a/src/test/run-pass/integral-indexing.rs
+++ b/src/test/run-pass/integral-indexing.rs
@@ -3,7 +3,7 @@
 
 // This is a testcase for issue #94.
 fn main() {
-    let v: [int] = [0, 1, 2, 3, 4, 5];
+    let v: [int]/~ = [0, 1, 2, 3, 4, 5]/~;
     let s: str = "abcdef";
     assert (v[3u] == 3);
     assert (v[3u8] == 3);
diff --git a/src/test/run-pass/issue-1821.rs b/src/test/run-pass/issue-1821.rs
index 9bb5ed0c2ef..07100a20860 100644
--- a/src/test/run-pass/issue-1821.rs
+++ b/src/test/run-pass/issue-1821.rs
@@ -1,5 +1,5 @@
 // Issue #1821 - Don't recurse trying to typecheck this
 enum t {
-    foo([t])
+    foo([t]/~)
 }
 fn main() {}
\ No newline at end of file
diff --git a/src/test/run-pass/issue-1989.rs b/src/test/run-pass/issue-1989.rs
index 92b7709a8a1..07d13b56edc 100644
--- a/src/test/run-pass/issue-1989.rs
+++ b/src/test/run-pass/issue-1989.rs
@@ -19,6 +19,6 @@ fn empty_pointy() -> @pointy {
 
 fn main()
 {
-    let v = [empty_pointy(), empty_pointy()];
+    let v = [empty_pointy(), empty_pointy()]/~;
     v[0].a = p(v[0]);
 }
diff --git a/src/test/run-pass/issue-2101.rs b/src/test/run-pass/issue-2101.rs
index 35434e11f61..4ae5a11c566 100644
--- a/src/test/run-pass/issue-2101.rs
+++ b/src/test/run-pass/issue-2101.rs
@@ -9,7 +9,7 @@ fn init(ar: &a.arena::arena, str: str) -> &a.hold {
     new(*ar) s(str)
 }
 
-fn main(args: [str]) {
+fn main(args: [str]/~) {
     let ar = arena::arena();
     let leak = init(&ar, args[0]);
     alt *leak {
diff --git a/src/test/run-pass/issue-2502.rs b/src/test/run-pass/issue-2502.rs
index 6aa35169dd5..add0c3e6dff 100644
--- a/src/test/run-pass/issue-2502.rs
+++ b/src/test/run-pass/issue-2502.rs
@@ -1,11 +1,11 @@
 class font/& {
-    let fontbuf: &self.[u8];
+    let fontbuf: &self.[u8]/~;
 
-    new(fontbuf: &self.[u8]) {
+    new(fontbuf: &self.[u8]/~) {
         self.fontbuf = fontbuf;
     }
 
-    fn buf() -> &self.[u8] {
+    fn buf() -> &self.[u8]/~ {
         self.fontbuf
     }
 }
diff --git a/src/test/run-pass/issue-2611.rs b/src/test/run-pass/issue-2611.rs
index ebd77749354..dc2a2f1b005 100644
--- a/src/test/run-pass/issue-2611.rs
+++ b/src/test/run-pass/issue-2611.rs
@@ -3,7 +3,7 @@ import iter;
 import iter::base_iter;
 
 impl Q<A> for base_iter<A> {
-   fn flat_map_to_vec<B:copy, IB:base_iter<B>>(op: fn(B) -> IB) -> [B] {
+   fn flat_map_to_vec<B:copy, IB:base_iter<B>>(op: fn(B) -> IB) -> [B]/~ {
       iter::flat_map_to_vec(self, op)
    }
 }
diff --git a/src/test/run-pass/issue-687.rs b/src/test/run-pass/issue-687.rs
index 1bb4f69fb02..a721aa0ddea 100644
--- a/src/test/run-pass/issue-687.rs
+++ b/src/test/run-pass/issue-687.rs
@@ -7,16 +7,16 @@ import comm::port;
 import comm::recv;
 import comm::send;
 
-enum msg { closed, received([u8]), }
+enum msg { closed, received([u8]/~), }
 
-fn producer(c: chan<[u8]>) {
-    send(c, [1u8, 2u8, 3u8, 4u8]);
-    let empty: [u8] = [];
+fn producer(c: chan<[u8]/~>) {
+    send(c, [1u8, 2u8, 3u8, 4u8]/~);
+    let empty: [u8]/~ = []/~;
     send(c, empty);
 }
 
-fn packager(cb: chan<chan<[u8]>>, msg: chan<msg>) {
-    let p: port<[u8]> = port();
+fn packager(cb: chan<chan<[u8]/~>>, msg: chan<msg>) {
+    let p: port<[u8]/~> = port();
     send(cb, chan(p));
     loop {
         #debug("waiting for bytes");
@@ -39,11 +39,11 @@ fn packager(cb: chan<chan<[u8]>>, msg: chan<msg>) {
 fn main() {
     let p: port<msg> = port();
     let ch = chan(p);
-    let recv_reader: port<chan<[u8]>> = port();
+    let recv_reader: port<chan<[u8]/~>> = port();
     let recv_reader_chan = chan(recv_reader);
     let pack = task::spawn {|| packager(recv_reader_chan, ch); };
 
-    let source_chan: chan<[u8]> = recv(recv_reader);
+    let source_chan: chan<[u8]/~> = recv(recv_reader);
     let prod = task::spawn {|| producer(source_chan); };
 
     loop {
diff --git a/src/test/run-pass/iter-all.rs b/src/test/run-pass/iter-all.rs
index 1de45c97d19..d2625414399 100644
--- a/src/test/run-pass/iter-all.rs
+++ b/src/test/run-pass/iter-all.rs
@@ -1,9 +1,9 @@
 fn is_even(&&x: uint) -> bool { (x % 2u) == 0u }
 
 fn main() {
-    assert ![1u, 2u].all(is_even);
-    assert [2u, 4u].all(is_even);
-    assert [].all(is_even);
+    assert ![1u, 2u]/~.all(is_even);
+    assert [2u, 4u]/~.all(is_even);
+    assert []/~.all(is_even);
 
     assert !some(1u).all(is_even);
     assert some(2u).all(is_even);
diff --git a/src/test/run-pass/iter-any.rs b/src/test/run-pass/iter-any.rs
index 40cd8a18039..8cba862d8fa 100644
--- a/src/test/run-pass/iter-any.rs
+++ b/src/test/run-pass/iter-any.rs
@@ -1,9 +1,9 @@
 fn is_even(&&x: uint) -> bool { (x % 2u) == 0u }
 
 fn main() {
-    assert ![1u, 3u].any(is_even);
-    assert [1u, 2u].any(is_even);
-    assert ![].any(is_even);
+    assert ![1u, 3u]/~.any(is_even);
+    assert [1u, 2u]/~.any(is_even);
+    assert ![]/~.any(is_even);
 
     assert !some(1u).any(is_even);
     assert some(2u).any(is_even);
diff --git a/src/test/run-pass/iter-contains.rs b/src/test/run-pass/iter-contains.rs
index 5af80d47a10..bd5e7a4bf52 100644
--- a/src/test/run-pass/iter-contains.rs
+++ b/src/test/run-pass/iter-contains.rs
@@ -1,9 +1,9 @@
 fn main() {
-    assert [].contains(22u) == false;
-    assert [1u, 3u].contains(22u) == false;
-    assert [22u, 1u, 3u].contains(22u) == true;
-    assert [1u, 22u, 3u].contains(22u) == true;
-    assert [1u, 3u, 22u].contains(22u) == true;
+    assert []/~.contains(22u) == false;
+    assert [1u, 3u]/~.contains(22u) == false;
+    assert [22u, 1u, 3u]/~.contains(22u) == true;
+    assert [1u, 22u, 3u]/~.contains(22u) == true;
+    assert [1u, 3u, 22u]/~.contains(22u) == true;
     assert none.contains(22u) == false;
     assert some(1u).contains(22u) == false;
     assert some(22u).contains(22u) == true;
diff --git a/src/test/run-pass/iter-count.rs b/src/test/run-pass/iter-count.rs
index 54c9c1e2b73..3cca6d748c8 100644
--- a/src/test/run-pass/iter-count.rs
+++ b/src/test/run-pass/iter-count.rs
@@ -1,8 +1,8 @@
 fn main() {
-    assert [].count(22u) == 0u;
-    assert [1u, 3u].count(22u) == 0u;
-    assert [22u, 1u, 3u].count(22u) == 1u;
-    assert [22u, 1u, 22u].count(22u) == 2u;
+    assert []/~.count(22u) == 0u;
+    assert [1u, 3u]/~.count(22u) == 0u;
+    assert [22u, 1u, 3u]/~.count(22u) == 1u;
+    assert [22u, 1u, 22u]/~.count(22u) == 2u;
     assert none.count(22u) == 0u;
     assert some(1u).count(22u) == 0u;
     assert some(22u).count(22u) == 1u;
diff --git a/src/test/run-pass/iter-eachi.rs b/src/test/run-pass/iter-eachi.rs
index 30efd24a55f..432a0080143 100644
--- a/src/test/run-pass/iter-eachi.rs
+++ b/src/test/run-pass/iter-eachi.rs
@@ -1,6 +1,6 @@
 fn main() {
     let mut c = 0u;
-    for [1u, 2u, 3u, 4u, 5u].eachi { |i, v|
+    for [1u, 2u, 3u, 4u, 5u]/~.eachi { |i, v|
         assert (i + 1u) == v;
         c += 1u;
     }
diff --git a/src/test/run-pass/iter-filter-to-vec.rs b/src/test/run-pass/iter-filter-to-vec.rs
index 91b4eeffe7d..c16cdc69ad1 100644
--- a/src/test/run-pass/iter-filter-to-vec.rs
+++ b/src/test/run-pass/iter-filter-to-vec.rs
@@ -1,9 +1,9 @@
 fn is_even(&&x: uint) -> bool { (x % 2u) == 0u }
 
 fn main() {
-    assert [1u, 3u].filter_to_vec(is_even) == [];
-    assert [1u, 2u, 3u].filter_to_vec(is_even) == [2u];
-    assert none.filter_to_vec(is_even) == [];
-    assert some(1u).filter_to_vec(is_even) == [];
-    assert some(2u).filter_to_vec(is_even) == [2u];
+    assert [1u, 3u]/~.filter_to_vec(is_even) == []/~;
+    assert [1u, 2u, 3u]/~.filter_to_vec(is_even) == [2u]/~;
+    assert none.filter_to_vec(is_even) == []/~;
+    assert some(1u).filter_to_vec(is_even) == []/~;
+    assert some(2u).filter_to_vec(is_even) == [2u]/~;
 }
\ No newline at end of file
diff --git a/src/test/run-pass/iter-flat-map-to-vec.rs b/src/test/run-pass/iter-flat-map-to-vec.rs
index d4395b487f4..92fdafc7f95 100644
--- a/src/test/run-pass/iter-flat-map-to-vec.rs
+++ b/src/test/run-pass/iter-flat-map-to-vec.rs
@@ -1,21 +1,21 @@
 // xfail-test -- flat_map_to_vec currently disable
 
-fn repeat(&&x: uint) -> [uint] { [x, x] }
+fn repeat(&&x: uint) -> [uint]/~ { [x, x]/~ }
 
 fn incd_if_even(&&x: uint) -> option<uint> {
     if (x % 2u) == 0u {some(x + 1u)} else {none}
 }
 
 fn main() {
-    assert [1u, 3u].flat_map_to_vec(repeat) == [1u, 1u, 3u, 3u];
-    assert [].flat_map_to_vec(repeat) == [];
-    assert none.flat_map_to_vec(repeat) == [];
-    assert some(1u).flat_map_to_vec(repeat) == [1u, 1u];
-    assert some(2u).flat_map_to_vec(repeat) == [2u, 2u];
+    assert [1u, 3u]/~.flat_map_to_vec(repeat) == [1u, 1u, 3u, 3u]/~;
+    assert []/~.flat_map_to_vec(repeat) == []/~;
+    assert none.flat_map_to_vec(repeat) == []/~;
+    assert some(1u).flat_map_to_vec(repeat) == [1u, 1u]/~;
+    assert some(2u).flat_map_to_vec(repeat) == [2u, 2u]/~;
 
-    assert [1u, 2u, 5u].flat_map_to_vec(incd_if_even) == [3u];
-    assert [].flat_map_to_vec(incd_if_even) == [];
-    assert none.flat_map_to_vec(incd_if_even) == [];
-    assert some(1u).flat_map_to_vec(incd_if_even) == [];
-    assert some(2u).flat_map_to_vec(incd_if_even) == [3u];
+    assert [1u, 2u, 5u]/~.flat_map_to_vec(incd_if_even) == [3u]/~;
+    assert []/~.flat_map_to_vec(incd_if_even) == []/~;
+    assert none.flat_map_to_vec(incd_if_even) == []/~;
+    assert some(1u).flat_map_to_vec(incd_if_even) == []/~;
+    assert some(2u).flat_map_to_vec(incd_if_even) == [3u]/~;
 }
\ No newline at end of file
diff --git a/src/test/run-pass/iter-foldl.rs b/src/test/run-pass/iter-foldl.rs
index 9f5fafcd5bc..d2678c5ba85 100644
--- a/src/test/run-pass/iter-foldl.rs
+++ b/src/test/run-pass/iter-foldl.rs
@@ -1,8 +1,8 @@
 fn add(&&x: float, &&y: uint) -> float { x + (y as float) }
 
 fn main() {
-    assert [1u, 3u].foldl(20f, add) == 24f;
-    assert [].foldl(20f, add) == 20f;
+    assert [1u, 3u]/~.foldl(20f, add) == 24f;
+    assert []/~.foldl(20f, add) == 20f;
     assert none.foldl(20f, add) == 20f;
     assert some(1u).foldl(20f, add) == 21f;
     assert some(2u).foldl(20f, add) == 22f;
diff --git a/src/test/run-pass/iter-map-to-vec.rs b/src/test/run-pass/iter-map-to-vec.rs
index ea98196fbdd..68bf3248ecb 100644
--- a/src/test/run-pass/iter-map-to-vec.rs
+++ b/src/test/run-pass/iter-map-to-vec.rs
@@ -1,9 +1,9 @@
 fn inc(&&x: uint) -> uint { x + 1u }
 
 fn main() {
-    assert [1u, 3u].map_to_vec(inc) == [2u, 4u];
-    assert [1u, 2u, 3u].map_to_vec(inc) == [2u, 3u, 4u];
-    assert none.map_to_vec(inc) == [];
-    assert some(1u).map_to_vec(inc) == [2u];
-    assert some(2u).map_to_vec(inc) == [3u];
+    assert [1u, 3u]/~.map_to_vec(inc) == [2u, 4u]/~;
+    assert [1u, 2u, 3u]/~.map_to_vec(inc) == [2u, 3u, 4u]/~;
+    assert none.map_to_vec(inc) == []/~;
+    assert some(1u).map_to_vec(inc) == [2u]/~;
+    assert some(2u).map_to_vec(inc) == [3u]/~;
 }
\ No newline at end of file
diff --git a/src/test/run-pass/iter-min-max.rs b/src/test/run-pass/iter-min-max.rs
index 338ba795111..4c67670367e 100644
--- a/src/test/run-pass/iter-min-max.rs
+++ b/src/test/run-pass/iter-min-max.rs
@@ -1,11 +1,11 @@
 fn is_even(&&x: uint) -> bool { (x % 2u) == 0u }
 
 fn main() {
-    assert [1u, 3u].min() == 1u;
-    assert [3u, 1u].min() == 1u;
+    assert [1u, 3u]/~.min() == 1u;
+    assert [3u, 1u]/~.min() == 1u;
     assert some(1u).min() == 1u;
 
-    assert [1u, 3u].max() == 3u;
-    assert [3u, 1u].max() == 3u;
+    assert [1u, 3u]/~.max() == 3u;
+    assert [3u, 1u]/~.max() == 3u;
     assert some(3u).max() == 3u;
 }
\ No newline at end of file
diff --git a/src/test/run-pass/iter-to-vec.rs b/src/test/run-pass/iter-to-vec.rs
index 3b2f1b2ced5..c8fcb881934 100644
--- a/src/test/run-pass/iter-to-vec.rs
+++ b/src/test/run-pass/iter-to-vec.rs
@@ -1,8 +1,8 @@
 fn main() {
-    assert [1u, 3u].to_vec() == [1u, 3u];
-    let e: [uint] = [];
-    assert e.to_vec() == [];
-    assert none::<uint>.to_vec() == [];
-    assert some(1u).to_vec() == [1u];
-    assert some(2u).to_vec() == [2u];
+    assert [1u, 3u]/~.to_vec() == [1u, 3u]/~;
+    let e: [uint]/~ = []/~;
+    assert e.to_vec() == []/~;
+    assert none::<uint>.to_vec() == []/~;
+    assert some(1u).to_vec() == [1u]/~;
+    assert some(2u).to_vec() == [2u]/~;
 }
\ No newline at end of file
diff --git a/src/test/run-pass/ivec-add.rs b/src/test/run-pass/ivec-add.rs
index b0289ceb64d..6ca1b2fb5d4 100644
--- a/src/test/run-pass/ivec-add.rs
+++ b/src/test/run-pass/ivec-add.rs
@@ -1,6 +1,6 @@
-fn double<T: copy>(a: T) -> [T] { ret [a] + [a]; }
+fn double<T: copy>(a: T) -> [T]/~ { ret [a]/~ + [a]/~; }
 
-fn double_int(a: int) -> [int] { ret [a] + [a]; }
+fn double_int(a: int) -> [int]/~ { ret [a]/~ + [a]/~; }
 
 fn main() {
     let mut d = double(1);
diff --git a/src/test/run-pass/ivec-pass-by-value.rs b/src/test/run-pass/ivec-pass-by-value.rs
index 557c3dc9b3e..69c19f5d9b0 100644
--- a/src/test/run-pass/ivec-pass-by-value.rs
+++ b/src/test/run-pass/ivec-pass-by-value.rs
@@ -1,3 +1,3 @@
-fn f(a: [int]) { }
-fn main() { f([1, 2, 3, 4, 5]); }
+fn f(a: [int]/~) { }
+fn main() { f([1, 2, 3, 4, 5]/~); }
 
diff --git a/src/test/run-pass/ivec-tag.rs b/src/test/run-pass/ivec-tag.rs
index dce947bb622..a1d0eccb50a 100644
--- a/src/test/run-pass/ivec-tag.rs
+++ b/src/test/run-pass/ivec-tag.rs
@@ -7,16 +7,16 @@ import comm::port;
 import comm::send;
 import comm::recv;
 
-fn producer(c: chan<[u8]>) {
+fn producer(c: chan<[u8]/~>) {
     send(c,
          [1u8, 2u8, 3u8, 4u8, 5u8, 6u8, 7u8, 8u8, 9u8, 10u8, 11u8, 12u8,
-          13u8]);
+          13u8]/~);
 }
 
 fn main() {
-    let p: port<[u8]> = port();
+    let p: port<[u8]/~> = port();
     let ch = chan(p);
     let prod = task::spawn {|| producer(ch); };
 
-    let data: [u8] = recv(p);
+    let data: [u8]/~ = recv(p);
 }
diff --git a/src/test/run-pass/lambda-infer-unresolved.rs b/src/test/run-pass/lambda-infer-unresolved.rs
index 36b93774c86..3bf96f6dccb 100644
--- a/src/test/run-pass/lambda-infer-unresolved.rs
+++ b/src/test/run-pass/lambda-infer-unresolved.rs
@@ -1,7 +1,7 @@
 // This should typecheck even though the type of e is not fully
 // resolved when we finish typechecking the fn@.
 fn main() {
-    let e = @{mut refs: [], n: 0};
+    let e = @{mut refs: []/~, n: 0};
     let f = fn@ () { log(error, e.n); };
-    e.refs += [1];
+    e.refs += [1]/~;
 }
diff --git a/src/test/run-pass/linear-for-loop.rs b/src/test/run-pass/linear-for-loop.rs
index f106e8c8a45..c963c781053 100644
--- a/src/test/run-pass/linear-for-loop.rs
+++ b/src/test/run-pass/linear-for-loop.rs
@@ -1,7 +1,7 @@
 
 
 fn main() {
-    let x = [1, 2, 3];
+    let x = [1, 2, 3]/~;
     let mut y = 0;
     for x.each {|i| log(debug, i); y += i; }
     log(debug, y);
diff --git a/src/test/run-pass/liveness-move-in-loop.rs b/src/test/run-pass/liveness-move-in-loop.rs
index a7f9547c059..edc3d97d794 100644
--- a/src/test/run-pass/liveness-move-in-loop.rs
+++ b/src/test/run-pass/liveness-move-in-loop.rs
@@ -1,11 +1,11 @@
 fn take(-x: int) -> int {x}
 
 fn the_loop() {
-    let mut list = [];
+    let mut list = []/~;
     loop {
         let x = 5;
         if x > 3 {
-            list += [take(x)];
+            list += [take(x)]/~;
         } else {
             break;
         }
diff --git a/src/test/run-pass/log-knows-the-names-of-variants-in-std.rs b/src/test/run-pass/log-knows-the-names-of-variants-in-std.rs
index 31f6b31fa37..78d912ff4c8 100644
--- a/src/test/run-pass/log-knows-the-names-of-variants-in-std.rs
+++ b/src/test/run-pass/log-knows-the-names-of-variants-in-std.rs
@@ -11,7 +11,7 @@ fn check_log<T>(exp: str, v: T) {
 }
 
 fn main() {
-    let x = list::from_vec([a(22u), b("hi")]);
+    let x = list::from_vec([a(22u), b("hi")]/~);
     let exp = "@cons(a(22), @cons(b(~\"hi\"), @nil))";
     assert #fmt["%?", x] == exp;
     check_log(exp, x);
diff --git a/src/test/run-pass/log-linearized.rs b/src/test/run-pass/log-linearized.rs
index 3e202e84b81..8bf9a94fa00 100644
--- a/src/test/run-pass/log-linearized.rs
+++ b/src/test/run-pass/log-linearized.rs
@@ -5,10 +5,10 @@ enum option<T> {
     some(T),
 }
 
-type smallintmap<T> = @{mut v: [mut option<T>]};
+type smallintmap<T> = @{mut v: [mut option<T>]/~};
 
 fn mk<T>() -> smallintmap<T> {
-    let v: [mut option<T>] = [mut];
+    let v: [mut option<T>]/~ = [mut]/~;
     ret @{mut v: v};
 }
 
diff --git a/src/test/run-pass/log-str.rs b/src/test/run-pass/log-str.rs
index 0c32e92f71f..e9b0f1e0c6d 100644
--- a/src/test/run-pass/log-str.rs
+++ b/src/test/run-pass/log-str.rs
@@ -1,4 +1,4 @@
 fn main() {
-    assert "~[1, 2, 3]" == sys::log_str([1, 2, 3]);
+    assert "~[1, 2, 3]" == sys::log_str([1, 2, 3]/~);
     assert #fmt["%?/%6?", [1, 2, 3], "hi"] == "~[1, 2, 3]/ ~\"hi\"";
 }
diff --git a/src/test/run-pass/loop-scope.rs b/src/test/run-pass/loop-scope.rs
index 3fe01a229ee..f43f8673a50 100644
--- a/src/test/run-pass/loop-scope.rs
+++ b/src/test/run-pass/loop-scope.rs
@@ -1,5 +1,5 @@
 fn main() {
-    let x = [10, 20, 30];
+    let x = [10, 20, 30]/~;
     let mut sum = 0;
     for x.each {|x| sum += x; }
     assert (sum == 60);
diff --git a/src/test/run-pass/main-ivec.rs b/src/test/run-pass/main-ivec.rs
index 8db23350855..b7c01eb9ad1 100644
--- a/src/test/run-pass/main-ivec.rs
+++ b/src/test/run-pass/main-ivec.rs
@@ -1 +1 @@
-fn main(args: [str]) { for args.each {|s| log(debug, s); } }
+fn main(args: [str]/~) { for args.each {|s| log(debug, s); } }
diff --git a/src/test/run-pass/maybe-mutable.rs b/src/test/run-pass/maybe-mutable.rs
index 4f305ff8378..41a649052b7 100644
--- a/src/test/run-pass/maybe-mutable.rs
+++ b/src/test/run-pass/maybe-mutable.rs
@@ -2,15 +2,15 @@
 
 
 // -*- rust -*-
-fn len(v: [const int]) -> uint {
+fn len(v: [const int]/~) -> uint {
     let mut i = 0u;
     while i < vec::len(v) { i += 1u; }
     ret i;
 }
 
 fn main() {
-    let v0 = [1, 2, 3, 4, 5];
+    let v0 = [1, 2, 3, 4, 5]/~;
     log(debug, len(v0));
-    let v1 = [mut 1, 2, 3, 4, 5];
+    let v1 = [mut 1, 2, 3, 4, 5]/~;
     log(debug, len(v1));
 }
diff --git a/src/test/run-pass/mod-view-items.rs b/src/test/run-pass/mod-view-items.rs
index 7046f1e3d78..c92821da978 100644
--- a/src/test/run-pass/mod-view-items.rs
+++ b/src/test/run-pass/mod-view-items.rs
@@ -7,7 +7,7 @@
 mod m {
     use std;
     import vec;
-    fn f() -> [int] { vec::from_elem(1u, 0) }
+    fn f() -> [int]/~ { vec::from_elem(1u, 0) }
 }
 
 fn main() { let x = m::f(); }
diff --git a/src/test/run-pass/monad.rs b/src/test/run-pass/monad.rs
index d14de311d9e..e171cad58fb 100644
--- a/src/test/run-pass/monad.rs
+++ b/src/test/run-pass/monad.rs
@@ -1,6 +1,6 @@
-impl monad<A> for [A] {
-    fn bind<B>(f: fn(A) -> [B]) -> [B] {
-        let mut r = [];
+impl monad<A> for [A]/~ {
+    fn bind<B>(f: fn(A) -> [B]/~) -> [B]/~ {
+        let mut r = []/~;
         for self.each {|elt| r += f(elt); }
         r
     }
diff --git a/src/test/run-pass/morestack6.rs b/src/test/run-pass/morestack6.rs
index 461be434b0a..10fe6d9a340 100644
--- a/src/test/run-pass/morestack6.rs
+++ b/src/test/run-pass/morestack6.rs
@@ -56,7 +56,7 @@ fn main() {
         calllink08,
         calllink09,
         calllink10
-    ];
+    ]/~;
     let rng = rand::rng();
     for fns.each {|f|
         let sz = rng.next() % 256u32 + 256u32;
diff --git a/src/test/run-pass/move-arg-2-unique.rs b/src/test/run-pass/move-arg-2-unique.rs
index dde8e6d4d40..39a0ac1fe4a 100644
--- a/src/test/run-pass/move-arg-2-unique.rs
+++ b/src/test/run-pass/move-arg-2-unique.rs
@@ -1,10 +1,10 @@
 fn test(-foo: ~[int]) { assert (foo[0] == 10); }
 
 fn main() {
-    let x = ~[10];
+    let x = ~[10]/~;
     // Test forgetting a local by move-in
     test(x);
 
     // Test forgetting a temporary by move-in.
-    test(~[10]);
+    test(~[10]/~);
 }
diff --git a/src/test/run-pass/move-arg-2.rs b/src/test/run-pass/move-arg-2.rs
index 65a3913132c..d70ccc36dbe 100644
--- a/src/test/run-pass/move-arg-2.rs
+++ b/src/test/run-pass/move-arg-2.rs
@@ -1,10 +1,10 @@
 fn test(-foo: @[int]) { assert (foo[0] == 10); }
 
 fn main() {
-    let x = @[10];
+    let x = @[10]/~;
     // Test forgetting a local by move-in
     test(x);
 
     // Test forgetting a temporary by move-in.
-    test(@[10]);
+    test(@[10]/~);
 }
diff --git a/src/test/run-pass/mutable-alias-vec.rs b/src/test/run-pass/mutable-alias-vec.rs
index b56f80d9700..edc682b892d 100644
--- a/src/test/run-pass/mutable-alias-vec.rs
+++ b/src/test/run-pass/mutable-alias-vec.rs
@@ -3,10 +3,10 @@
 // -*- rust -*-
 use std;
 
-fn grow(&v: [int]) { v += [1]; }
+fn grow(&v: [int]/~) { v += [1]/~; }
 
 fn main() {
-    let mut v: [int] = [];
+    let mut v: [int]/~ = []/~;
     grow(v);
     grow(v);
     grow(v);
diff --git a/src/test/run-pass/mutable-huh-variance-vec1.rs b/src/test/run-pass/mutable-huh-variance-vec1.rs
index 31cfab18ddc..403716321bc 100644
--- a/src/test/run-pass/mutable-huh-variance-vec1.rs
+++ b/src/test/run-pass/mutable-huh-variance-vec1.rs
@@ -1,12 +1,12 @@
 // error-pattern: mismatched types
 
 fn main() {
-    let v = [[0]];
+    let v = [[0]/~]/~;
 
     // This is ok because the outer vec is covariant with respect
     // to the inner vec. If the outer vec was mut then we
     // couldn't do this.
-    fn f(&&v: [[const int]]) {
+    fn f(&&v: [[const int]/~]/~) {
     }
 
     f(v);
diff --git a/src/test/run-pass/mutable-huh-variance-vec2.rs b/src/test/run-pass/mutable-huh-variance-vec2.rs
index 7815554cdab..56c8def9ac6 100644
--- a/src/test/run-pass/mutable-huh-variance-vec2.rs
+++ b/src/test/run-pass/mutable-huh-variance-vec2.rs
@@ -1,12 +1,12 @@
 // error-pattern: mismatched types
 
 fn main() {
-    let v = [[0]];
+    let v = [[0]/~]/~;
 
     // This is ok because the outer vec is covariant with respect
     // to the inner vec. If the outer vec was mut then we
     // couldn't do this.
-    fn f(&&v: [const [const int]]) {
+    fn f(&&v: [const [const int]/~]/~) {
     }
 
     f(v);
diff --git a/src/test/run-pass/mutable-vec-drop.rs b/src/test/run-pass/mutable-vec-drop.rs
index 2b1433d8a65..b7aa4278b49 100644
--- a/src/test/run-pass/mutable-vec-drop.rs
+++ b/src/test/run-pass/mutable-vec-drop.rs
@@ -1,6 +1,6 @@
 
 fn main() {
     // This just tests whether the vec leaks its members.
-    let pvec: [mut @{a: int, b: int}] =
-        [mut @{a: 1, b: 2}, @{a: 3, b: 4}, @{a: 5, b: 6}];
+    let pvec: [mut @{a: int, b: int}]/~ =
+        [mut @{a: 1, b: 2}, @{a: 3, b: 4}, @{a: 5, b: 6}]/~;
 }
diff --git a/src/test/run-pass/native-fn-linkname.rs b/src/test/run-pass/native-fn-linkname.rs
index 72d0ab01f96..eaa6522e2d1 100644
--- a/src/test/run-pass/native-fn-linkname.rs
+++ b/src/test/run-pass/native-fn-linkname.rs
@@ -12,7 +12,7 @@ native mod libc {
 
 fn strlen(str: str) -> uint unsafe {
     // C string is terminated with a zero
-    let bytes = str::bytes(str) + [0u8];
+    let bytes = str::bytes(str) + [0u8]/~;
     ret libc::my_strlen(vec::unsafe::to_ptr(bytes));
 }
 
diff --git a/src/test/run-pass/native2.rs b/src/test/run-pass/native2.rs
index 3ad9f330548..5fbef59101e 100644
--- a/src/test/run-pass/native2.rs
+++ b/src/test/run-pass/native2.rs
@@ -24,4 +24,4 @@ native mod libc {
 #[nolink]
 native mod baz { }
 
-fn main(args: [str]) { }
+fn main(args: [str]/~) { }
diff --git a/src/test/run-pass/newtype-polymorphic.rs b/src/test/run-pass/newtype-polymorphic.rs
index 69efb129146..4398f40a08a 100644
--- a/src/test/run-pass/newtype-polymorphic.rs
+++ b/src/test/run-pass/newtype-polymorphic.rs
@@ -1,11 +1,11 @@
-enum myvec<X> = [X];
+enum myvec<X> = [X]/~;
 
-fn myvec_deref<X: copy>(mv: myvec<X>) -> [X] { ret *mv; }
+fn myvec_deref<X: copy>(mv: myvec<X>) -> [X]/~ { ret *mv; }
 
 fn myvec_elt<X: copy>(mv: myvec<X>) -> X { ret mv[0]; }
 
 fn main() {
-    let mv = myvec([1, 2, 3]);
+    let mv = myvec([1, 2, 3]/~);
     assert (myvec_deref(mv)[1] == 2);
     assert (myvec_elt(mv) == 1);
     assert (mv[2] == 3);
diff --git a/src/test/run-pass/operator-overloading-leaks.rs b/src/test/run-pass/operator-overloading-leaks.rs
index a67bffa2e92..07186db4da9 100644
--- a/src/test/run-pass/operator-overloading-leaks.rs
+++ b/src/test/run-pass/operator-overloading-leaks.rs
@@ -1,11 +1,11 @@
 // The cases commented as "Leaks" need to not leak. Issue #2581
 
-impl methods<T: copy> for [T] {
-    fn -(x: [T]/&) -> [T] {
+impl methods<T: copy> for [T]/~ {
+    fn -(x: [T]/&) -> [T]/~ {
         [x[0], x[0], x[0]]
     }
 
-    fn foo(x: [T]/&) -> [T] {
+    fn foo(x: [T]/&) -> [T]/~ {
         [x[0], x[0], x[0]]
     }
 }
@@ -30,23 +30,23 @@ impl methods for @int {
 
 fn main() {
     // leaks
-    let mut bar = [1, 2, 3];
-    bar -= [3, 2, 1];
-    bar -= [4, 5, 6];
+    let mut bar = [1, 2, 3]/~;
+    bar -= [3, 2, 1]/~;
+    bar -= [4, 5, 6]/~;
     
     io::println(#fmt("%?", bar));
 
     // okay
-    let mut bar = [1, 2, 3];
-    bar = bar.foo([3, 2, 1]);
-    bar = bar.foo([4, 5, 6]);
+    let mut bar = [1, 2, 3]/~;
+    bar = bar.foo([3, 2, 1]/~);
+    bar = bar.foo([4, 5, 6]/~);
 
     io::println(#fmt("%?", bar));
 
     // okay
-    let mut bar = [1, 2, 3];
-    bar = bar - [3, 2, 1];
-    bar = bar - [4, 5, 6];
+    let mut bar = [1, 2, 3]/~;
+    bar = bar - [3, 2, 1]/~;
+    bar = bar - [4, 5, 6]/~;
 
     io::println(#fmt("%?", bar));
 
diff --git a/src/test/run-pass/option-ext.rs b/src/test/run-pass/option-ext.rs
index cb6b63059f4..cde7d73e720 100644
--- a/src/test/run-pass/option-ext.rs
+++ b/src/test/run-pass/option-ext.rs
@@ -1,4 +1,4 @@
-fn main(args: [str]) {
+fn main(args: [str]/~) {
     let thing = "{{ f }}";
     let f = str::find_str(thing, "{{");
 
diff --git a/src/test/run-pass/path.rs b/src/test/run-pass/path.rs
index 4fe43d18121..96a7a7229b6 100644
--- a/src/test/run-pass/path.rs
+++ b/src/test/run-pass/path.rs
@@ -4,4 +4,4 @@ mod foo {
     fn bar(offset: uint) { }
 }
 
-fn main(args: [str]) { foo::bar(0u); }
+fn main(args: [str]/~) { foo::bar(0u); }
diff --git a/src/test/run-pass/pure-sum.rs b/src/test/run-pass/pure-sum.rs
index f5bc71d94b0..823f6751c23 100644
--- a/src/test/run-pass/pure-sum.rs
+++ b/src/test/run-pass/pure-sum.rs
@@ -1,6 +1,6 @@
 // Check that pure functions can modify local state.
 
-pure fn sums_to(v: [int], sum: int) -> bool {
+pure fn sums_to(v: [int]/~, sum: int) -> bool {
     let mut i = 0u, sum0 = 0;
     while i < v.len() {
         sum0 += v[i];
@@ -9,7 +9,7 @@ pure fn sums_to(v: [int], sum: int) -> bool {
     ret sum0 == sum;
 }
 
-pure fn sums_to_using_uniq(v: [int], sum: int) -> bool {
+pure fn sums_to_using_uniq(v: [int]/~, sum: int) -> bool {
     let mut i = 0u, sum0 = ~mut 0;
     while i < v.len() {
         *sum0 += v[i];
@@ -18,7 +18,7 @@ pure fn sums_to_using_uniq(v: [int], sum: int) -> bool {
     ret *sum0 == sum;
 }
 
-pure fn sums_to_using_rec(v: [int], sum: int) -> bool {
+pure fn sums_to_using_rec(v: [int]/~, sum: int) -> bool {
     let mut i = 0u, sum0 = {f: 0};
     while i < v.len() {
         sum0.f += v[i];
@@ -27,7 +27,7 @@ pure fn sums_to_using_rec(v: [int], sum: int) -> bool {
     ret sum0.f == sum;
 }
 
-pure fn sums_to_using_uniq_rec(v: [int], sum: int) -> bool {
+pure fn sums_to_using_uniq_rec(v: [int]/~, sum: int) -> bool {
     let mut i = 0u, sum0 = {f: ~mut 0};
     while i < v.len() {
         *sum0.f += v[i];
diff --git a/src/test/run-pass/rcvr-borrowed-to-slice.rs b/src/test/run-pass/rcvr-borrowed-to-slice.rs
index 38f9f685050..6718de9d9d6 100644
--- a/src/test/run-pass/rcvr-borrowed-to-slice.rs
+++ b/src/test/run-pass/rcvr-borrowed-to-slice.rs
@@ -10,17 +10,17 @@ impl foo/& for [int]/& {
 fn call_sum(x: [int]/&) -> int { x.sum() }
 
 fn main() {
-    let x = [1, 2, 3];
+    let x = [1, 2, 3]/~;
     let y = call_sum(x);
     #debug["y==%d", y];
     assert y == 6;
 
-    let x = [mut 1, 2, 3];
+    let x = [mut 1, 2, 3]/~;
     let y = x.sum();
     #debug["y==%d", y];
     assert y == 6;
 
-    let x = [1, 2, 3];
+    let x = [1, 2, 3]/~;
     let y = x.sum();
     #debug["y==%d", y];
     assert y == 6;
diff --git a/src/test/run-pass/reflect-visit-data.rs b/src/test/run-pass/reflect-visit-data.rs
index 391acdaa9a2..d0818bda7c4 100644
--- a/src/test/run-pass/reflect-visit-data.rs
+++ b/src/test/run-pass/reflect-visit-data.rs
@@ -250,14 +250,14 @@ impl ptr_visitor<V: ty_visitor movable_ptr>
     }
 
     fn visit_enter_vec(mtbl: uint) -> bool {
-        self.align_to::<[u8]>();
+        self.align_to::<[u8]/~>();
         if ! self.inner.visit_enter_vec(mtbl) { ret false; }
         true
     }
 
     fn visit_leave_vec(mtbl: uint) -> bool {
         if ! self.inner.visit_leave_vec(mtbl) { ret false; }
-        self.bump_past::<[u8]>();
+        self.bump_past::<[u8]/~>();
         true
     }
 
@@ -547,7 +547,7 @@ impl ptr_visitor<V: ty_visitor movable_ptr>
 enum my_visitor = @{
     mut ptr1: *c_void,
     mut ptr2: *c_void,
-    mut vals: [str]
+    mut vals: [str]/~
 };
 
 impl extra_methods for my_visitor {
@@ -572,7 +572,7 @@ impl of ty_visitor for my_visitor {
     fn visit_bool() -> bool {
 /*
         self.get::<bool>() {|b|
-            self.vals += [bool::to_str(b)];
+            self.vals += [bool::to_str(b)]/~;
         }
 */
         true
@@ -580,7 +580,7 @@ impl of ty_visitor for my_visitor {
     fn visit_int() -> bool {
 /*
         self.get::<int>() {|i|
-            self.vals += [int::to_str(i, 10u)];
+            self.vals += [int::to_str(i, 10u)]/~;
         }
 */
         true
@@ -699,7 +699,7 @@ fn main() {
     let p = ptr::addr_of(r) as *c_void;
     let u = my_visitor(@{mut ptr1: p,
                          mut ptr2: p,
-                         mut vals: []});
+                         mut vals: []/~});
     let v = ptr_visit_adaptor({inner: u});
     let vv = v as intrinsic::ty_visitor;
     intrinsic::visit_ty::<(int,int,int,bool,bool)>(vv);
diff --git a/src/test/run-pass/reflect-visit-type.rs b/src/test/run-pass/reflect-visit-type.rs
index 8e90e438068..33f5115df5f 100644
--- a/src/test/run-pass/reflect-visit-type.rs
+++ b/src/test/run-pass/reflect-visit-type.rs
@@ -1,7 +1,7 @@
 // FIXME: un-xfail after snapshot
 // xfail-test
 
-enum my_visitor = @{ mut types: [str] };
+enum my_visitor = @{ mut types: [str]/~ };
 
 impl of intrinsic::ty_visitor for my_visitor {
     fn visit_bot() -> bool {
@@ -139,14 +139,14 @@ impl of intrinsic::ty_visitor for my_visitor {
 }
 
 fn main() {
-    let v = my_visitor(@{mut types: []});
+    let v = my_visitor(@{mut types: []/~});
     let vv = v as intrinsic::ty_visitor;
 
     intrinsic::visit_ty::<bool>(vv);
     intrinsic::visit_ty::<int>(vv);
     intrinsic::visit_ty::<i8>(vv);
     intrinsic::visit_ty::<i16>(vv);
-    intrinsic::visit_ty::<[int]>(vv);
+    intrinsic::visit_ty::<[int]/~>(vv);
 
     for (copy v.types).each {|s|
         io::println(#fmt("type: %s", s));
diff --git a/src/test/run-pass/regions-borrow-evec-uniq.rs b/src/test/run-pass/regions-borrow-evec-uniq.rs
index 3cfcd015dde..8ee9dc7f958 100644
--- a/src/test/run-pass/regions-borrow-evec-uniq.rs
+++ b/src/test/run-pass/regions-borrow-evec-uniq.rs
@@ -7,7 +7,7 @@ fn main() {
     let r = foo(p);
     assert r == 1;
 
-    let p = [5,4,3,2,1];
+    let p = [5,4,3,2,1]/~;
     let r = foo(p);
     assert r == 5;
 }
diff --git a/src/test/run-pass/ret-break-cont-in-block.rs b/src/test/run-pass/ret-break-cont-in-block.rs
index e93ce8a32e9..94d78b5f556 100644
--- a/src/test/run-pass/ret-break-cont-in-block.rs
+++ b/src/test/run-pass/ret-break-cont-in-block.rs
@@ -1,4 +1,4 @@
-fn iter<T>(v: [T], it: fn(T) -> bool) {
+fn iter<T>(v: [T]/~, it: fn(T) -> bool) {
     let mut i = 0u, l = v.len();
     while i < l {
         if !it(v[i]) { break; }
@@ -6,7 +6,7 @@ fn iter<T>(v: [T], it: fn(T) -> bool) {
     }
 }
 
-fn find_pos<T>(n: T, h: [T]) -> option<uint> {
+fn find_pos<T>(n: T, h: [T]/~) -> option<uint> {
     let mut i = 0u;
     for iter(h) {|e|
         if e == n { ret some(i); }
@@ -15,7 +15,7 @@ fn find_pos<T>(n: T, h: [T]) -> option<uint> {
     none
 }
 
-fn bail_deep(x: [[bool]]) {
+fn bail_deep(x: [[bool]/~]/~) {
     let mut seen = false;
     for iter(x) {|x|
         for iter(x) {|x|
@@ -27,8 +27,8 @@ fn bail_deep(x: [[bool]]) {
 }
 
 fn ret_deep() -> str {
-    for iter([1, 2]) {|e|
-        for iter([3, 4]) {|x|
+    for iter([1, 2]/~) {|e|
+        for iter([3, 4]/~) {|x|
             if e + x > 4 { ret "hi"; }
         }
     }
@@ -37,7 +37,7 @@ fn ret_deep() -> str {
 
 fn main() {
     let mut last = 0;
-    for vec::all([1, 2, 3, 4, 5, 6, 7]) {|e|
+    for vec::all([1, 2, 3, 4, 5, 6, 7]/~) {|e|
         last = e;
         if e == 5 { break; }
         if e % 2 == 1 { cont; }
@@ -45,13 +45,13 @@ fn main() {
     };
     assert last == 5;
 
-    assert find_pos(1, [0, 1, 2, 3]) == some(1u);
-    assert find_pos(1, [0, 4, 2, 3]) == none;
+    assert find_pos(1, [0, 1, 2, 3]/~) == some(1u);
+    assert find_pos(1, [0, 4, 2, 3]/~) == none;
     assert find_pos("hi", ["foo", "bar", "baz", "hi"]) == some(3u);
 
-    bail_deep([[false, false], [true, true], [false, true]]);
-    bail_deep([[true]]);
-    bail_deep([[false, false, false]]);
+    bail_deep([[false, false]/~, [true, true]/~, [false, true]/~]/~);
+    bail_deep([[true]/~]/~);
+    bail_deep([[false, false, false]/~]/~);
 
     assert ret_deep() == "hi";
 }
diff --git a/src/test/run-pass/sendfn-deep-copy.rs b/src/test/run-pass/sendfn-deep-copy.rs
index 96e06e65c70..a5fd483e3f8 100644
--- a/src/test/run-pass/sendfn-deep-copy.rs
+++ b/src/test/run-pass/sendfn-deep-copy.rs
@@ -8,7 +8,7 @@ fn main() { test05(); }
 fn mk_counter<A:copy>() -> fn~(A) -> (A,uint) {
     // The only reason that the counter is generic is so that it closes
     // over both a type descriptor and some data.
-    let v = [mut 0u];
+    let v = [mut 0u]/~;
     ret fn~(a: A) -> (A,uint) {
         let n = v[0];
         v[0] = n + 1u;
diff --git a/src/test/run-pass/seq-compare.rs b/src/test/run-pass/seq-compare.rs
index 79a318eefd2..423d755076f 100644
--- a/src/test/run-pass/seq-compare.rs
+++ b/src/test/run-pass/seq-compare.rs
@@ -4,13 +4,13 @@ fn main() {
     assert ("hello" < "hellr");
     assert ("hello " > "hello");
     assert ("hello" != "there");
-    assert ([1, 2, 3, 4] > [1, 2, 3]);
-    assert ([1, 2, 3] < [1, 2, 3, 4]);
-    assert ([1, 2, 4, 4] > [1, 2, 3, 4]);
-    assert ([1, 2, 3, 4] < [1, 2, 4, 4]);
-    assert ([1, 2, 3] <= [1, 2, 3]);
-    assert ([1, 2, 3] <= [1, 2, 3, 3]);
-    assert ([1, 2, 3, 4] > [1, 2, 3]);
-    assert ([1, 2, 3] == [1, 2, 3]);
-    assert ([1, 2, 3] != [1, 1, 3]);
+    assert ([1, 2, 3, 4]/~ > [1, 2, 3]/~);
+    assert ([1, 2, 3]/~ < [1, 2, 3, 4]/~);
+    assert ([1, 2, 4, 4]/~ > [1, 2, 3, 4]/~);
+    assert ([1, 2, 3, 4]/~ < [1, 2, 4, 4]/~);
+    assert ([1, 2, 3]/~ <= [1, 2, 3]/~);
+    assert ([1, 2, 3]/~ <= [1, 2, 3, 3]/~);
+    assert ([1, 2, 3, 4]/~ > [1, 2, 3]/~);
+    assert ([1, 2, 3]/~ == [1, 2, 3]/~);
+    assert ([1, 2, 3]/~ != [1, 1, 3]/~);
 }
diff --git a/src/test/run-pass/shadow.rs b/src/test/run-pass/shadow.rs
index 5ec60b38c10..11ee08d3c2e 100644
--- a/src/test/run-pass/shadow.rs
+++ b/src/test/run-pass/shadow.rs
@@ -1,7 +1,7 @@
 // -*- rust -*-
-fn foo(c: [int]) {
+fn foo(c: [int]/~) {
     let a: int = 5;
-    let mut b: [int] = [];
+    let mut b: [int]/~ = []/~;
 
 
     alt none::<int> {
@@ -9,7 +9,7 @@ fn foo(c: [int]) {
         for c.each {|i|
             log(debug, a);
             let a = 17;
-            b += [a];
+            b += [a]/~;
         }
       }
       _ { }
@@ -18,4 +18,4 @@ fn foo(c: [int]) {
 
 enum t<T> { none, some(T), }
 
-fn main() { let x = 10; let x = x + 20; assert (x == 30); foo([]); }
+fn main() { let x = 10; let x = x + 20; assert (x == 30); foo([]/~); }
diff --git a/src/test/run-pass/shape_intrinsic_tag_then_rec.rs b/src/test/run-pass/shape_intrinsic_tag_then_rec.rs
index 65b793564ad..3a40b378f14 100644
--- a/src/test/run-pass/shape_intrinsic_tag_then_rec.rs
+++ b/src/test/run-pass/shape_intrinsic_tag_then_rec.rs
@@ -16,7 +16,7 @@ enum opt_span {
 type span = {lo: uint, hi: uint, expanded_from: opt_span};
 type spanned<T> = { data: T, span: span };
 type ty_ = uint;
-type path_ = { global: bool, idents: [str], types: [@ty] };
+type path_ = { global: bool, idents: [str]/~, types: [@ty]/~ };
 type path = spanned<path_>;
 type ty = spanned<ty_>;
 
diff --git a/src/test/run-pass/size-and-align.rs b/src/test/run-pass/size-and-align.rs
index ce70efa318e..3617546d0fc 100644
--- a/src/test/run-pass/size-and-align.rs
+++ b/src/test/run-pass/size-and-align.rs
@@ -4,7 +4,7 @@
 // -*- rust -*-
 enum clam<T> { a(T, int), b, }
 
-fn uhoh<T>(v: [clam<T>]) {
+fn uhoh<T>(v: [clam<T>]/~) {
     alt v[1] {
       a::<T>(t, u) { #debug("incorrect"); log(debug, u); fail; }
       b::<T> { #debug("correct"); }
@@ -12,6 +12,6 @@ fn uhoh<T>(v: [clam<T>]) {
 }
 
 fn main() {
-    let v: [clam<int>] = [b::<int>, b::<int>, a::<int>(42, 17)];
+    let v: [clam<int>]/~ = [b::<int>, b::<int>, a::<int>(42, 17)]/~;
     uhoh::<int>(v);
 }
diff --git a/src/test/run-pass/static-impl.rs b/src/test/run-pass/static-impl.rs
index 10a67b9217c..edceedae71d 100644
--- a/src/test/run-pass/static-impl.rs
+++ b/src/test/run-pass/static-impl.rs
@@ -17,12 +17,12 @@ impl util for uint {
     }
 }
 
-impl util<T> for [T] {
+impl util<T> for [T]/~ {
     fn length_() -> uint { vec::len(self) }
     fn iter_(f: fn(T)) { for self.each {|x| f(x); } }
-    fn map_<U>(f: fn(T) -> U) -> [U] {
-        let mut r = [];
-        for self.each {|elt| r += [f(elt)]; }
+    fn map_<U>(f: fn(T) -> U) -> [U]/~ {
+        let mut r = []/~;
+        for self.each {|elt| r += [f(elt)]/~; }
         r
     }
 }
@@ -33,9 +33,9 @@ fn main() {
     assert 10u.plus() == 30;
     assert "hi".plus() == 200;
 
-    assert [1].length_().str() == "1";
-    assert [3, 4].map_({|a| a + 4})[0] == 7;
-    assert [3, 4].map_::<uint>({|a| a as uint + 4u})[0] == 7u;
+    assert [1]/~.length_().str() == "1";
+    assert [3, 4]/~.map_({|a| a + 4})[0] == 7;
+    assert [3, 4]/~.map_::<uint>({|a| a as uint + 4u})[0] == 7u;
     let mut x = 0u;
     10u.times {|_n| x += 2u;}
     assert x == 20u;
diff --git a/src/test/run-pass/swap-2.rs b/src/test/run-pass/swap-2.rs
index f94205f4a9f..a70ffba452e 100644
--- a/src/test/run-pass/swap-2.rs
+++ b/src/test/run-pass/swap-2.rs
@@ -1,7 +1,7 @@
 fn swap<T>(v: [mut T], i: int, j: int) { v[i] <-> v[j]; }
 
 fn main() {
-    let a: [mut int] = [mut 0, 1, 2, 3, 4, 5, 6];
+    let a: [mut int]/~ = [mut 0, 1, 2, 3, 4, 5, 6]/~;
     swap(a, 2, 4);
     assert (a[2] == 4);
     assert (a[4] == 2);
diff --git a/src/test/run-pass/tag-in-block.rs b/src/test/run-pass/tag-in-block.rs
index c08d440874d..5d3088cc8ae 100644
--- a/src/test/run-pass/tag-in-block.rs
+++ b/src/test/run-pass/tag-in-block.rs
@@ -6,4 +6,4 @@ fn foo() {
     fn baz() { zed(nil); }
 }
 
-fn main(args: [str]) { }
+fn main(args: [str]/~) { }
diff --git a/src/test/run-pass/task-comm-16.rs b/src/test/run-pass/task-comm-16.rs
index d250b311ccc..5c7b8c7b282 100644
--- a/src/test/run-pass/task-comm-16.rs
+++ b/src/test/run-pass/task-comm-16.rs
@@ -25,7 +25,7 @@ fn test_rec() {
 fn test_vec() {
     let po = port();
     let ch = chan(po);
-    let v0: [int] = [0, 1, 2];
+    let v0: [int]/~ = [0, 1, 2]/~;
     send(ch, v0);
     let v1 = recv(po);
     assert (v1[0] == 0);
diff --git a/src/test/run-pass/task-comm-3.rs b/src/test/run-pass/task-comm-3.rs
index 8364c3a3fd0..17cd1a1ce93 100644
--- a/src/test/run-pass/task-comm-3.rs
+++ b/src/test/run-pass/task-comm-3.rs
@@ -30,10 +30,10 @@ fn test00() {
     let mut i: int = 0;
 
     // Create and spawn tasks...
-    let mut results = [];
+    let mut results = []/~;
     while i < number_of_tasks {
         let builder = task::builder();
-        results += [task::future_result(builder)];
+        results += [task::future_result(builder)]/~;
         task::run(builder) {|copy i|
             test00_start(ch, i, number_of_messages)
         }
diff --git a/src/test/run-pass/task-comm.rs b/src/test/run-pass/task-comm.rs
index 9118075c642..97c2a8643ad 100644
--- a/src/test/run-pass/task-comm.rs
+++ b/src/test/run-pass/task-comm.rs
@@ -38,11 +38,11 @@ fn test00() {
 
     let mut i: int = 0;
 
-    let mut results = [];
+    let mut results = []/~;
     while i < number_of_tasks {
         i = i + 1;
         let builder = task::builder();
-        results += [task::future_result(builder)];
+        results += [task::future_result(builder)]/~;
         task::run(builder) {|copy i|
             test00_start(ch, i, number_of_messages);
         }
@@ -125,11 +125,11 @@ fn test06() {
 
     let mut i: int = 0;
 
-    let mut results = [];
+    let mut results = []/~;
     while i < number_of_tasks {
         i = i + 1;
         let builder = task::builder();
-        results += [task::future_result(builder)];
+        results += [task::future_result(builder)]/~;
         task::run(builder) {|copy i|
             test06_start(i);
         };
diff --git a/src/test/run-pass/task-killjoin-rsrc.rs b/src/test/run-pass/task-killjoin-rsrc.rs
index 0696d176147..6dd5827836e 100644
--- a/src/test/run-pass/task-killjoin-rsrc.rs
+++ b/src/test/run-pass/task-killjoin-rsrc.rs
@@ -14,7 +14,7 @@ class notify {
                task::get_task(),
                ptr::addr_of(*(self.v)) as uint,
                task::failing(),
-               *(self.v)];
+               *(self.v)]/~;
         let b = *(self.v);
         comm::send(self.ch, b);
     }
@@ -26,7 +26,7 @@ fn joinable(f: fn~()) -> comm::port<bool> {
         let b = @mut false;
         #error["wrapper: task=%? allocated v=%x",
                task::get_task(),
-               ptr::addr_of(*b) as uint];
+               ptr::addr_of(*b) as uint]/~;
         let _r = notify(c, b);
         f();
         *b = true;
diff --git a/src/test/run-pass/type-param.rs b/src/test/run-pass/type-param.rs
index 8d4bccc11ff..68be7c56d4b 100644
--- a/src/test/run-pass/type-param.rs
+++ b/src/test/run-pass/type-param.rs
@@ -2,4 +2,4 @@
 
 type lteq<T> = native fn(T) -> bool;
 
-fn main(args: [str]) { }
+fn main(args: [str]/~) { }
diff --git a/src/test/run-pass/type-params-in-for-each.rs b/src/test/run-pass/type-params-in-for-each.rs
index 3e84e341733..9173e258003 100644
--- a/src/test/run-pass/type-params-in-for-each.rs
+++ b/src/test/run-pass/type-params-in-for-each.rs
@@ -5,8 +5,8 @@ fn range(lo: uint, hi: uint, it: fn(uint)) {
     while lo_ < hi { it(lo_); lo_ += 1u; }
 }
 
-fn create_index<T>(index: [{a: T, b: uint}], hash_fn: native fn(T) -> uint) {
-    range(0u, 256u) {|_i| let bucket: [T] = []; }
+fn create_index<T>(index: [{a: T, b: uint}]/~, hash_fn: native fn(T) -> uint) {
+    range(0u, 256u) {|_i| let bucket: [T]/~ = []/~; }
 }
 
 fn main() { }
diff --git a/src/test/run-pass/type-ptr.rs b/src/test/run-pass/type-ptr.rs
index e608a9f9836..9569954ebe6 100644
--- a/src/test/run-pass/type-ptr.rs
+++ b/src/test/run-pass/type-ptr.rs
@@ -2,4 +2,4 @@ fn f(a: *int) -> *int { ret a; }
 
 fn g(a: *int) -> *int { let b = f(a); ret b; }
 
-fn main(args: [str]) { ret; }
+fn main(args: [str]/~) { ret; }
diff --git a/src/test/run-pass/unique-assign-generic.rs b/src/test/run-pass/unique-assign-generic.rs
index ba8b4bb5723..230aa21cb90 100644
--- a/src/test/run-pass/unique-assign-generic.rs
+++ b/src/test/run-pass/unique-assign-generic.rs
@@ -6,6 +6,6 @@ fn f<T: copy>(t: T) -> T {
 fn main() {
     let t = f(~100);
     assert t == ~100;
-    let t = f(~@[100]);
-    assert t == ~@[100];
+    let t = f(~@[100]/~);
+    assert t == ~@[100]/~;
 }
diff --git a/src/test/run-pass/unique-autoderef-index.rs b/src/test/run-pass/unique-autoderef-index.rs
index 6b978fc1506..43d894ed3ac 100644
--- a/src/test/run-pass/unique-autoderef-index.rs
+++ b/src/test/run-pass/unique-autoderef-index.rs
@@ -1,4 +1,4 @@
 fn main() {
-    let i = ~[100];
+    let i = ~[100]/~;
     assert i[0] == 100;
 }
\ No newline at end of file
diff --git a/src/test/run-pass/unique-create.rs b/src/test/run-pass/unique-create.rs
index c46cf29ba5d..24714a94873 100644
--- a/src/test/run-pass/unique-create.rs
+++ b/src/test/run-pass/unique-create.rs
@@ -3,5 +3,5 @@ fn main() {
 }
 
 fn vec() {
-    [0];
+    [0]/~;
 }
\ No newline at end of file
diff --git a/src/test/run-pass/unique-drop-complex.rs b/src/test/run-pass/unique-drop-complex.rs
index 23048eb7868..6ae3224ccfc 100644
--- a/src/test/run-pass/unique-drop-complex.rs
+++ b/src/test/run-pass/unique-drop-complex.rs
@@ -1,3 +1,3 @@
 fn main() {
-    let x = ~[0,0,0,0,0];
+    let x = ~[0,0,0,0,0]/~;
 }
\ No newline at end of file
diff --git a/src/test/run-pass/unique-in-vec-copy.rs b/src/test/run-pass/unique-in-vec-copy.rs
index 1a9eb581c24..ed9ffd26ae8 100644
--- a/src/test/run-pass/unique-in-vec-copy.rs
+++ b/src/test/run-pass/unique-in-vec-copy.rs
@@ -1,5 +1,5 @@
 fn main() {
-    let a = [~mut 10];
+    let a = [~mut 10]/~;
     let b = a;
 
     assert *a[0] == 10;
diff --git a/src/test/run-pass/unique-in-vec.rs b/src/test/run-pass/unique-in-vec.rs
index 0f5bbce050f..62391debea2 100644
--- a/src/test/run-pass/unique-in-vec.rs
+++ b/src/test/run-pass/unique-in-vec.rs
@@ -1,3 +1,3 @@
 fn main() {
-    assert [~100][0] == ~100;
-}
\ No newline at end of file
+    assert ([~100]/~)[0] == ~100;
+}
diff --git a/src/test/run-pass/utf8_chars.rs b/src/test/run-pass/utf8_chars.rs
index 99842f2ebc7..99c6a0cc510 100644
--- a/src/test/run-pass/utf8_chars.rs
+++ b/src/test/run-pass/utf8_chars.rs
@@ -4,7 +4,7 @@ import vec;
 
 fn main() {
     // Chars of 1, 2, 3, and 4 bytes
-    let chs: [char] = ['e', 'é', '€', 0x10000 as char];
+    let chs: [char]/~ = ['e', 'é', '€', 0x10000 as char]/~;
     let s: str = str::from_chars(chs);
 
     assert (str::len(s) == 10u);
@@ -15,9 +15,9 @@ fn main() {
     assert (str::char_at(s, 1u) == 'é');
 
     assert (str::is_utf8(str::bytes(s)));
-    assert (!str::is_utf8([0x80_u8]));
-    assert (!str::is_utf8([0xc0_u8]));
-    assert (!str::is_utf8([0xc0_u8, 0x10_u8]));
+    assert (!str::is_utf8([0x80_u8]/~));
+    assert (!str::is_utf8([0xc0_u8]/~));
+    assert (!str::is_utf8([0xc0_u8, 0x10_u8]/~));
 
     let mut stack = "a×c€";
     assert (str::pop_char(stack) == '€');
diff --git a/src/test/run-pass/vec-concat.rs b/src/test/run-pass/vec-concat.rs
index 3a5a1916d64..6aa5f5ef424 100644
--- a/src/test/run-pass/vec-concat.rs
+++ b/src/test/run-pass/vec-concat.rs
@@ -1,8 +1,8 @@
 // -*- rust -*-
 fn main() {
-    let a: [int] = [1, 2, 3, 4, 5];
-    let b: [int] = [6, 7, 8, 9, 0];
-    let v: [int] = a + b;
+    let a: [int]/~ = [1, 2, 3, 4, 5]/~;
+    let b: [int]/~ = [6, 7, 8, 9, 0]/~;
+    let v: [int]/~ = a + b;
     log(debug, v[9]);
     assert (v[0] == 1);
     assert (v[7] == 8);
diff --git a/src/test/run-pass/vec-drop.rs b/src/test/run-pass/vec-drop.rs
index 499b24d43f0..9b75d0c2155 100644
--- a/src/test/run-pass/vec-drop.rs
+++ b/src/test/run-pass/vec-drop.rs
@@ -3,6 +3,6 @@
 fn main() {
     // This just tests whether the vec leaks its members.
 
-    let pvec: [@{x: int, y: int}] =
-        [@{x: 1, y: 2}, @{x: 3, y: 4}, @{x: 5, y: 6}];
+    let pvec: [@{x: int, y: int}]/~ =
+        [@{x: 1, y: 2}, @{x: 3, y: 4}, @{x: 5, y: 6}]/~;
 }
diff --git a/src/test/run-pass/vec-growth.rs b/src/test/run-pass/vec-growth.rs
index 343004c81c2..b6c4aa3659f 100644
--- a/src/test/run-pass/vec-growth.rs
+++ b/src/test/run-pass/vec-growth.rs
@@ -1,11 +1,11 @@
 
 
 fn main() {
-    let mut v = [1];
-    v += [2];
-    v += [3];
-    v += [4];
-    v += [5];
+    let mut v = [1]/~;
+    v += [2]/~;
+    v += [3]/~;
+    v += [4]/~;
+    v += [5]/~;
     assert (v[0] == 1);
     assert (v[1] == 2);
     assert (v[2] == 3);
diff --git a/src/test/run-pass/vec-ivec-deadlock.rs b/src/test/run-pass/vec-ivec-deadlock.rs
index a2571b57b7a..4fb7eb8f7f5 100644
--- a/src/test/run-pass/vec-ivec-deadlock.rs
+++ b/src/test/run-pass/vec-ivec-deadlock.rs
@@ -1 +1 @@
-fn main() { let a = [1, 2, 3, 4, 5]; let mut b = [a, a]; b += b; }
+fn main() { let a = [1, 2, 3, 4, 5]/~; let mut b = [a, a]/~; b += b; }
diff --git a/src/test/run-pass/vec-late-init.rs b/src/test/run-pass/vec-late-init.rs
index 9b97ed092cd..6f5efa0bd01 100644
--- a/src/test/run-pass/vec-late-init.rs
+++ b/src/test/run-pass/vec-late-init.rs
@@ -1,7 +1,7 @@
 
 
 fn main() {
-    let mut later: [int];
-    if true { later = [1]; } else { later = [2]; }
+    let mut later: [int]/~;
+    if true { later = [1]/~; } else { later = [2]/~; }
     log(debug, later[0]);
 }
diff --git a/src/test/run-pass/vec-push.rs b/src/test/run-pass/vec-push.rs
index 15b9239c44b..2505b7141b1 100644
--- a/src/test/run-pass/vec-push.rs
+++ b/src/test/run-pass/vec-push.rs
@@ -1 +1 @@
-fn main() { let mut v = [1, 2, 3]; vec::push(v, 1); }
+fn main() { let mut v = [1, 2, 3]/~; vec::push(v, 1); }
diff --git a/src/test/run-pass/vec-self-append.rs b/src/test/run-pass/vec-self-append.rs
index e9e6cce4a87..c897a327a5e 100644
--- a/src/test/run-pass/vec-self-append.rs
+++ b/src/test/run-pass/vec-self-append.rs
@@ -3,7 +3,7 @@ import vec;
 
 fn test_heap_to_heap() {
     // a spills onto the heap
-    let mut a = [0, 1, 2, 3, 4];
+    let mut a = [0, 1, 2, 3, 4]/~;
     a += a;
     assert (vec::len(a) == 10u);
     assert (a[0] == 0);
@@ -20,7 +20,7 @@ fn test_heap_to_heap() {
 
 fn test_stack_to_heap() {
     // a is entirely on the stack
-    let mut a = [0, 1, 2];
+    let mut a = [0, 1, 2]/~;
     // a spills to the heap
     a += a;
     assert (vec::len(a) == 6u);
@@ -34,7 +34,7 @@ fn test_stack_to_heap() {
 
 fn test_loop() {
     // Make sure we properly handle repeated self-appends.
-    let mut a: [int] = [0];
+    let mut a: [int]/~ = [0]/~;
     let mut i = 20;
     let mut expected_len = 1u;
     while i > 0 {
diff --git a/src/test/run-pass/vec-slice.rs b/src/test/run-pass/vec-slice.rs
index b8ec6563a96..e1961d59b39 100644
--- a/src/test/run-pass/vec-slice.rs
+++ b/src/test/run-pass/vec-slice.rs
@@ -1,5 +1,5 @@
 fn main() {
-    let  v = [1,2,3,4,5];
+    let  v = [1,2,3,4,5]/~;
     let v2 = vec::slice(v, 1, 3);
     assert (v2[0] == 2);
     assert (v2[1] == 3);
diff --git a/src/test/run-pass/vec-trailing-comma.rs b/src/test/run-pass/vec-trailing-comma.rs
index 473ffe9f11d..b0dac0abd7e 100644
--- a/src/test/run-pass/vec-trailing-comma.rs
+++ b/src/test/run-pass/vec-trailing-comma.rs
@@ -1,10 +1,10 @@
 // Issue #2482.
 
 fn main() {
-    let v1: [int] = [10, 20, 30,];
-    let v2: [int] = [10, 20, 30];
+    let v1: [int]/~ = [10, 20, 30,]/~;
+    let v2: [int]/~ = [10, 20, 30]/~;
     assert (v1[2] == v2[2]);
-    let v3: [int] = [10,];
-    let v4: [int] = [10];
+    let v3: [int]/~ = [10,]/~;
+    let v4: [int]/~ = [10]/~;
     assert (v3[0] == v4[0]);
 }
diff --git a/src/test/run-pass/vec.rs b/src/test/run-pass/vec.rs
index f1cc97ab61a..cc70cd8cf8a 100644
--- a/src/test/run-pass/vec.rs
+++ b/src/test/run-pass/vec.rs
@@ -3,7 +3,7 @@
 
 // -*- rust -*-
 fn main() {
-    let v: [int] = [10, 20];
+    let v: [int]/~ = [10, 20]/~;
     assert (v[0] == 10);
     assert (v[1] == 20);
     let mut x: int = 0;
diff --git a/src/test/run-pass/vector-no-ann-2.rs b/src/test/run-pass/vector-no-ann-2.rs
index 10a9cd9c6b8..7e0e614c0df 100644
--- a/src/test/run-pass/vector-no-ann-2.rs
+++ b/src/test/run-pass/vector-no-ann-2.rs
@@ -1 +1 @@
-fn main() { let quux: @[uint] = @[]; }
+fn main() { let quux: @[uint]/~ = @[]/~; }
diff --git a/src/test/run-pass/while-with-break.rs b/src/test/run-pass/while-with-break.rs
index 24907f948dc..68c0779657e 100644
--- a/src/test/run-pass/while-with-break.rs
+++ b/src/test/run-pass/while-with-break.rs
@@ -8,8 +8,8 @@ fn main() {
         log(debug, i);
         i = i + 1;
         if i == 95 {
-            let v: [int] =
-                [1, 2, 3, 4, 5]; // we check that it is freed by break
+            let v: [int]/~ =
+                [1, 2, 3, 4, 5]/~; // we check that it is freed by break
 
             #debug("breaking");
             break;
diff --git a/src/test/run-pass/zip-same-length.rs b/src/test/run-pass/zip-same-length.rs
index ef095dca8e9..4c5c3343512 100644
--- a/src/test/run-pass/zip-same-length.rs
+++ b/src/test/run-pass/zip-same-length.rs
@@ -5,18 +5,18 @@ import uint;
 import u8;
 import vec::{head, is_not_empty, last, same_length, zip};
 
-fn enum_chars(start: u8, end: u8) -> [char] {
+fn enum_chars(start: u8, end: u8) -> [char]/~ {
     assert start < end;
     let mut i = start;
-    let mut r = [];
+    let mut r = []/~;
     while i <= end { vec::push(r, i as char); i += 1u as u8; }
     ret r;
 }
 
-fn enum_uints(start: uint, end: uint) -> [uint] {
+fn enum_uints(start: uint, end: uint) -> [uint]/~ {
     assert start < end;
     let mut i = start;
-    let mut r = [];
+    let mut r = []/~;
     while i <= end { vec::push(r, i); i += 1u; }
     ret r;
 }
author	Michael Sullivan <sully@msully.net>	2012-06-25 20:00:46 -0700
committer	Michael Sullivan <sully@msully.net>	2012-06-25 20:00:46 -0700
commit	329eca6044fdf376a7a89ec7a96dba7a8b884cf7 (patch)
tree	7008814278a066914b6ba36818388d5212ffda9f /src/test
parent	c087aaf56b1109163126fea4c2760f8414ffbe56 (diff)
download	rust-329eca6044fdf376a7a89ec7a96dba7a8b884cf7.tar.gz rust-329eca6044fdf376a7a89ec7a96dba7a8b884cf7.zip