Merge remote-tracking branch 'original/incoming' into incoming

Conflicts:
	src/libstd/json.rs
	src/libstd/sort.rs

105 files changed, 489 insertions, 267 deletions

diff --git a/src/test/auxiliary/cci_class.rs b/src/test/auxiliary/cci_class.rs
index 8f4055cd415..bb286f956bc 100644
--- a/src/test/auxiliary/cci_class.rs
+++ b/src/test/auxiliary/cci_class.rs
@@ -1,3 +1,4 @@
+#[legacy_exports];
 mod kitties {
     #[legacy_exports];
 
diff --git a/src/test/auxiliary/cci_class_2.rs b/src/test/auxiliary/cci_class_2.rs
index e572f41322c..186f021a81f 100644
--- a/src/test/auxiliary/cci_class_2.rs
+++ b/src/test/auxiliary/cci_class_2.rs
@@ -1,3 +1,5 @@
+#[legacy_exports];
+
 mod kitties {
     #[legacy_exports];
 
diff --git a/src/test/auxiliary/cci_class_3.rs b/src/test/auxiliary/cci_class_3.rs
index 79583a6134c..dbae452a8f9 100644
--- a/src/test/auxiliary/cci_class_3.rs
+++ b/src/test/auxiliary/cci_class_3.rs
@@ -1,3 +1,5 @@
+#[legacy_exports];
+
 mod kitties {
     #[legacy_exports];
 
diff --git a/src/test/auxiliary/cci_class_4.rs b/src/test/auxiliary/cci_class_4.rs
index 57c6f2f4b52..436f92e5e78 100644
--- a/src/test/auxiliary/cci_class_4.rs
+++ b/src/test/auxiliary/cci_class_4.rs
@@ -1,3 +1,4 @@
+#[legacy_exports];
 mod kitties {
     #[legacy_exports];
 
diff --git a/src/test/auxiliary/cci_class_6.rs b/src/test/auxiliary/cci_class_6.rs
index 72262781222..6cf86aff055 100644
--- a/src/test/auxiliary/cci_class_6.rs
+++ b/src/test/auxiliary/cci_class_6.rs
@@ -1,3 +1,5 @@
+#[legacy_exports];
+
 mod kitties {
     #[legacy_exports];
 
diff --git a/src/test/auxiliary/cci_class_cast.rs b/src/test/auxiliary/cci_class_cast.rs
index 550dfb6886a..288fe66dd20 100644
--- a/src/test/auxiliary/cci_class_cast.rs
+++ b/src/test/auxiliary/cci_class_cast.rs
@@ -1,3 +1,5 @@
+#[legacy_exports];
+
 use to_str::*;
 use to_str::ToStr;
 
diff --git a/src/test/auxiliary/crateresolve7x.rs b/src/test/auxiliary/crateresolve7x.rs
index 520a207345f..e7bf211d3f0 100644
--- a/src/test/auxiliary/crateresolve7x.rs
+++ b/src/test/auxiliary/crateresolve7x.rs
@@ -3,6 +3,7 @@
 // aux-build:crateresolve_calories-2.rs
 
 // These both have the same version but differ in other metadata
+#[legacy_exports];
 mod a {
     #[legacy_exports];
     extern mod cr_1 (name = "crateresolve_calories", vers = "0.1", calories="100");
diff --git a/src/test/auxiliary/foreign_lib.rs b/src/test/auxiliary/foreign_lib.rs
index 6ea28255421..bb6d425de34 100644
--- a/src/test/auxiliary/foreign_lib.rs
+++ b/src/test/auxiliary/foreign_lib.rs
@@ -1,4 +1,5 @@
 #[link(name="foreign_lib", vers="0.0")];
+#[legacy_exports];
 
 extern mod rustrt {
     #[legacy_exports];
diff --git a/src/test/auxiliary/issue-3012-1.rs b/src/test/auxiliary/issue-3012-1.rs
index a9d371321f8..d774669cd13 100644
--- a/src/test/auxiliary/issue-3012-1.rs
+++ b/src/test/auxiliary/issue-3012-1.rs
@@ -1,5 +1,6 @@
 #[link(name="socketlib", vers="0.0")];
 #[crate_type = "lib"];
+#[legacy_exports];
 
 mod socket {
     #[legacy_exports];
diff --git a/src/test/auxiliary/test_comm.rs b/src/test/auxiliary/test_comm.rs
index b150b58c638..77f107fda09 100644
--- a/src/test/auxiliary/test_comm.rs
+++ b/src/test/auxiliary/test_comm.rs
@@ -34,7 +34,7 @@ struct port_ptr<T:Send> {
     debug!("in the port_ptr destructor");
        do task::unkillable {
         let yield = 0u;
-        let yieldp = ptr::addr_of(yield);
+        let yieldp = ptr::addr_of(&yield);
         rustrt::rust_port_begin_detach(self.po, yieldp);
         if yield != 0u {
             task::yield();
@@ -66,10 +66,10 @@ fn recv<T: Send>(p: port<T>) -> T { recv_((**p).po) }
 /// Receive on a raw port pointer
 fn recv_<T: Send>(p: *rust_port) -> T {
     let yield = 0u;
-    let yieldp = ptr::addr_of(yield);
+    let yieldp = ptr::addr_of(&yield);
     let mut res;
     res = rusti::init::<T>();
-    rustrt::port_recv(ptr::addr_of(res) as *uint, p, yieldp);
+    rustrt::port_recv(ptr::addr_of(&res) as *uint, p, yieldp);
 
     if yield != 0u {
         // Data isn't available yet, so res has not been initialized.
diff --git a/src/test/bench/core-map.rs b/src/test/bench/core-map.rs
index 279905fe3f1..afd9b2ccc9c 100644
--- a/src/test/bench/core-map.rs
+++ b/src/test/bench/core-map.rs
@@ -154,7 +154,7 @@ fn main(++args: ~[~str]) {
     let seed = ~[1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
 
     {
-        let rng = rand::seeded_rng(copy seed);
+        let rng = rand::seeded_rng(&seed);
         let mut results = empty_results();
         int_benchmarks::<map::HashMap<uint, uint>>(
             map::HashMap, rng, num_keys, &mut results);
@@ -164,7 +164,7 @@ fn main(++args: ~[~str]) {
     }
 
     {
-        let rng = rand::seeded_rng(copy seed);
+        let rng = rand::seeded_rng(&seed);
         let mut results = empty_results();
         int_benchmarks::<@Mut<LinearMap<uint, uint>>>(
             || @Mut(LinearMap()),
diff --git a/src/test/bench/core-std.rs b/src/test/bench/core-std.rs
index a88793705a6..cf44d478356 100644
--- a/src/test/bench/core-std.rs
+++ b/src/test/bench/core-std.rs
@@ -30,7 +30,7 @@ fn maybe_run_test(argv: &[~str], name: ~str, test: fn()) {
 
     if os::getenv(~"RUST_BENCH").is_some() { run_test = true }
     else if argv.len() > 0 {
-        run_test = argv.contains(~"all") || argv.contains(name)
+        run_test = argv.contains(&~"all") || argv.contains(&name)
     }
 
     if !run_test { return }
@@ -47,7 +47,7 @@ fn shift_push() {
     let mut v2 = ~[];
 
     while v1.len() > 0 {
-        vec::push(v2, vec::shift(v1));
+        v2.push(v1.shift());
     }
 }
 
@@ -56,7 +56,7 @@ fn read_line() {
         .push_rel(&Path("src/test/bench/shootout-k-nucleotide.data"));
 
     for int::range(0, 3) |_i| {
-        let reader = result::get(io::file_reader(&path));
+        let reader = result::get(&io::file_reader(&path));
         while !reader.eof() {
             reader.read_line();
         }
@@ -122,11 +122,11 @@ fn vec_push_all() {
     for uint::range(0, 1500) |i| {
         let mut rv = vec::from_elem(r.gen_uint_range(0, i + 1), i);
         if r.gen_bool() {
-            vec::push_all(v, rv);
+            v.push_all(rv);
         }
         else {
             v <-> rv;
-            vec::push_all(v, rv);
+            v.push_all(rv);
         }
     }
 }
diff --git a/src/test/bench/core-vec-append.rs b/src/test/bench/core-vec-append.rs
index d708ac9eaa7..2b9216876b4 100644
--- a/src/test/bench/core-vec-append.rs
+++ b/src/test/bench/core-vec-append.rs
@@ -7,7 +7,7 @@ use io::WriterUtil;
 fn collect_raw(num: uint) -> ~[uint] {
     let mut result = ~[];
     for uint::range(0u, num) |i| {
-        vec::push(result, i);
+        result.push(i);
     }
     return result;
 }
diff --git a/src/test/bench/graph500-bfs.rs b/src/test/bench/graph500-bfs.rs
index 89ca8eadde4..a34fcc89c04 100644
--- a/src/test/bench/graph500-bfs.rs
+++ b/src/test/bench/graph500-bfs.rs
@@ -97,7 +97,7 @@ fn gen_search_keys(graph: graph, n: uint) -> ~[node_id] {
         let k = r.gen_uint_range(0u, graph.len());
 
         if graph[k].len() > 0u && vec::any(graph[k], |i| {
-            i != k as node_id
+            *i != k as node_id
         }) {
             map::set_add(keys, k as node_id);
         }
@@ -160,8 +160,8 @@ fn bfs2(graph: graph, key: node_id) -> bfs_result {
         }
     };
 
-    fn is_gray(c: color) -> bool {
-        match c {
+    fn is_gray(c: &color) -> bool {
+        match *c {
           gray(_) => { true }
           _ => { false }
         }
@@ -183,7 +183,7 @@ fn bfs2(graph: graph, key: node_id) -> bfs_result {
                 let mut color = white;
 
                 do neighbors.each() |k| {
-                    if is_gray(colors[*k]) {
+                    if is_gray(&colors[*k]) {
                         color = gray(*k);
                         false
                     }
@@ -231,18 +231,18 @@ fn pbfs(&&graph: arc::ARC<graph>, key: node_id) -> bfs_result {
     };
 
     #[inline(always)]
-    fn is_gray(c: color) -> bool {
-        match c {
+    fn is_gray(c: &color) -> bool {
+        match *c {
           gray(_) => { true }
           _ => { false }
         }
     }
 
-    let mut i = 0u;
+    let mut i = 0;
     while par::any(colors, is_gray) {
         // Do the BFS.
         log(info, fmt!("PBFS iteration %?", i));
-        i += 1u;
+        i += 1;
         let old_len = colors.len();
 
         let color = arc::ARC(colors);
@@ -251,7 +251,7 @@ fn pbfs(&&graph: arc::ARC<graph>, key: node_id) -> bfs_result {
         colors = do par::mapi_factory(*color_vec) {
             let colors = arc::clone(&color);
             let graph = arc::clone(&graph);
-            fn~(i: uint, c: color) -> color {
+            fn~(+i: uint, +c: color) -> color {
                 let c : color = c;
                 let colors = arc::get(&colors);
                 let graph = arc::get(&graph);
@@ -264,7 +264,7 @@ fn pbfs(&&graph: arc::ARC<graph>, key: node_id) -> bfs_result {
                     let mut color = white;
 
                     do neighbors.each() |k| {
-                        if is_gray(colors[*k]) {
+                        if is_gray(&colors[*k]) {
                             color = gray(*k);
                             false
                         }
@@ -282,7 +282,7 @@ fn pbfs(&&graph: arc::ARC<graph>, key: node_id) -> bfs_result {
 
     // Convert the results.
     do par::map(colors) |c| {
-        match c {
+        match *c {
           white => { -1i64 }
           black(parent) => { parent }
           _ => { fail ~"Found remaining gray nodes in BFS" }
@@ -314,11 +314,11 @@ fn validate(edges: ~[(node_id, node_id)],
         }
         else {
             while parent != root {
-                if vec::contains(path, parent) {
+                if vec::contains(path, &parent) {
                     status = false;
                 }
 
-                vec::push(path, parent);
+                path.push(parent);
                 parent = tree[parent];
             }
 
@@ -336,8 +336,8 @@ fn validate(edges: ~[(node_id, node_id)],
     log(info, ~"Verifying tree edges...");
 
     let status = do tree.alli() |k, parent| {
-        if parent != root && parent != -1i64 {
-            level[parent] == level[k] - 1
+        if *parent != root && *parent != -1i64 {
+            level[*parent] == level[k] - 1
         }
         else {
             true
@@ -352,7 +352,7 @@ fn validate(edges: ~[(node_id, node_id)],
     log(info, ~"Verifying graph edges...");
 
     let status = do edges.all() |e| {
-        let (u, v) = e;
+        let (u, v) = *e;
 
         abs(level[u] - level[v]) <= 1
     };
@@ -370,11 +370,11 @@ fn validate(edges: ~[(node_id, node_id)],
 
     let status = do par::alli(tree) |u, v| {
         let u = u as node_id;
-        if v == -1i64 || u == root {
+        if *v == -1i64 || u == root {
             true
         }
         else {
-            edges.contains((u, v)) || edges.contains((v, u))
+            edges.contains(&(u, *v)) || edges.contains(&(*v, u))
         }
     };
 
diff --git a/src/test/bench/msgsend-pipes-shared.rs b/src/test/bench/msgsend-pipes-shared.rs
index 89d339b7a76..0a55e7572db 100644
--- a/src/test/bench/msgsend-pipes-shared.rs
+++ b/src/test/bench/msgsend-pipes-shared.rs
@@ -19,7 +19,7 @@ use io::WriterUtil;
 use pipes::{Port, Chan, SharedChan};
 
 macro_rules! move_out (
-    { $x:expr } => { unsafe { let y <- *ptr::addr_of($x); y } }
+    { $x:expr } => { unsafe { let y <- *ptr::addr_of(&($x)); y } }
 )
 
 enum request {
@@ -60,7 +60,7 @@ fn run(args: &[~str]) {
     for uint::range(0u, workers) |i| {
         let to_child = to_child.clone();
         do task::task().future_result(|+r| {
-            vec::push(worker_results, r);
+            worker_results.push(r);
         }).spawn {
             for uint::range(0u, size / workers) |_i| {
                 //error!("worker %?: sending %? bytes", i, num_bytes);
diff --git a/src/test/bench/msgsend-pipes.rs b/src/test/bench/msgsend-pipes.rs
index babc97694a5..ab67a8c7cb1 100644
--- a/src/test/bench/msgsend-pipes.rs
+++ b/src/test/bench/msgsend-pipes.rs
@@ -15,7 +15,7 @@ use io::WriterUtil;
 use pipes::{Port, PortSet, Chan};
 
 macro_rules! move_out (
-    { $x:expr } => { unsafe { let y <- *ptr::addr_of($x); y } }
+    { $x:expr } => { unsafe { let y <- *ptr::addr_of(&($x)); y } }
 )
 
 enum request {
@@ -57,7 +57,7 @@ fn run(args: &[~str]) {
         let (to_child, from_parent_) = pipes::stream();
         from_parent.add(from_parent_);
         do task::task().future_result(|+r| {
-            vec::push(worker_results, r);
+            worker_results.push(r);
         }).spawn {
             for uint::range(0u, size / workers) |_i| {
                 //error!("worker %?: sending %? bytes", i, num_bytes);
diff --git a/src/test/bench/msgsend-ring-mutex-arcs.rs b/src/test/bench/msgsend-ring-mutex-arcs.rs
index e3d8afce1bf..ec144b78a10 100644
--- a/src/test/bench/msgsend-ring-mutex-arcs.rs
+++ b/src/test/bench/msgsend-ring-mutex-arcs.rs
@@ -18,7 +18,7 @@ type pipe = arc::MutexARC<~[uint]>;
 
 fn send(p: &pipe, msg: uint) {
     do p.access_cond |state, cond| {
-        vec::push(*state, msg);
+        state.push(msg);
         cond.signal();
     }
 }
@@ -27,7 +27,7 @@ fn recv(p: &pipe) -> uint {
         while vec::is_empty(*state) {
             cond.wait();
         }
-        vec::pop(*state)
+        state.pop()
     }
 }
 
@@ -91,7 +91,7 @@ fn main(++args: ~[~str]) {
                         option::unwrap(num_chan),
                         option::unwrap(num_port1))
         });
-        vec::push(futures, new_future);
+        futures.push(new_future);
         num_chan = Some(new_chan);
     };
 
diff --git a/src/test/bench/msgsend-ring-pipes.rs b/src/test/bench/msgsend-ring-pipes.rs
index 645aa654700..119c2065d6b 100644
--- a/src/test/bench/msgsend-ring-pipes.rs
+++ b/src/test/bench/msgsend-ring-pipes.rs
@@ -24,7 +24,7 @@ proto! ring (
 fn macros() {
     #macro[
         [#move_out[x],
-         unsafe { let y <- *ptr::addr_of(x); y }]
+         unsafe { let y <- *ptr::addr_of(&x); y }]
     ];
 }
 
@@ -88,7 +88,7 @@ fn main(++args: ~[~str]) {
                         option::unwrap(num_chan),
                         option::unwrap(num_port1))
         };
-        vec::push(futures, new_future);
+        futures.push(new_future);
         num_chan = Some(new_chan);
     };
 
diff --git a/src/test/bench/msgsend-ring-rw-arcs.rs b/src/test/bench/msgsend-ring-rw-arcs.rs
index b4b75adc3b5..1b857b6caeb 100644
--- a/src/test/bench/msgsend-ring-rw-arcs.rs
+++ b/src/test/bench/msgsend-ring-rw-arcs.rs
@@ -18,7 +18,7 @@ type pipe = arc::RWARC<~[uint]>;
 
 fn send(p: &pipe, msg: uint) {
     do p.write_cond |state, cond| {
-        vec::push(*state, msg);
+        state.push(msg);
         cond.signal();
     }
 }
@@ -27,7 +27,7 @@ fn recv(p: &pipe) -> uint {
         while vec::is_empty(*state) {
             cond.wait();
         }
-        vec::pop(*state)
+        state.pop()
     }
 }
 
@@ -92,7 +92,7 @@ fn main(++args: ~[~str]) {
                         option::unwrap(num_chan),
                         option::unwrap(num_port1))
         };
-        vec::push(futures, new_future);
+        futures.push(new_future);
         num_chan = Some(new_chan);
     };
 
diff --git a/src/test/bench/msgsend-ring.rs b/src/test/bench/msgsend-ring.rs
index 47ce0d2b91f..5533aeeeb41 100644
--- a/src/test/bench/msgsend-ring.rs
+++ b/src/test/bench/msgsend-ring.rs
@@ -51,7 +51,7 @@ fn main(++args: ~[~str]) {
             get_chan_chan.send(Chan(p));
             thread_ring(i, msg_per_task, num_chan,  p)
         };
-        vec::push(futures, new_future);
+        futures.push(new_future);
         
         num_chan = get_chan.recv();
     };
diff --git a/src/test/bench/msgsend.rs b/src/test/bench/msgsend.rs
index 2790f00d40d..fb1e3ae9226 100644
--- a/src/test/bench/msgsend.rs
+++ b/src/test/bench/msgsend.rs
@@ -37,7 +37,7 @@ fn run(args: ~[~str]) {
     let mut worker_results = ~[];
     for uint::range(0u, workers) |_i| {
         do task::task().future_result(|+r| {
-            vec::push(worker_results, r);
+            worker_results.push(r);
         }).spawn {
             for uint::range(0u, size / workers) |_i| {
                 comm::send(to_child, bytes(100u));
diff --git a/src/test/bench/pingpong.rs b/src/test/bench/pingpong.rs
index 570ec8c0b6b..70f98934e1b 100644
--- a/src/test/bench/pingpong.rs
+++ b/src/test/bench/pingpong.rs
@@ -33,7 +33,7 @@ proto! pingpong_unbounded (
 
 // This stuff should go in libcore::pipes
 macro_rules! move_it (
-    { $x:expr } => { let t <- *ptr::addr_of($x); t }
+    { $x:expr } => { let t <- *ptr::addr_of(&($x)); t }
 )
 
 macro_rules! follow (
diff --git a/src/test/bench/shootout-chameneos-redux.rs b/src/test/bench/shootout-chameneos-redux.rs
index bdfe4b7b727..5c7827f5106 100644
--- a/src/test/bench/shootout-chameneos-redux.rs
+++ b/src/test/bench/shootout-chameneos-redux.rs
@@ -163,7 +163,7 @@ fn rendezvous(nn: uint, set: ~[color]) {
     // save each creature's meeting stats
     let mut report = ~[];
     for vec::each(to_creature) |_to_one| {
-        vec::push(report, comm::recv(from_creatures_log));
+        report.push(comm::recv(from_creatures_log));
     }
 
     // print each color in the set
diff --git a/src/test/bench/shootout-fasta.rs b/src/test/bench/shootout-fasta.rs
index a07b29f3dc6..0c742e16bfa 100644
--- a/src/test/bench/shootout-fasta.rs
+++ b/src/test/bench/shootout-fasta.rs
@@ -81,7 +81,7 @@ fn main(++args: ~[~str]) {
     };
 
     let writer = if os::getenv(~"RUST_BENCH").is_some() {
-        result::get(io::file_writer(&Path("./shootout-fasta.data"),
+        result::get(&io::file_writer(&Path("./shootout-fasta.data"),
                                     ~[io::Truncate, io::Create]))
     } else {
         io::stdout()
diff --git a/src/test/bench/shootout-k-nucleotide-pipes.rs b/src/test/bench/shootout-k-nucleotide-pipes.rs
index 21bed9f8790..85dcdd32e13 100644
--- a/src/test/bench/shootout-k-nucleotide-pipes.rs
+++ b/src/test/bench/shootout-k-nucleotide-pipes.rs
@@ -41,7 +41,7 @@ fn sort_and_fmt(mm: HashMap<~[u8], uint>, total: uint) -> ~str {
 
    // map -> [(k,%)]
    mm.each(fn&(key: ~[u8], val: uint) -> bool {
-      vec::push(pairs, (key, pct(val, total)));
+      pairs.push((key, pct(val, total)));
       return true;
    });
 
@@ -134,7 +134,7 @@ fn main(++args: ~[~str]) {
        // get to this massive data set, but #include_bin chokes on it (#2598)
        let path = Path(env!("CFG_SRC_DIR"))
            .push_rel(&Path("src/test/bench/shootout-k-nucleotide.data"));
-       result::get(io::file_reader(&path))
+       result::get(&io::file_reader(&path))
    } else {
       io::stdin()
    };
@@ -152,7 +152,7 @@ fn main(++args: ~[~str]) {
         stream <-> streams[ii];
         let (to_parent_, from_child_) = option::unwrap(stream);
 
-        vec::push(from_child, from_child_);
+        from_child.push(from_child_);
 
         let (to_child, from_parent) = pipes::stream();
 
diff --git a/src/test/bench/shootout-k-nucleotide.rs b/src/test/bench/shootout-k-nucleotide.rs
index d107db7e6b0..6ba6eb7fead 100644
--- a/src/test/bench/shootout-k-nucleotide.rs
+++ b/src/test/bench/shootout-k-nucleotide.rs
@@ -38,7 +38,7 @@ fn sort_and_fmt(mm: HashMap<~[u8], uint>, total: uint) -> ~str {
 
    // map -> [(k,%)]
    mm.each(fn&(key: ~[u8], val: uint) -> bool {
-      vec::push(pairs, (key, pct(val, total)));
+      pairs.push((key, pct(val, total)));
       return true;
    });
 
@@ -131,7 +131,7 @@ fn main(++args: ~[~str]) {
        // get to this massive data set, but #include_bin chokes on it (#2598)
        let path = Path(env!("CFG_SRC_DIR"))
            .push_rel(&Path("src/test/bench/shootout-k-nucleotide.data"));
-       result::get(io::file_reader(&path))
+       result::get(&io::file_reader(&path))
    } else {
       io::stdin()
    };
diff --git a/src/test/bench/shootout-mandelbrot.rs b/src/test/bench/shootout-mandelbrot.rs
index f6386a207b1..ee38b957b0c 100644
--- a/src/test/bench/shootout-mandelbrot.rs
+++ b/src/test/bench/shootout-mandelbrot.rs
@@ -85,7 +85,7 @@ fn chanmb(i: uint, size: uint, ch: comm::Chan<line>) -> ()
     let xincr = 8f64*incr;
     for uint::range(0_u, size/8_u) |j| {
         let x = cmplx {re: xincr*(j as f64) - 1.5f64, im: y};
-        vec::push(crv, fillbyte(x, incr));
+        crv.push(fillbyte(x, incr));
     };
     comm::send(ch, {i:i, b:crv});
 }
@@ -94,7 +94,7 @@ type devnull = {dn: int};
 
 impl devnull: io::Writer {
     fn write(_b: &[const u8]) {}
-    fn seek(_i: int, _s: io::SeekStyle) {}
+    fn seek(+_i: int, +_s: io::SeekStyle) {}
     fn tell() -> uint {0_u}
     fn flush() -> int {0}
     fn get_type() -> io::WriterType { io::File }
@@ -114,7 +114,7 @@ fn writer(path: ~str, writech: comm::Chan<comm::Chan<line>>, size: uint)
         }
         _ => {
             result::get(
-                io::file_writer(&Path(path),
+                &io::file_writer(&Path(path),
                 ~[io::Create, io::Truncate]))
         }
     };
diff --git a/src/test/bench/shootout-pfib.rs b/src/test/bench/shootout-pfib.rs
index 705679bd403..90224645f84 100644
--- a/src/test/bench/shootout-pfib.rs
+++ b/src/test/bench/shootout-pfib.rs
@@ -73,7 +73,7 @@ fn stress(num_tasks: int) {
     let mut results = ~[];
     for range(0, num_tasks) |i| {
         do task::task().future_result(|+r| {
-            vec::push(results, r);
+            results.push(r);
         }).spawn {
             stress_task(i);
         }
diff --git a/src/test/bench/task-perf-one-million.rs b/src/test/bench/task-perf-one-million.rs
index da8b1932f65..c9d4fb6b4d8 100644
--- a/src/test/bench/task-perf-one-million.rs
+++ b/src/test/bench/task-perf-one-million.rs
@@ -21,7 +21,7 @@ fn calc(children: uint, parent_ch: comm::Chan<msg>) {
     for iter::repeat (children) {
         match comm::recv(port) {
           ready(child_ch) => {
-            vec::push(child_chs, child_ch);
+            child_chs.push(child_ch);
           }
           _ => fail ~"task-perf-one-million failed (port not ready)"
         }
diff --git a/src/test/bench/task-perf-word-count-generic.rs b/src/test/bench/task-perf-word-count-generic.rs
index 73c5dab16d8..62612366524 100644
--- a/src/test/bench/task-perf-word-count-generic.rs
+++ b/src/test/bench/task-perf-word-count-generic.rs
@@ -20,7 +20,7 @@ use option::None;
 use std::map;
 use std::map::HashMap;
 use hash::Hash;
-use io::WriterUtil;
+use io::{ReaderUtil, WriterUtil};
 
 use std::time;
 
@@ -32,7 +32,7 @@ use cmp::Eq;
 use to_bytes::IterBytes;
 
 macro_rules! move_out (
-    { $x:expr } => { unsafe { let y <- *ptr::addr_of($x); y } }
+    { $x:expr } => { unsafe { let y <- *ptr::addr_of(&($x)); y } }
 )
 
 trait word_reader {
@@ -155,8 +155,8 @@ mod map_reduce {
             let (ctrl, ctrl_server) = ctrl_proto::init();
             let ctrl = box(ctrl);
             let i = copy *i;
-            vec::push(tasks, spawn_joinable(|move i| map_task(map, ctrl, i)));
-            vec::push(ctrls, ctrl_server);
+            tasks.push(spawn_joinable(|move i| map_task(map, ctrl, i)));
+            ctrls.push(ctrl_server);
         }
         return tasks;
     }
@@ -270,8 +270,7 @@ mod map_reduce {
                     let p = Port();
                     let ch = Chan(p);
                     let r = reduce, kk = k;
-                    vec::push(tasks,
-                              spawn_joinable(|| reduce_task(r, kk, ch) ));
+                    tasks.push(spawn_joinable(|| reduce_task(r, kk, ch) ));
                     c = recv(p);
                     reducers.insert(k, c);
                   }
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 b8e34aefd6f..15154ab5a4e 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
@@ -2,7 +2,7 @@
 fn compute1() -> float {
     let v = ~[0f, 1f, 2f, 3f];
 
-    do vec::foldl(0f, v) |x, y| { x + y } - 10f
+    do vec::foldl(0f, v) |x, y| { x + *y } - 10f
     //~^ ERROR mismatched types: expected `()`
 }
 
diff --git a/src/test/compile-fail/deprecated-mode-fn-arg.rs b/src/test/compile-fail/deprecated-mode-fn-arg.rs
new file mode 100644
index 00000000000..5afffb59dfc
--- /dev/null
+++ b/src/test/compile-fail/deprecated-mode-fn-arg.rs
@@ -0,0 +1,9 @@
+#[forbid(deprecated_mode)];
+
+fn foo(_f: fn(&i: int)) { //~ ERROR explicit mode
+}
+
+type Bar = fn(&i: int); //~ ERROR explicit mode
+
+fn main() {
+}
\ No newline at end of file
diff --git a/src/test/compile-fail/issue-3096-2.rs b/src/test/compile-fail/issue-3096-2.rs
index cd3d63b5888..03e13f67a9a 100644
--- a/src/test/compile-fail/issue-3096-2.rs
+++ b/src/test/compile-fail/issue-3096-2.rs
@@ -1,6 +1,6 @@
 enum bottom { } 
 
 fn main() {
-    let x = ptr::addr_of(()) as *bottom;
+    let x = ptr::p2::addr_of(&()) as *bottom;
     match x { } //~ ERROR non-exhaustive patterns
 }
diff --git a/src/test/compile-fail/mutable-huh-ptr-assign.rs b/src/test/compile-fail/mutable-huh-ptr-assign.rs
index ecfbb9a1f08..4b680ec8b70 100644
--- a/src/test/compile-fail/mutable-huh-ptr-assign.rs
+++ b/src/test/compile-fail/mutable-huh-ptr-assign.rs
@@ -7,7 +7,7 @@ fn main() {
 
     unsafe {
         let a = 0;
-        let v = ptr::mut_addr_of(a);
+        let v = ptr::mut_addr_of(&a);
         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 c96f3f624f1..e98b9b34c5f 100644
--- a/src/test/compile-fail/mutable-huh-variance-ptr.rs
+++ b/src/test/compile-fail/mutable-huh-variance-ptr.rs
@@ -4,7 +4,7 @@ extern mod std;
 
 fn main() {
     let a = ~[0];
-    let v: *mut ~[int] = ptr::mut_addr_of(a);
+    let v: *mut ~[int] = ptr::mut_addr_of(&a);
 
     fn f(&&v: *mut ~[const int]) {
         unsafe {
diff --git a/src/test/compile-fail/non-copyable-void.rs b/src/test/compile-fail/non-copyable-void.rs
index 59136683e6f..a00dd7afd6d 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::p2::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/purity-infer-fail.rs b/src/test/compile-fail/purity-infer-fail.rs
index 691829edf59..b7666fa8650 100644
--- a/src/test/compile-fail/purity-infer-fail.rs
+++ b/src/test/compile-fail/purity-infer-fail.rs
@@ -2,5 +2,5 @@ fn something(f: pure fn()) { f(); }
 
 fn main() {
     let mut x = ~[];
-    something(|| vec::push(x, 0) ); //~ ERROR access to impure function prohibited in pure context
+    something(|| x.push(0) ); //~ ERROR access to impure function prohibited in pure context
 }
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 638f14f8794..276862ce106 100644
--- a/src/test/compile-fail/regions-escape-loop-via-vec.rs
+++ b/src/test/compile-fail/regions-escape-loop-via-vec.rs
@@ -7,7 +7,7 @@ fn broken() -> int {
         y += ~[&mut z]; //~ ERROR illegal borrow
         x += 1;
     }
-    vec::foldl(0, y, |v, p| v + *p )
+    vec::foldl(0, y, |v, p| v + **p )
 }
 
 fn main() { }
\ No newline at end of file
diff --git a/src/test/compile-fail/unnamed_argument_mode.rs b/src/test/compile-fail/unnamed_argument_mode.rs
new file mode 100644
index 00000000000..36e6edc96f9
--- /dev/null
+++ b/src/test/compile-fail/unnamed_argument_mode.rs
@@ -0,0 +1,14 @@
+//error-pattern: mismatched types
+
+fn bad(&a: int) {
+}
+
+// unnamed argument &int is now parsed x: &int
+// it's not parsed &x: int anymore
+
+fn called(f: fn(&int)) {
+}
+
+fn main() {
+called(bad);
+}
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 0db43856612..ef371d07569 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
@@ -1,5 +1,5 @@
 // xfail-test
-// error-pattern:bounds check
+// error-pattern:index out of bounds
 
 fn main() {
     let x = ~[1u,2u,3u];
@@ -14,4 +14,4 @@ fn main() {
 
     // This should fail.
     error!("ov2 0x%x",  x[idx]);
-}
\ No newline at end of file
+}
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 949d303eb01..ae3a9c55b93 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
@@ -1,5 +1,5 @@
 // xfail-test
-// error-pattern:bounds check
+// error-pattern:index out of bounds
 
 #[cfg(target_arch="x86")]
 fn main() {
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 924b3dda149..fdbcb4de2be 100644
--- a/src/test/run-fail/bug-2470-bounds-check-overflow.rs
+++ b/src/test/run-fail/bug-2470-bounds-check-overflow.rs
@@ -1,4 +1,4 @@
-// error-pattern:bounds check
+// error-pattern:index out of bounds
 
 fn main() {
 
diff --git a/src/test/run-fail/issue-2156.rs b/src/test/run-fail/issue-2156.rs
index 6b39e323c6e..57d33c965b0 100644
--- a/src/test/run-fail/issue-2156.rs
+++ b/src/test/run-fail/issue-2156.rs
@@ -1,7 +1,7 @@
 // error-pattern:explicit failure
 // Don't double free the string
 extern mod std;
-use io::Reader;
+use io::ReaderUtil;
 
 fn main() {
     do io::with_str_reader(~"") |rdr| {
diff --git a/src/test/run-fail/result-get-fail.rs b/src/test/run-fail/result-get-fail.rs
index fbc8378643b..2b8712f3d59 100644
--- a/src/test/run-fail/result-get-fail.rs
+++ b/src/test/run-fail/result-get-fail.rs
@@ -1,4 +1,4 @@
 // error-pattern:get called on error result: ~"kitty"
 fn main() {
-  log(error, result::get(result::Err::<int,~str>(~"kitty")));
+  log(error, result::get(&result::Err::<int,~str>(~"kitty")));
 }
diff --git a/src/test/run-fail/small-negative-indexing.rs b/src/test/run-fail/small-negative-indexing.rs
index 96f0c12c760..5ba6e9dd27a 100644
--- a/src/test/run-fail/small-negative-indexing.rs
+++ b/src/test/run-fail/small-negative-indexing.rs
@@ -1,4 +1,4 @@
-// error-pattern:bounds check
+// error-pattern:index out of bounds: the len is 1024 but the index is -1
 fn main() {
     let v = vec::from_fn(1024u, {|n| n});
     // this should trip a bounds check
diff --git a/src/test/run-fail/str-overrun.rs b/src/test/run-fail/str-overrun.rs
index b8bccfe82d4..d9485f3a289 100644
--- a/src/test/run-fail/str-overrun.rs
+++ b/src/test/run-fail/str-overrun.rs
@@ -1,6 +1,6 @@
 // -*- rust -*-
 
-// error-pattern:bounds check
+// error-pattern:index out of bounds: the len is 5 but the index is 5
 fn main() {
     let s: ~str = ~"hello";
 
diff --git a/src/test/run-fail/vec-overrun.rs b/src/test/run-fail/vec-overrun.rs
index 8301a05f76b..fd3254bc6b1 100644
--- a/src/test/run-fail/vec-overrun.rs
+++ b/src/test/run-fail/vec-overrun.rs
@@ -1,6 +1,6 @@
 // -*- rust -*-
 
-// error-pattern:bounds check
+// error-pattern:index out of bounds: the len is 1 but the index is 2
 fn main() {
     let v: ~[int] = ~[10];
     let x: int = 0;
diff --git a/src/test/run-fail/vec-underrun.rs b/src/test/run-fail/vec-underrun.rs
index 1228e95ac1e..88b29471dac 100644
--- a/src/test/run-fail/vec-underrun.rs
+++ b/src/test/run-fail/vec-underrun.rs
@@ -1,6 +1,6 @@
 // -*- rust -*-
 
-// error-pattern:bounds check
+// error-pattern:index out of bounds: the len is 2 but the index is -1
 fn main() {
     let v: ~[int] = ~[10, 20];
     let x: int = 0;
diff --git a/src/test/run-fail/zip-different-lengths.rs b/src/test/run-fail/zip-different-lengths.rs
index 4e97d2f903f..c6239c1f657 100644
--- a/src/test/run-fail/zip-different-lengths.rs
+++ b/src/test/run-fail/zip-different-lengths.rs
@@ -8,7 +8,7 @@ fn enum_chars(start: u8, end: u8) -> ~[char] {
     assert start < end;
     let mut i = start;
     let mut r = ~[];
-    while i <= end { vec::push(r, i as char); i += 1u as u8; }
+    while i <= end { r.push(i as char); i += 1u as u8; }
     return r;
 }
 
@@ -16,7 +16,7 @@ fn enum_uints(start: uint, end: uint) -> ~[uint] {
     assert start < end;
     let mut i = start;
     let mut r = ~[];
-    while i <= end { vec::push(r, i); i += 1u; }
+    while i <= end { r.push(i); i += 1u; }
     return r;
 }
 
diff --git a/src/test/run-pass/auto-ref-sliceable.rs b/src/test/run-pass/auto-ref-sliceable.rs
index 43d9fa5b14b..48d83da74ad 100644
--- a/src/test/run-pass/auto-ref-sliceable.rs
+++ b/src/test/run-pass/auto-ref-sliceable.rs
@@ -4,7 +4,7 @@ trait Pushable<T> {
 
 impl<T> ~[T]: Pushable<T> {
     fn push_val(&mut self, +t: T) {
-        vec::push(*self, t);
+        self.push(t);
     }
 }
 
diff --git a/src/test/run-pass/auto_serialize2.rs b/src/test/run-pass/auto_serialize2.rs
new file mode 100644
index 00000000000..4503ea6c7e0
--- /dev/null
+++ b/src/test/run-pass/auto_serialize2.rs
@@ -0,0 +1,163 @@
+extern mod std;
+
+// These tests used to be separate files, but I wanted to refactor all
+// the common code.
+
+use cmp::Eq;
+use std::ebml2;
+use io::Writer;
+use std::serialization2::{Serializable, Deserializable, deserialize};
+use std::prettyprint2;
+
+fn test_ser_and_deser<A:Eq Serializable Deserializable>(
+    a1: &A,
+    +expected: ~str
+) {
+    // check the pretty printer:
+    let s = do io::with_str_writer |w| {
+        a1.serialize(&prettyprint2::Serializer(w))
+    };
+    debug!("s == %?", s);
+    assert s == expected;
+
+    // check the EBML serializer:
+    let bytes = do io::with_bytes_writer |wr| {
+        let ebml_w = &ebml2::Serializer(wr);
+        a1.serialize(ebml_w)
+    };
+    let d = ebml2::Doc(@bytes);
+    let a2: A = deserialize(&ebml2::Deserializer(d));
+    assert *a1 == a2;
+}
+
+#[auto_serialize2]
+#[auto_deserialize2]
+enum Expr {
+    Val(uint),
+    Plus(@Expr, @Expr),
+    Minus(@Expr, @Expr)
+}
+
+impl Expr : cmp::Eq {
+    pure fn eq(other: &Expr) -> bool {
+        match self {
+            Val(e0a) => {
+                match *other {
+                    Val(e0b) => e0a == e0b,
+                    _ => false
+                }
+            }
+            Plus(e0a, e1a) => {
+                match *other {
+                    Plus(e0b, e1b) => e0a == e0b && e1a == e1b,
+                    _ => false
+                }
+            }
+            Minus(e0a, e1a) => {
+                match *other {
+                    Minus(e0b, e1b) => e0a == e0b && e1a == e1b,
+                    _ => false
+                }
+            }
+        }
+    }
+    pure fn ne(other: &Expr) -> bool { !self.eq(other) }
+}
+
+impl AnEnum : cmp::Eq {
+    pure fn eq(other: &AnEnum) -> bool {
+        self.v == other.v
+    }
+    pure fn ne(other: &AnEnum) -> bool { !self.eq(other) }
+}
+
+impl Point : cmp::Eq {
+    pure fn eq(other: &Point) -> bool {
+        self.x == other.x && self.y == other.y
+    }
+    pure fn ne(other: &Point) -> bool { !self.eq(other) }
+}
+
+impl<T:cmp::Eq> Quark<T> : cmp::Eq {
+    pure fn eq(other: &Quark<T>) -> bool {
+        match self {
+            Top(ref q) => {
+                match *other {
+                    Top(ref r) => q == r,
+                    Bottom(_) => false
+                }
+            },
+            Bottom(ref q) => {
+                match *other {
+                    Top(_) => false,
+                    Bottom(ref r) => q == r
+                }
+            },
+        }
+    }
+    pure fn ne(other: &Quark<T>) -> bool { !self.eq(other) }
+}
+
+impl CLike : cmp::Eq {
+    pure fn eq(other: &CLike) -> bool {
+        self as int == *other as int
+    }
+    pure fn ne(other: &CLike) -> bool { !self.eq(other) }
+}
+
+#[auto_serialize2]
+#[auto_deserialize2]
+type Spanned<T> = {lo: uint, hi: uint, node: T};
+
+impl<T:cmp::Eq> Spanned<T> : cmp::Eq {
+    pure fn eq(other: &Spanned<T>) -> bool {
+        self.lo == other.lo && self.hi == other.hi && self.node == other.node
+    }
+    pure fn ne(other: &Spanned<T>) -> bool { !self.eq(other) }
+}
+
+#[auto_serialize2]
+#[auto_deserialize2]
+type SomeRec = {v: ~[uint]};
+
+#[auto_serialize2]
+#[auto_deserialize2]
+enum AnEnum = SomeRec;
+
+#[auto_serialize2]
+#[auto_deserialize2]
+struct Point {x: uint, y: uint}
+
+#[auto_serialize2]
+#[auto_deserialize2]
+enum Quark<T> {
+    Top(T),
+    Bottom(T)
+}
+
+#[auto_serialize2]
+#[auto_deserialize2]
+enum CLike { A, B, C }
+
+fn main() {
+    test_ser_and_deser(&Plus(@Minus(@Val(3u), @Val(10u)),
+                             @Plus(@Val(22u), @Val(5u))),
+                       ~"Plus(@Minus(@Val(3u), @Val(10u)), \
+                        @Plus(@Val(22u), @Val(5u)))");
+
+    test_ser_and_deser(&{lo: 0u, hi: 5u, node: 22u},
+                       ~"{lo: 0u, hi: 5u, node: 22u}");
+
+    test_ser_and_deser(&AnEnum({v: ~[1u, 2u, 3u]}),
+                       ~"AnEnum({v: ~[1u, 2u, 3u]})");
+
+    test_ser_and_deser(&Point {x: 3u, y: 5u}, ~"Point {x: 3u, y: 5u}");
+
+    test_ser_and_deser(&@[1u, 2u, 3u], ~"@[1u, 2u, 3u]");
+
+    test_ser_and_deser(&Top(22u), ~"Top(22u)");
+    test_ser_and_deser(&Bottom(222u), ~"Bottom(222u)");
+
+    test_ser_and_deser(&A, ~"A");
+    test_ser_and_deser(&B, ~"B");
+}
diff --git a/src/test/run-pass/autoref-intermediate-types-issue-3585.rs b/src/test/run-pass/autoref-intermediate-types-issue-3585.rs
new file mode 100644
index 00000000000..68e172bacad
--- /dev/null
+++ b/src/test/run-pass/autoref-intermediate-types-issue-3585.rs
@@ -0,0 +1,20 @@
+trait Foo {
+    fn foo(&self) -> ~str;
+}
+
+impl<T: Foo> @T: Foo {
+    fn foo(&self) -> ~str {
+        fmt!("@%s", (**self).foo())
+    }
+}
+
+impl uint: Foo {
+    fn foo(&self) -> ~str {
+        fmt!("%u", *self)
+    }
+}
+
+fn main() {
+    let x = @3u;
+    assert x.foo() == ~"@3";
+}
\ No newline at end of file
diff --git a/src/test/run-pass/binops.rs b/src/test/run-pass/binops.rs
index 0cc828132c9..cfcb158a990 100644
--- a/src/test/run-pass/binops.rs
+++ b/src/test/run-pass/binops.rs
@@ -103,8 +103,8 @@ fn test_class() {
   
   unsafe {
   error!("q = %x, r = %x",
-         (cast::reinterpret_cast::<*p, uint>(&ptr::addr_of(q))),
-         (cast::reinterpret_cast::<*p, uint>(&ptr::addr_of(r))));
+         (cast::reinterpret_cast::<*p, uint>(&ptr::addr_of(&q))),
+         (cast::reinterpret_cast::<*p, uint>(&ptr::addr_of(&r))));
   }
   assert(q == r);
   r.y = 17;
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 53f158471e8..bab28a06934 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
@@ -2,7 +2,7 @@ fn main() {
     let v = ~[-1f, 0f, 1f, 2f, 3f];
 
     // Trailing expressions don't require parentheses:
-    let y = do vec::foldl(0f, v) |x, y| { x + y } + 10f;
+    let y = do vec::foldl(0f, v) |x, y| { x + *y } + 10f;
 
     assert y == 15f;
 }
diff --git a/src/test/run-pass/block-arg-in-parentheses.rs b/src/test/run-pass/block-arg-in-parentheses.rs
index 14b05b29dc3..1121cc4dd2f 100644
--- a/src/test/run-pass/block-arg-in-parentheses.rs
+++ b/src/test/run-pass/block-arg-in-parentheses.rs
@@ -1,20 +1,20 @@
 fn w_semi(v: ~[int]) -> int {
     // the semicolon causes compiler not to
     // complain about the ignored return value:
-    do vec::foldl(0, v) |x,y| { x+y };
+    do vec::foldl(0, v) |x,y| { x+*y };
     -10
 }
 
 fn w_paren1(v: ~[int]) -> int {
-    (do vec::foldl(0, v) |x,y| { x+y }) - 10
+    (do vec::foldl(0, v) |x,y| { x+*y }) - 10
 }
 
 fn w_paren2(v: ~[int]) -> int {
-    (do vec::foldl(0, v) |x,y| { x+y} - 10)
+    (do vec::foldl(0, v) |x,y| { x+*y} - 10)
 }
 
 fn w_ret(v: ~[int]) -> int {
-    return do vec::foldl(0, v) |x,y| { x+y } - 10;
+    return do vec::foldl(0, v) |x,y| { x+*y } - 10;
 }
 
 fn main() {
diff --git a/src/test/run-pass/block-arg.rs b/src/test/run-pass/block-arg.rs
index 5953e0b85fb..0f77a0e0816 100644
--- a/src/test/run-pass/block-arg.rs
+++ b/src/test/run-pass/block-arg.rs
@@ -8,28 +8,28 @@ fn main() {
     }
 
     // Usable at all:
-    let mut any_negative = do vec::any(v) |e| { float::is_negative(e) };
+    let mut any_negative = do vec::any(v) |e| { float::is_negative(*e) };
     assert any_negative;
 
     // Higher precedence than assignments:
-    any_negative = do vec::any(v) |e| { float::is_negative(e) };
+    any_negative = do vec::any(v) |e| { float::is_negative(*e) };
     assert any_negative;
 
     // Higher precedence than unary operations:
     let abs_v = do vec::map(v) |e| { float::abs(*e) };
-    assert do vec::all(abs_v) |e| { float::is_nonnegative(e) };
-    assert !do vec::any(abs_v) |e| { float::is_negative(e) };
+    assert do vec::all(abs_v) |e| { float::is_nonnegative(*e) };
+    assert !do vec::any(abs_v) |e| { float::is_negative(*e) };
 
     // Usable in funny statement-like forms:
-    if !do vec::any(v) |e| { float::is_positive(e) } {
+    if !do vec::any(v) |e| { float::is_positive(*e) } {
         assert false;
     }
-    match do vec::all(v) |e| { float::is_negative(e) } {
+    match do vec::all(v) |e| { float::is_negative(*e) } {
         true => { fail ~"incorrect answer."; }
         false => { }
     }
     match 3 {
-      _ if do vec::any(v) |e| { float::is_negative(e) } => {
+      _ if do vec::any(v) |e| { float::is_negative(*e) } => {
       }
       _ => {
         fail ~"wrong answer.";
@@ -38,15 +38,15 @@ fn main() {
 
 
     // Lower precedence than binary operations:
-    let w = do vec::foldl(0f, v) |x, y| { x + y } + 10f;
-    let y = do vec::foldl(0f, v) |x, y| { x + y } + 10f;
-    let z = 10f + do vec::foldl(0f, v) |x, y| { x + y };
+    let w = do vec::foldl(0f, v) |x, y| { x + *y } + 10f;
+    let y = do vec::foldl(0f, v) |x, y| { x + *y } + 10f;
+    let z = 10f + do vec::foldl(0f, v) |x, y| { x + *y };
     assert w == y;
     assert y == z;
 
     // In the tail of a block
     let w =
-        if true { do vec::any(abs_v) |e| { float::is_nonnegative(e) } }
+        if true { do vec::any(abs_v) |e| { float::is_nonnegative(*e) } }
       else { false };
     assert w;
 }
diff --git a/src/test/run-pass/block-vec-map2.rs b/src/test/run-pass/block-vec-map2.rs
index 332afc65f72..d270800de11 100644
--- a/src/test/run-pass/block-vec-map2.rs
+++ b/src/test/run-pass/block-vec-map2.rs
@@ -4,7 +4,7 @@ fn main() {
     let v =
         vec::map2(~[1, 2, 3, 4, 5],
                   ~[true, false, false, true, true],
-                  |i, b| if b { -i } else { i } );
+                  |i, b| if *b { -(*i) } else { *i } );
     log(error, v);
     assert (v == ~[-1, 2, 3, -4, -5]);
 }
diff --git a/src/test/run-pass/borrowck-borrow-from-expr-block.rs b/src/test/run-pass/borrowck-borrow-from-expr-block.rs
index ec31225f46b..d180fc4b8ae 100644
--- a/src/test/run-pass/borrowck-borrow-from-expr-block.rs
+++ b/src/test/run-pass/borrowck-borrow-from-expr-block.rs
@@ -7,7 +7,7 @@ fn borrow(x: &int, f: fn(x: &int)) {
 fn test1(x: @~int) {
     // Right now, at least, this induces a copy of the unique pointer:
     do borrow({*x}) |p| {
-        let x_a = ptr::addr_of(**x);
+        let x_a = ptr::addr_of(&(**x));
         assert (x_a as uint) != to_uint(p);
         assert unsafe{*x_a} == *p;
     }
diff --git a/src/test/run-pass/borrowck-mut-uniq.rs b/src/test/run-pass/borrowck-mut-uniq.rs
index 6db380735cb..2d1833c0736 100644
--- a/src/test/run-pass/borrowck-mut-uniq.rs
+++ b/src/test/run-pass/borrowck-mut-uniq.rs
@@ -4,7 +4,7 @@ fn add_int(x: &mut ints, v: int) {
     *x.sum += v;
     let mut values = ~[];
     x.values <-> values;
-    vec::push(values, v);
+    values.push(v);
     x.values <- values;
 }
 
diff --git a/src/test/run-pass/borrowck-preserve-box-in-discr.rs b/src/test/run-pass/borrowck-preserve-box-in-discr.rs
index 373830d77af..5ed78488b35 100644
--- a/src/test/run-pass/borrowck-preserve-box-in-discr.rs
+++ b/src/test/run-pass/borrowck-preserve-box-in-discr.rs
@@ -5,13 +5,13 @@ fn main() {
     match *x {
       {f: b_x} => {
         assert *b_x == 3;
-        assert ptr::addr_of(*x.f) == ptr::addr_of(*b_x);
+        assert ptr::addr_of(&(*x.f)) == ptr::addr_of(&(*b_x));
 
         x = @{f: ~4};
 
-        debug!("ptr::addr_of(*b_x) = %x", ptr::addr_of(*b_x) as uint);
+        debug!("ptr::addr_of(*b_x) = %x", ptr::addr_of(&(*b_x)) as uint);
         assert *b_x == 3;
-        assert ptr::addr_of(*x.f) != ptr::addr_of(*b_x);
+        assert ptr::addr_of(&(*x.f)) != ptr::addr_of(&(*b_x));
       }
     }
 }
\ No newline at end of file
diff --git a/src/test/run-pass/borrowck-preserve-box-in-field.rs b/src/test/run-pass/borrowck-preserve-box-in-field.rs
index 7ab2dc4b99d..d7d3aa68faf 100644
--- a/src/test/run-pass/borrowck-preserve-box-in-field.rs
+++ b/src/test/run-pass/borrowck-preserve-box-in-field.rs
@@ -11,11 +11,11 @@ fn main() {
     let mut x = @{f: ~3};
     do borrow(x.f) |b_x| {
         assert *b_x == 3;
-        assert ptr::addr_of(*x.f) == ptr::addr_of(*b_x);
+        assert ptr::addr_of(&(*x.f)) == ptr::addr_of(&(*b_x));
         x = @{f: ~4};
 
-        debug!("ptr::addr_of(*b_x) = %x", ptr::addr_of(*b_x) as uint);
+        debug!("ptr::addr_of(*b_x) = %x", ptr::addr_of(&(*b_x)) as uint);
         assert *b_x == 3;
-        assert ptr::addr_of(*x.f) != ptr::addr_of(*b_x);
+        assert ptr::addr_of(&(*x.f)) != ptr::addr_of(&(*b_x));
     }
 }
\ No newline at end of file
diff --git a/src/test/run-pass/borrowck-preserve-box-in-pat.rs b/src/test/run-pass/borrowck-preserve-box-in-pat.rs
index 599879f82f1..f0944ea3544 100644
--- a/src/test/run-pass/borrowck-preserve-box-in-pat.rs
+++ b/src/test/run-pass/borrowck-preserve-box-in-pat.rs
@@ -5,13 +5,13 @@ fn main() {
     match x {
       @@{f: b_x} => {
         assert *b_x == 3;
-        assert ptr::addr_of(x.f) == ptr::addr_of(b_x);
+        assert ptr::addr_of(&(x.f)) == ptr::addr_of(&(b_x));
 
         *x = @{f: ~4};
 
-        debug!("ptr::addr_of(*b_x) = %x", ptr::addr_of(*b_x) as uint);
+        debug!("ptr::addr_of(*b_x) = %x", ptr::addr_of(&(*b_x)) as uint);
         assert *b_x == 3;
-        assert ptr::addr_of(*x.f) != ptr::addr_of(*b_x);
+        assert ptr::addr_of(&(*x.f)) != ptr::addr_of(&(*b_x));
       }
     }
 }
diff --git a/src/test/run-pass/borrowck-preserve-box-in-uniq.rs b/src/test/run-pass/borrowck-preserve-box-in-uniq.rs
index bd43ad65cff..b0bb4d8d40c 100644
--- a/src/test/run-pass/borrowck-preserve-box-in-uniq.rs
+++ b/src/test/run-pass/borrowck-preserve-box-in-uniq.rs
@@ -11,11 +11,11 @@ fn main() {
     let mut x = ~mut @{f: ~3};
     do borrow(x.f) |b_x| {
         assert *b_x == 3;
-        assert ptr::addr_of(*x.f) == ptr::addr_of(*b_x);
+        assert ptr::addr_of(&(*x.f)) == ptr::addr_of(&(*b_x));
         *x = @{f: ~4};
 
-        debug!("ptr::addr_of(*b_x) = %x", ptr::addr_of(*b_x) as uint);
+        debug!("ptr::addr_of(*b_x) = %x", ptr::addr_of(&(*b_x)) as uint);
         assert *b_x == 3;
-        assert ptr::addr_of(*x.f) != ptr::addr_of(*b_x);
+        assert ptr::addr_of(&(*x.f)) != ptr::addr_of(&(*b_x));
     }
 }
\ No newline at end of file
diff --git a/src/test/run-pass/borrowck-preserve-box.rs b/src/test/run-pass/borrowck-preserve-box.rs
index 8d59975204b..88f4b459d36 100644
--- a/src/test/run-pass/borrowck-preserve-box.rs
+++ b/src/test/run-pass/borrowck-preserve-box.rs
@@ -11,11 +11,11 @@ fn main() {
     let mut x = @3;
     do borrow(x) |b_x| {
         assert *b_x == 3;
-        assert ptr::addr_of(*x) == ptr::addr_of(*b_x);
+        assert ptr::addr_of(&(*x)) == ptr::addr_of(&(*b_x));
         x = @22;
 
-        debug!("ptr::addr_of(*b_x) = %x", ptr::addr_of(*b_x) as uint);
+        debug!("ptr::addr_of(*b_x) = %x", ptr::addr_of(&(*b_x)) as uint);
         assert *b_x == 3;
-        assert ptr::addr_of(*x) != ptr::addr_of(*b_x);
+        assert ptr::addr_of(&(*x)) != ptr::addr_of(&(*b_x));
     }
 }
\ No newline at end of file
diff --git a/src/test/run-pass/borrowck-preserve-expl-deref.rs b/src/test/run-pass/borrowck-preserve-expl-deref.rs
index e126ecc4340..ba525eafc51 100644
--- a/src/test/run-pass/borrowck-preserve-expl-deref.rs
+++ b/src/test/run-pass/borrowck-preserve-expl-deref.rs
@@ -11,11 +11,11 @@ fn main() {
     let mut x = @{f: ~3};
     do borrow((*x).f) |b_x| {
         assert *b_x == 3;
-        assert ptr::addr_of(*x.f) == ptr::addr_of(*b_x);
+        assert ptr::addr_of(&(*x.f)) == ptr::addr_of(&(*b_x));
         x = @{f: ~4};
 
-        debug!("ptr::addr_of(*b_x) = %x", ptr::addr_of(*b_x) as uint);
+        debug!("ptr::addr_of(*b_x) = %x", ptr::addr_of(&(*b_x)) as uint);
         assert *b_x == 3;
-        assert ptr::addr_of(*x.f) != ptr::addr_of(*b_x);
+        assert ptr::addr_of(&(*x.f)) != ptr::addr_of(&(*b_x));
     }
 }
diff --git a/src/test/run-pass/box-annihilator-shared.rs b/src/test/run-pass/box-annihilator-shared.rs
deleted file mode 100644
index 5786b334af7..00000000000
--- a/src/test/run-pass/box-annihilator-shared.rs
+++ /dev/null
@@ -1,12 +0,0 @@
-extern mod rustrt {
-    #[legacy_exports];
-    fn rust_annihilate_box(ptr: *uint);
-}
-
-fn main() {
-    unsafe {
-        let x = @3;
-        let p: *uint = cast::transmute(x);
-        rustrt::rust_annihilate_box(p);
-    }
-}
diff --git a/src/test/run-pass/box-annihilator-unique-vec.rs b/src/test/run-pass/box-annihilator-unique-vec.rs
deleted file mode 100644
index 45449cc6382..00000000000
--- a/src/test/run-pass/box-annihilator-unique-vec.rs
+++ /dev/null
@@ -1,12 +0,0 @@
-extern mod rustrt {
-    #[legacy_exports];
-    fn rust_annihilate_box(ptr: *uint);
-}
-
-fn main() {
-    unsafe {
-        let x = ~[~"a", ~"b", ~"c"];
-        let p: *uint = cast::transmute(x);
-        rustrt::rust_annihilate_box(p);
-    }
-}
diff --git a/src/test/run-pass/box-annihilator-unique.rs b/src/test/run-pass/box-annihilator-unique.rs
deleted file mode 100644
index a2d11654f9a..00000000000
--- a/src/test/run-pass/box-annihilator-unique.rs
+++ /dev/null
@@ -1,12 +0,0 @@
-extern mod rustrt {
-    #[legacy_exports];
-    fn rust_annihilate_box(ptr: *uint);
-}
-
-fn main() {
-    unsafe {
-        let x = ~3;
-        let p: *uint = cast::transmute(x);
-        rustrt::rust_annihilate_box(p);
-    }
-}
diff --git a/src/test/run-pass/cap-clause-move.rs b/src/test/run-pass/cap-clause-move.rs
index 260c1d45b76..0561af6ca6d 100644
--- a/src/test/run-pass/cap-clause-move.rs
+++ b/src/test/run-pass/cap-clause-move.rs
@@ -1,29 +1,29 @@
 fn main() {
     let x = ~1;
-    let y = ptr::addr_of(*x) as uint;
-    let lam_copy = fn@(copy x) -> uint { ptr::addr_of(*x) as uint };
-    let lam_move = fn@(move x) -> uint { ptr::addr_of(*x) as uint };
+    let y = ptr::addr_of(&(*x)) as uint;
+    let lam_copy = fn@(copy x) -> uint { ptr::addr_of(&(*x)) as uint };
+    let lam_move = fn@(move x) -> uint { ptr::addr_of(&(*x)) as uint };
     assert lam_copy() != y;
     assert lam_move() == y;
 
     let x = ~2;
-    let y = ptr::addr_of(*x) as uint;
-    let lam_copy: fn@() -> uint = |copy x| ptr::addr_of(*x) as uint;
-    let lam_move: fn@() -> uint = |move x| ptr::addr_of(*x) as uint;
+    let y = ptr::addr_of(&(*x)) as uint;
+    let lam_copy: fn@() -> uint = |copy x| ptr::addr_of(&(*x)) as uint;
+    let lam_move: fn@() -> uint = |move x| ptr::addr_of(&(*x)) as uint;
     assert lam_copy() != y;
     assert lam_move() == y;
 
     let x = ~3;
-    let y = ptr::addr_of(*x) as uint;
-    let snd_copy = fn~(copy x) -> uint { ptr::addr_of(*x) as uint };
-    let snd_move = fn~(move x) -> uint { ptr::addr_of(*x) as uint };
+    let y = ptr::addr_of(&(*x)) as uint;
+    let snd_copy = fn~(copy x) -> uint { ptr::addr_of(&(*x)) as uint };
+    let snd_move = fn~(move x) -> uint { ptr::addr_of(&(*x)) as uint };
     assert snd_copy() != y;
     assert snd_move() == y;
 
     let x = ~4;
-    let y = ptr::addr_of(*x) as uint;
-    let lam_copy: fn~() -> uint = |copy x| ptr::addr_of(*x) as uint;
-    let lam_move: fn~() -> uint = |move x| ptr::addr_of(*x) as uint;
+    let y = ptr::addr_of(&(*x)) as uint;
+    let lam_copy: fn~() -> uint = |copy x| ptr::addr_of(&(*x)) as uint;
+    let lam_move: fn~() -> uint = |move x| ptr::addr_of(&(*x)) as uint;
     assert lam_copy() != y;
     assert lam_move() == y;
 }
diff --git a/src/test/run-pass/cleanup-copy-mode.rs b/src/test/run-pass/cleanup-copy-mode.rs
index 2cf1276887e..e4bfa54c410 100644
--- a/src/test/run-pass/cleanup-copy-mode.rs
+++ b/src/test/run-pass/cleanup-copy-mode.rs
@@ -2,7 +2,7 @@
 fn adder(+x: @int, +y: @int) -> int { return *x + *y; }
 fn failer() -> @int { fail; }
 fn main() {
-    assert(result::is_err(task::try(|| {
+    assert(result::is_err(&task::try(|| {
         adder(@2, failer()); ()
     })));
 }
diff --git a/src/test/run-pass/early-vtbl-resolution.rs b/src/test/run-pass/early-vtbl-resolution.rs
index 24faa53fda4..2bbbbf7ef17 100644
--- a/src/test/run-pass/early-vtbl-resolution.rs
+++ b/src/test/run-pass/early-vtbl-resolution.rs
@@ -9,7 +9,7 @@ fn foo_func<A, B: thing<A>>(x: B) -> Option<A> { x.foo() }
 
 fn main() {
 
-    for iter::eachi(Some({a: 0})) |i, a| { 
+    for iter::eachi(&(Some({a: 0}))) |i, a| { 
         #debug["%u %d", i, a.a];
     }
 
diff --git a/src/test/run-pass/enum-export-inheritance.rs b/src/test/run-pass/enum-export-inheritance.rs
new file mode 100644
index 00000000000..1fddddba331
--- /dev/null
+++ b/src/test/run-pass/enum-export-inheritance.rs
@@ -0,0 +1,12 @@
+mod a {
+    pub enum Foo {
+        Bar,
+        Baz,
+        Boo
+    }
+}
+
+fn main() {
+    let x = a::Bar;
+}
+
diff --git a/src/test/run-pass/hello.rs b/src/test/run-pass/hello.rs
index 5f61c554992..5b0664f400b 100644
--- a/src/test/run-pass/hello.rs
+++ b/src/test/run-pass/hello.rs
@@ -1,5 +1,5 @@
-
-
-
 // -*- rust -*-
-fn main() { debug!("hello, world."); }
+
+fn main() {
+    io::println("hello, world");
+}
diff --git a/src/test/run-pass/issue-2611.rs b/src/test/run-pass/issue-2611.rs
index cc2e89c76ea..8fb5a0d6e04 100644
--- a/src/test/run-pass/issue-2611.rs
+++ b/src/test/run-pass/issue-2611.rs
@@ -4,12 +4,12 @@
 use iter::BaseIter;
 
 trait FlatMapToVec<A> {
-  fn flat_map_to_vec<B:Copy, IB:BaseIter<B>>(op: fn(A) -> IB) -> ~[B];
+  fn flat_map_to_vec<B:Copy, IB:BaseIter<B>>(op: fn(+a: A) -> IB) -> ~[B];
 }
 
 impl<A:Copy> BaseIter<A>: FlatMapToVec<A> {
-   fn flat_map_to_vec<B:Copy, IB:BaseIter<B>>(op: fn(A) -> IB) -> ~[B] {
-     iter::flat_map_to_vec(self, op)
+   fn flat_map_to_vec<B:Copy, IB:BaseIter<B>>(op: fn(+a: A) -> IB) -> ~[B] {
+     iter::flat_map_to_vec(&self, op)
    }
 }
 
diff --git a/src/test/run-pass/issue-2718.rs b/src/test/run-pass/issue-2718.rs
index 6da4349ba5f..b887b86cf2f 100644
--- a/src/test/run-pass/issue-2718.rs
+++ b/src/test/run-pass/issue-2718.rs
@@ -201,7 +201,7 @@ mod pingpong {
 
     fn liberate_ping(-p: ping) -> pipes::send_packet<pong> unsafe {
         let addr : *pipes::send_packet<pong> = match p {
-          ping(x) => { cast::transmute(ptr::addr_of(x)) }
+          ping(x) => { cast::transmute(ptr::addr_of(&x)) }
         };
         let liberated_value <- *addr;
         cast::forget(p);
@@ -210,7 +210,7 @@ mod pingpong {
 
     fn liberate_pong(-p: pong) -> pipes::send_packet<ping> unsafe {
         let addr : *pipes::send_packet<ping> = match p {
-          pong(x) => { cast::transmute(ptr::addr_of(x)) }
+          pong(x) => { cast::transmute(ptr::addr_of(&x)) }
         };
         let liberated_value <- *addr;
         cast::forget(p);
diff --git a/src/test/run-pass/issue-2804.rs b/src/test/run-pass/issue-2804.rs
index 9088f6e3584..7ef4ef22560 100644
--- a/src/test/run-pass/issue-2804.rs
+++ b/src/test/run-pass/issue-2804.rs
@@ -1,6 +1,7 @@
 extern mod std;
 use io::WriterUtil;
 use std::map::HashMap;
+use std::json;
 
 enum object
 {
@@ -8,13 +9,13 @@ enum object
     int_value(i64),
 }
 
-fn lookup(table: std::map::HashMap<~str, std::json::Json>, key: ~str, default: ~str) -> ~str
+fn lookup(table: ~json::Object, key: ~str, default: ~str) -> ~str
 {
-    match table.find(key)
+    match table.find(&key)
     {
         option::Some(std::json::String(s)) =>
         {
-            *s
+            s
         }
         option::Some(value) =>
         {
@@ -32,7 +33,7 @@ fn add_interface(store: int, managed_ip: ~str, data: std::json::Json) -> (~str,
 {
     match data
     {
-        std::json::Dict(interface) =>
+        std::json::Object(interface) =>
         {
             let name = lookup(interface, ~"ifDescr", ~"");
             let label = fmt!("%s-%s", managed_ip, name);
@@ -53,7 +54,7 @@ fn add_interfaces(store: int, managed_ip: ~str, device: std::map::HashMap<~str,
     {
         std::json::List(interfaces) =>
         {
-          do vec::map(*interfaces) |interface| {
+          do vec::map(interfaces) |interface| {
                 add_interface(store, managed_ip, *interface)
           }
         }
diff --git a/src/test/run-pass/issue-2904.rs b/src/test/run-pass/issue-2904.rs
index 704e8f79fb1..6d771dc7386 100644
--- a/src/test/run-pass/issue-2904.rs
+++ b/src/test/run-pass/issue-2904.rs
@@ -1,5 +1,7 @@
 /// Map representation
 
+use io::ReaderUtil;
+
 extern mod std;
 
 enum square {
@@ -50,10 +52,10 @@ fn read_board_grid<rdr: Owned io::Reader>(+in: rdr) -> ~[~[square]] {
     let mut grid = ~[];
     for in.each_line |line| {
         let mut row = ~[];
-        for line.each_char |c| {
-            vec::push(row, square_from_char(c))
+        for str::each_char(line) |c| {
+            row.push(square_from_char(c))
         }
-        vec::push(grid, row)
+        grid.push(row)
     }
     let width = grid[0].len();
     for grid.each |row| { assert row.len() == width }
diff --git a/src/test/run-pass/issue-783.rs b/src/test/run-pass/issue-783.rs
index 752101e651b..a9c6fed8eca 100644
--- a/src/test/run-pass/issue-783.rs
+++ b/src/test/run-pass/issue-783.rs
@@ -1,6 +1,6 @@
 extern mod std;
 use comm::*;
-use task::*;
+use task::spawn;
 
 fn a() {
     fn doit() {
diff --git a/src/test/run-pass/iter-all.rs b/src/test/run-pass/iter-all.rs
index eb5dbd6aa5c..75334db86cc 100644
--- a/src/test/run-pass/iter-all.rs
+++ b/src/test/run-pass/iter-all.rs
@@ -1,4 +1,4 @@
-fn is_even(&&x: uint) -> bool { (x % 2u) == 0u }
+fn is_even(x: &uint) -> bool { (*x % 2) == 0 }
 
 fn main() {
     assert ![1u, 2u]/_.all(is_even);
diff --git a/src/test/run-pass/iter-any.rs b/src/test/run-pass/iter-any.rs
index d672df09c24..22057b74a41 100644
--- a/src/test/run-pass/iter-any.rs
+++ b/src/test/run-pass/iter-any.rs
@@ -1,11 +1,11 @@
-fn is_even(&&x: uint) -> bool { (x % 2u) == 0u }
+fn is_even(x: &uint) -> bool { (*x % 2) == 0 }
 
 fn main() {
     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);
+    assert !Some(1).any(is_even);
+    assert Some(2).any(is_even);
     assert !None.any(is_even);
 }
diff --git a/src/test/run-pass/iter-contains.rs b/src/test/run-pass/iter-contains.rs
index 43bce3e7dcb..6036b5b2d24 100644
--- a/src/test/run-pass/iter-contains.rs
+++ b/src/test/run-pass/iter-contains.rs
@@ -1,10 +1,10 @@
 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 None.contains(22u) == false;
-    assert Some(1u).contains(22u) == false;
-    assert Some(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 ba22cc7710b..0b6f94367be 100644
--- a/src/test/run-pass/iter-count.rs
+++ b/src/test/run-pass/iter-count.rs
@@ -1,9 +1,9 @@
 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 None.count(22u) == 0u;
-    assert Some(1u).count(22u) == 0u;
-    assert Some(22u).count(22u) == 1u;
+    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-filter-to-vec.rs b/src/test/run-pass/iter-filter-to-vec.rs
index 8cb9e0e9d53..f96b18f140a 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 is_even(+x: uint) -> bool { (x % 2) == 0 }
 
 fn main() {
-    assert [1u, 3u]/_.filter_to_vec(is_even) == ~[];
-    assert [1u, 2u, 3u]/_.filter_to_vec(is_even) == ~[2u];
+    assert [1, 3]/_.filter_to_vec(is_even) == ~[];
+    assert [1, 2, 3]/_.filter_to_vec(is_even) == ~[2];
     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 Some(1).filter_to_vec(is_even) == ~[];
+    assert Some(2).filter_to_vec(is_even) == ~[2];
 }
diff --git a/src/test/run-pass/iter-foldl.rs b/src/test/run-pass/iter-foldl.rs
index 41bb6b82ddd..bbc1673f686 100644
--- a/src/test/run-pass/iter-foldl.rs
+++ b/src/test/run-pass/iter-foldl.rs
@@ -1,4 +1,4 @@
-fn add(&&x: float, &&y: uint) -> float { x + (y as float) }
+fn add(x: &float, y: &uint) -> float { *x + ((*y) as float) }
 
 fn main() {
     assert [1u, 3u]/_.foldl(20f, add) == 24f;
diff --git a/src/test/run-pass/iter-map-to-vec.rs b/src/test/run-pass/iter-map-to-vec.rs
index 11f2cc1efb1..2f5359f197f 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 inc(+x: uint) -> uint { x + 1 }
 
 fn main() {
-    assert [1u, 3u]/_.map_to_vec(inc) == ~[2u, 4u];
-    assert [1u, 2u, 3u]/_.map_to_vec(inc) == ~[2u, 3u, 4u];
+    assert [1, 3]/_.map_to_vec(inc) == ~[2, 4];
+    assert [1, 2, 3]/_.map_to_vec(inc) == ~[2, 3, 4];
     assert None.map_to_vec(inc) == ~[];
-    assert Some(1u).map_to_vec(inc) == ~[2u];
-    assert Some(2u).map_to_vec(inc) == ~[3u];
+    assert Some(1).map_to_vec(inc) == ~[2];
+    assert Some(2).map_to_vec(inc) == ~[3];
 }
diff --git a/src/test/run-pass/last-use-corner-cases.rs b/src/test/run-pass/last-use-corner-cases.rs
index 2d8e3aa7b8c..a3088a2c125 100644
--- a/src/test/run-pass/last-use-corner-cases.rs
+++ b/src/test/run-pass/last-use-corner-cases.rs
@@ -4,14 +4,14 @@
 fn main() {
     // Make sure closing over can be a last use
     let q = ~10;
-    let addr = ptr::addr_of(*q);
-    let f = fn@() -> *int { ptr::addr_of(*q) };
+    let addr = ptr::addr_of(&(*q));
+    let f = fn@() -> *int { ptr::addr_of(&(*q)) };
     assert addr == f();
 
     // But only when it really is the last use
     let q = ~20;
-    let f = fn@() -> *int { ptr::addr_of(*q) };
-    assert ptr::addr_of(*q) != f();
+    let f = fn@() -> *int { ptr::addr_of(&(*q)) };
+    assert ptr::addr_of(&(*q)) != f();
 
     // Ensure function arguments and box arguments interact sanely.
     fn call_me(x: fn() -> int, y: ~int) { assert x() == *y; }
diff --git a/src/test/run-pass/numeric-method-autoexport.rs b/src/test/run-pass/numeric-method-autoexport.rs
index 6a3676227cc..f2882b91983 100644
--- a/src/test/run-pass/numeric-method-autoexport.rs
+++ b/src/test/run-pass/numeric-method-autoexport.rs
@@ -5,11 +5,11 @@
 fn main() {
 // ints
     // num
-    assert 15.add(6) == 21;
-    assert 15i8.add(6i8) == 21i8;
-    assert 15i16.add(6i16) == 21i16;
-    assert 15i32.add(6i32) == 21i32;
-    assert 15i64.add(6i64) == 21i64;
+    assert 15.add(&6) == 21;
+    assert 15i8.add(&6i8) == 21i8;
+    assert 15i16.add(&6i16) == 21i16;
+    assert 15i32.add(&6i32) == 21i32;
+    assert 15i64.add(&6i64) == 21i64;
     // times
      15.times(|| false);
      15i8.times(|| false);
@@ -19,11 +19,11 @@ fn main() {
 
 // uints
     // num
-    assert 15u.add(6u) == 21u;
-    assert 15u8.add(6u8) == 21u8;
-    assert 15u16.add(6u16) == 21u16;
-    assert 15u32.add(6u32) == 21u32;
-    assert 15u64.add(6u64) == 21u64;
+    assert 15u.add(&6u) == 21u;
+    assert 15u8.add(&6u8) == 21u8;
+    assert 15u16.add(&6u16) == 21u16;
+    assert 15u32.add(&6u32) == 21u32;
+    assert 15u64.add(&6u64) == 21u64;
     // times
      15u.times(|| false);
      15u8.times(|| false);
diff --git a/src/test/run-pass/operator-overloading.rs b/src/test/run-pass/operator-overloading.rs
index d5af5a54377..2215b49937f 100644
--- a/src/test/run-pass/operator-overloading.rs
+++ b/src/test/run-pass/operator-overloading.rs
@@ -25,7 +25,7 @@ impl Point : ops::Neg<Point> {
 }
 
 impl Point : ops::Index<bool,int> {
-    pure fn index(&&x: bool) -> int {
+    pure fn index(+x: bool) -> int {
         if x { self.x } else { self.y }
     }
 }
diff --git a/src/test/run-pass/pipe-bank-proto.rs b/src/test/run-pass/pipe-bank-proto.rs
index 8ac76293284..899b74b2866 100644
--- a/src/test/run-pass/pipe-bank-proto.rs
+++ b/src/test/run-pass/pipe-bank-proto.rs
@@ -33,7 +33,7 @@ proto! bank (
 )
 
 macro_rules! move_it (
-    { $x:expr } => { unsafe { let y <- *ptr::addr_of($x); y } }
+    { $x:expr } => { unsafe { let y <- *ptr::addr_of(&($x)); y } }
 )
 
 fn switch<T: Send, U>(+endp: pipes::RecvPacket<T>,
diff --git a/src/test/run-pass/pipe-pingpong-bounded.rs b/src/test/run-pass/pipe-pingpong-bounded.rs
index f9f091131ab..9bfbbe338e7 100644
--- a/src/test/run-pass/pipe-pingpong-bounded.rs
+++ b/src/test/run-pass/pipe-pingpong-bounded.rs
@@ -28,7 +28,7 @@ mod pingpong {
         do pipes::entangle_buffer(buffer) |buffer, data| {
             data.ping.set_buffer_(buffer);
             data.pong.set_buffer_(buffer);
-            ptr::addr_of(data.ping)
+            ptr::addr_of(&(data.ping))
         }
     }
     enum ping = server::pong;
@@ -38,8 +38,8 @@ mod pingpong {
         fn ping(+pipe: ping) -> pong {
             {
                 let b = pipe.reuse_buffer();
-                let s = SendPacketBuffered(ptr::addr_of(b.buffer.data.pong));
-                let c = RecvPacketBuffered(ptr::addr_of(b.buffer.data.pong));
+                let s = SendPacketBuffered(ptr::addr_of(&(b.buffer.data.pong)));
+                let c = RecvPacketBuffered(ptr::addr_of(&(b.buffer.data.pong)));
                 let message = pingpong::ping(s);
                 pipes::send(pipe, message);
                 c
@@ -57,8 +57,8 @@ mod pingpong {
         fn pong(+pipe: pong) -> ping {
             {
                 let b = pipe.reuse_buffer();
-                let s = SendPacketBuffered(ptr::addr_of(b.buffer.data.ping));
-                let c = RecvPacketBuffered(ptr::addr_of(b.buffer.data.ping));
+                let s = SendPacketBuffered(ptr::addr_of(&(b.buffer.data.ping)));
+                let c = RecvPacketBuffered(ptr::addr_of(&(b.buffer.data.ping)));
                 let message = pingpong::pong(s);
                 pipes::send(pipe, message);
                 c
diff --git a/src/test/run-pass/reexport-star.rs b/src/test/run-pass/reexport-star.rs
new file mode 100644
index 00000000000..1709ddc70f2
--- /dev/null
+++ b/src/test/run-pass/reexport-star.rs
@@ -0,0 +1,14 @@
+mod a {
+    pub fn f() {}
+    pub fn g() {}
+}
+
+mod b {
+    pub use a::*;
+}
+
+fn main() {
+    b::f();
+    b::g();
+}
+
diff --git a/src/test/run-pass/reflect-visit-data.rs b/src/test/run-pass/reflect-visit-data.rs
index affd0ef6162..e27aaa618ac 100644
--- a/src/test/run-pass/reflect-visit-data.rs
+++ b/src/test/run-pass/reflect-visit-data.rs
@@ -612,7 +612,7 @@ fn get_tydesc_for<T>(&&_t: T) -> *TyDesc {
 
 fn main() {
     let r = (1,2,3,true,false,{x:5,y:4,z:3});
-    let p = ptr::addr_of(r) as *c_void;
+    let p = ptr::addr_of(&r) as *c_void;
     let u = my_visitor(@{mut ptr1: p,
                          mut ptr2: p,
                          mut vals: ~[]});
diff --git a/src/test/run-pass/resource-cycle.rs b/src/test/run-pass/resource-cycle.rs
index 9e0a2c35e2f..26e19ee1b0c 100644
--- a/src/test/run-pass/resource-cycle.rs
+++ b/src/test/run-pass/resource-cycle.rs
@@ -4,8 +4,8 @@ struct r {
   v: *int,
   drop unsafe {
     debug!("r's dtor: self = %x, self.v = %x, self.v's value = %x",
-           cast::reinterpret_cast::<*r, uint>(&ptr::addr_of(self)),
-           cast::reinterpret_cast::<**int, uint>(&ptr::addr_of(self.v)),
+           cast::reinterpret_cast::<*r, uint>(&ptr::addr_of(&self)),
+           cast::reinterpret_cast::<**int, uint>(&ptr::addr_of(&(self.v))),
            cast::reinterpret_cast::<*int, uint>(&self.v));
     let v2: ~int = cast::reinterpret_cast(&self.v); }
 }
@@ -34,27 +34,27 @@ fn main() unsafe {
           r: {
           let rs = r(i1p);
           debug!("r = %x",
-                 cast::reinterpret_cast::<*r, uint>(&ptr::addr_of(rs)));
+                 cast::reinterpret_cast::<*r, uint>(&ptr::addr_of(&rs)));
           rs }
     });
     
     debug!("x1 = %x, x1.r = %x",
         cast::reinterpret_cast::<@t, uint>(&x1),
-        cast::reinterpret_cast::<*r, uint>(&ptr::addr_of(x1.r)));
+        cast::reinterpret_cast::<*r, uint>(&ptr::addr_of(&(x1.r))));
 
     let x2 = @t({
         mut next: None,
           r: {
           let rs = r(i2p);
           debug!("r2 = %x",
-                 cast::reinterpret_cast::<*r, uint>(&ptr::addr_of(rs)));
+                 cast::reinterpret_cast::<*r, uint>(&ptr::addr_of(&rs)));
           rs
             }
     });
     
     debug!("x2 = %x, x2.r = %x",
            cast::reinterpret_cast::<@t, uint>(&x2),
-           cast::reinterpret_cast::<*r, uint>(&ptr::addr_of(x2.r)));
+           cast::reinterpret_cast::<*r, uint>(&ptr::addr_of(&(x2.r))));
 
     x1.next = Some(x2);
     x2.next = Some(x1);
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 9013842ba8b..4e7e978cf55 100644
--- a/src/test/run-pass/ret-break-cont-in-block.rs
+++ b/src/test/run-pass/ret-break-cont-in-block.rs
@@ -43,10 +43,10 @@ fn ret_deep() -> ~str {
 fn main() {
     let mut last = 0;
     for vec::all(~[1, 2, 3, 4, 5, 6, 7]) |e| {
-        last = e;
-        if e == 5 { break; }
-        if e % 2 == 1 { loop; }
-        assert e % 2 == 0;
+        last = *e;
+        if *e == 5 { break; }
+        if *e % 2 == 1 { loop; }
+        assert *e % 2 == 0;
     };
     assert last == 5;
 
diff --git a/src/test/run-pass/rt-sched-1.rs b/src/test/run-pass/rt-sched-1.rs
index 9604dff64d7..15207b668fe 100644
--- a/src/test/run-pass/rt-sched-1.rs
+++ b/src/test/run-pass/rt-sched-1.rs
@@ -33,7 +33,7 @@ fn main() unsafe {
         assert child_sched_id == new_sched_id;
         comm::send(ch, ());
     };
-    let fptr = cast::reinterpret_cast(&ptr::addr_of(f));
+    let fptr = cast::reinterpret_cast(&ptr::addr_of(&f));
     rustrt::start_task(new_task_id, fptr);
     cast::forget(f);
     comm::recv(po);
diff --git a/src/test/run-pass/select-macro.rs b/src/test/run-pass/select-macro.rs
index 15dd56e46c5..78bddffcc1d 100644
--- a/src/test/run-pass/select-macro.rs
+++ b/src/test/run-pass/select-macro.rs
@@ -28,7 +28,7 @@ macro_rules! select_if (
             match move pipes::try_recv($port) {
               $(Some($message($($(ref $x,)+)* ref next)) => {
                 // FIXME (#2329) we really want move out of enum here.
-                let $next = unsafe { let x <- *ptr::addr_of(*next); x };
+                let $next = unsafe { let x <- *ptr::addr_of(&(*next)); x };
                 $e
               })+
               _ => fail
diff --git a/src/test/run-pass/stable-addr-of.rs b/src/test/run-pass/stable-addr-of.rs
index 060994ed48f..dceb80331b4 100644
--- a/src/test/run-pass/stable-addr-of.rs
+++ b/src/test/run-pass/stable-addr-of.rs
@@ -2,5 +2,5 @@
 
 fn main() {
     let foo = 1;
-    assert ptr::addr_of(foo) == ptr::addr_of(foo);
+    assert ptr::addr_of(&foo) == ptr::addr_of(&foo);
 }
diff --git a/src/test/run-pass/task-comm-3.rs b/src/test/run-pass/task-comm-3.rs
index dd2dd5e54d4..4faac4fdac1 100644
--- a/src/test/run-pass/task-comm-3.rs
+++ b/src/test/run-pass/task-comm-3.rs
@@ -34,7 +34,7 @@ fn test00() {
     while i < number_of_tasks {
         let ch = po.chan();
         do task::task().future_result(|+r| {
-            vec::push(results, r);
+            results.push(r);
         }).spawn |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 a3a6b6efd7f..8d144b1a399 100644
--- a/src/test/run-pass/task-comm.rs
+++ b/src/test/run-pass/task-comm.rs
@@ -40,7 +40,7 @@ fn test00() {
     while i < number_of_tasks {
         i = i + 1;
         do task::task().future_result(|+r| {
-            vec::push(results, r);
+            results.push(r);
         }).spawn |copy i| {
             test00_start(ch, i, number_of_messages);
         }
@@ -127,7 +127,7 @@ fn test06() {
     while i < number_of_tasks {
         i = i + 1;
         do task::task().future_result(|+r| {
-            vec::push(results, r);
+            results.push(r);
         }).spawn |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 98d5193c86d..405ba82b790 100644
--- a/src/test/run-pass/task-killjoin-rsrc.rs
+++ b/src/test/run-pass/task-killjoin-rsrc.rs
@@ -10,7 +10,7 @@ struct notify {
     drop {
         error!("notify: task=%? v=%x unwinding=%b b=%b",
                task::get_task(),
-               ptr::addr_of(*(self.v)) as uint,
+               ptr::addr_of(&(*(self.v))) as uint,
                task::failing(),
                *(self.v));
         let b = *(self.v);
@@ -30,7 +30,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/task-spawn-move-and-copy.rs b/src/test/run-pass/task-spawn-move-and-copy.rs
index 9cedfea6130..7316a927751 100644
--- a/src/test/run-pass/task-spawn-move-and-copy.rs
+++ b/src/test/run-pass/task-spawn-move-and-copy.rs
@@ -3,16 +3,16 @@ fn main() {
     let ch = comm::Chan(p);
 
     let x = ~1;
-    let x_in_parent = ptr::addr_of(*x) as uint;
+    let x_in_parent = ptr::addr_of(&(*x)) as uint;
 
     let y = ~2;
-    let y_in_parent = ptr::addr_of(*y) as uint;
+    let y_in_parent = ptr::addr_of(&(*y)) as uint;
 
     task::spawn(fn~(copy ch, copy y, move x) {
-        let x_in_child = ptr::addr_of(*x) as uint;
+        let x_in_child = ptr::addr_of(&(*x)) as uint;
         comm::send(ch, x_in_child);
 
-        let y_in_child = ptr::addr_of(*y) as uint;
+        let y_in_child = ptr::addr_of(&(*y)) as uint;
         comm::send(ch, y_in_child);
     });
     // Ensure last-use analysis doesn't move y to child.
diff --git a/src/test/run-pass/uniq-cc-generic.rs b/src/test/run-pass/uniq-cc-generic.rs
index 18c3db591f6..592d49cc2a8 100644
--- a/src/test/run-pass/uniq-cc-generic.rs
+++ b/src/test/run-pass/uniq-cc-generic.rs
@@ -9,7 +9,7 @@ type pointy = {
 };
 
 fn make_uniq_closure<A:Send Copy>(a: A) -> fn~() -> uint {
-    fn~() -> uint { ptr::addr_of(a) as uint }
+    fn~() -> uint { ptr::addr_of(&a) as uint }
 }
 
 fn empty_pointy() -> @pointy {
diff --git a/src/test/run-pass/unnamed_argument_mode.rs b/src/test/run-pass/unnamed_argument_mode.rs
new file mode 100644
index 00000000000..97e7582e142
--- /dev/null
+++ b/src/test/run-pass/unnamed_argument_mode.rs
@@ -0,0 +1,11 @@
+fn good(a: &int) {
+}
+
+// unnamed argument &int is now parse x: &int
+
+fn called(f: fn(&int)) {
+}
+
+fn main() {
+called(good);
+}
diff --git a/src/test/run-pass/vec-push.rs b/src/test/run-pass/vec-push.rs
index 3e47f7e0a3b..d4190d41386 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]; v.push(1); }
diff --git a/src/test/run-pass/zip-same-length.rs b/src/test/run-pass/zip-same-length.rs
index 61e359129fe..9b8304792fa 100644
--- a/src/test/run-pass/zip-same-length.rs
+++ b/src/test/run-pass/zip-same-length.rs
@@ -7,7 +7,7 @@ fn enum_chars(start: u8, end: u8) -> ~[char] {
     assert start < end;
     let mut i = start;
     let mut r = ~[];
-    while i <= end { vec::push(r, i as char); i += 1u as u8; }
+    while i <= end { r.push(i as char); i += 1u as u8; }
     return r;
 }
 
@@ -15,7 +15,7 @@ fn enum_uints(start: uint, end: uint) -> ~[uint] {
     assert start < end;
     let mut i = start;
     let mut r = ~[];
-    while i <= end { vec::push(r, i); i += 1u; }
+    while i <= end { r.push(i); i += 1u; }
     return r;
 }