test: Fix tests and the pipe compiler

src/libcore/repr.rs

@@ -448,10 +448,15 @@ impl TyVisitor for ReprVisitor {
         true
     }
 
-    fn visit_enter_enum(&self, _n_variants: uint,
+    fn visit_enter_enum(&self,
+                        _n_variants: uint,
                         get_disr: extern unsafe fn(ptr: *Opaque) -> int,
-                        _sz: uint, _align: uint) -> bool {
-        let disr = unsafe { get_disr(transmute(self.ptr)) };
+                        _sz: uint,
+                        _align: uint) -> bool {
+        let var_stk: &mut ~[VariantState] = self.var_stk;
+        let disr = unsafe {
+            get_disr(transmute(*self.ptr))
+        };
         self.var_stk.push(SearchingFor(disr));
         true
     }
@@ -484,31 +489,12 @@ impl TyVisitor for ReprVisitor {
         true
     }
 
-<<<<<<< HEAD
-    fn visit_enum_variant_field(&self, i: uint, _offset: uint, inner: *TyDesc) -> bool {
-        match self.var_stk[vec::uniq_len(&const self.var_stk) - 1] {
-=======
-    #[cfg(stage0)]
-    fn visit_enum_variant_field(&self, i: uint, inner: *TyDesc) -> bool {
-        match self.var_stk[vec::uniq_len(&const *self.var_stk) - 1] {
-            Degenerate | TagMatch => {
-                if i != 0 {
-                    self.writer.write_str(", ");
-                }
-                if ! self.visit_inner(inner) {
-                    return false;
-                }
-            }
-            TagMismatch => ()
-        }
-        true
-    }
-
-    #[cfg(not(stage0))]
-    fn visit_enum_variant_field(&self, i: uint, _: uint, inner: *TyDesc)
+    fn visit_enum_variant_field(&self,
+                                i: uint,
+                                _offset: uint,
+                                inner: *TyDesc)
                                 -> bool {
-        match self.var_stk[vec::uniq_len(&const *self.var_stk) - 1] {
->>>>>>> libcore: Remove mutable fields from repr
+        match self.var_stk[vec::uniq_len(&const self.var_stk) - 1] {
             Matched => {
                 if i != 0 {
                     self.writer.write_str(", ");
@@ -522,26 +508,6 @@ impl TyVisitor for ReprVisitor {
         true
     }
 
-<<<<<<< HEAD
-=======
-    #[cfg(stage0)]
-    fn visit_leave_enum_variant(&self, _variant: uint,
-                                _disr_val: int,
-                                n_fields: uint,
-                                _name: &str) -> bool {
-        match self.var_stk[vec::uniq_len(&const *self.var_stk) - 1] {
-            Degenerate | TagMatch => {
-                if n_fields > 0 {
-                    self.writer.write_char(')');
-                }
-            }
-            TagMismatch => ()
-        }
-        true
-    }
-
-    #[cfg(not(stage0))]
->>>>>>> libcore: Remove mutable fields from repr
     fn visit_leave_enum_variant(&self, _variant: uint,
                                 _disr_val: int,
                                 n_fields: uint,
@@ -557,9 +523,13 @@ impl TyVisitor for ReprVisitor {
         true
     }
 
-    fn visit_leave_enum(&self, _n_variants: uint,
+    fn visit_leave_enum(&self,
+                        _n_variants: uint,
                         _get_disr: extern unsafe fn(ptr: *Opaque) -> int,
-                        _sz: uint, _align: uint) -> bool {
+                        _sz: uint,
+                        _align: uint)
+                        -> bool {
+        let var_stk: &mut ~[VariantState] = self.var_stk;
         match self.var_stk.pop() {
             SearchingFor(*) => fail!(~"enum value matched no variant"),
             _ => true

src/libcore/task/mod.rs

@@ -230,12 +230,14 @@ pub impl TaskBuilder {
     /// the child.
     fn supervised(&mut self) {
         self.opts.supervised = true;
+        self.opts.linked = false;
     }
 
     /// Link the child task's and parent task's failures. If either fails, the
     /// other will be killed.
     fn linked(&mut self) {
         self.opts.linked = true;
+        self.opts.supervised = false;
     }
 
     /**

src/libsyntax/ext/pipes/pipec.rs

@@ -64,6 +64,7 @@ impl gen_send for message {
 
             let mut body = ~"{\n";
             body += fmt!("use super::%s;\n", name);
+            body += ~"let mut pipe = pipe;\n";
 
             if this.proto.is_bounded() {
                 let (sp, rp) = match (this.dir, next.dir) {
@@ -73,12 +74,12 @@ impl gen_send for message {
                   (recv, recv) => (~"c", ~"s")
                 };
 
-                body += ~"let b = pipe.reuse_buffer();\n";
+                body += ~"let mut b = pipe.reuse_buffer();\n";
                 body += fmt!("let %s = ::core::pipes::SendPacketBuffered(\
-                              &(b.buffer.data.%s));\n",
+                              &mut (b.buffer.data.%s));\n",
                              sp, next.name);
                 body += fmt!("let %s = ::core::pipes::RecvPacketBuffered(\
-                              &(b.buffer.data.%s));\n",
+                              &mut (b.buffer.data.%s));\n",
                              rp, next.name);
             }
             else {
@@ -366,7 +367,7 @@ impl gen_init for protocol {
                         fmt!("data.%s.set_buffer(buffer)",
                              s.name))),
                 ext_cx.parse_expr(fmt!(
-                    "::core::ptr::to_unsafe_ptr(&(data.%s))",
+                    "::core::ptr::to_mut_unsafe_ptr(&mut (data.%s))",
                     self.states[0].name))));
 
         quote_expr!({

src/test/bench/core-map.rs

@@ -103,7 +103,7 @@ fn main() {
     let mut rand = vec::with_capacity(n_keys);
 
     {
-        let rng = core::rand::IsaacRng::new_seeded([1, 1, 1, 1, 1, 1, 1]);
+        let mut rng = core::rand::IsaacRng::new_seeded([1, 1, 1, 1, 1, 1, 1]);
         let mut set = HashSet::new();
         while set.len() != n_keys {
             let next = rng.next() as uint;

src/test/bench/core-set.rs

@@ -31,8 +31,13 @@ fn timed(result: &mut float, op: &fn()) {
 }
 
 pub impl Results {
-    fn bench_int<T:Set<uint>, R: rand::Rng>(&mut self, rng: &R, num_keys: uint,
-                               rand_cap: uint, f: &fn() -> T) {
+    fn bench_int<T:Set<uint>,
+                 R: rand::Rng>(
+                 &mut self,
+                 rng: &mut R,
+                 num_keys: uint,
+                 rand_cap: uint,
+                 f: &fn() -> T) {
         {
             let mut set = f();
             do timed(&mut self.sequential_ints) {
@@ -69,8 +74,12 @@ pub impl Results {
         }
     }
 
-    fn bench_str<T:Set<~str>, R: rand::Rng>(&mut self, rng: &R, num_keys: uint,
-                                            f: &fn() -> T) {
+    fn bench_str<T:Set<~str>,
+                 R:rand::Rng>(
+                 &mut self,
+                 rng: &mut R,
+                 num_keys: uint,
+                 f: &fn() -> T) {
         {
             let mut set = f();
             do timed(&mut self.sequential_strings) {
@@ -155,25 +164,25 @@ fn main() {
     let max = 200000;
 
     {
-        let rng = rand::IsaacRng::new_seeded(seed);
+        let mut rng = rand::IsaacRng::new_seeded(seed);
         let mut results = empty_results();
-        results.bench_int(&rng, num_keys, max, || HashSet::new::<uint>());
-        results.bench_str(&rng, num_keys, || HashSet::new::<~str>());
+        results.bench_int(&mut rng, num_keys, max, || HashSet::new::<uint>());
+        results.bench_str(&mut rng, num_keys, || HashSet::new::<~str>());
         write_results("core::hashmap::HashSet", &results);
     }
 
     {
-        let rng = rand::IsaacRng::new_seeded(seed);
+        let mut rng = rand::IsaacRng::new_seeded(seed);
         let mut results = empty_results();
-        results.bench_int(&rng, num_keys, max, || TreeSet::new::<uint>());
-        results.bench_str(&rng, num_keys, || TreeSet::new::<~str>());
+        results.bench_int(&mut rng, num_keys, max, || TreeSet::new::<uint>());
+        results.bench_str(&mut rng, num_keys, || TreeSet::new::<~str>());
         write_results("std::treemap::TreeSet", &results);
     }
 
     {
-        let rng = rand::IsaacRng::new_seeded(seed);
+        let mut rng = rand::IsaacRng::new_seeded(seed);
         let mut results = empty_results();
-        results.bench_int(&rng, num_keys, max, || BitvSet::new());
+        results.bench_int(&mut rng, num_keys, max, || BitvSet::new());
         write_results("std::bitv::BitvSet", &results);
     }
 }

src/test/bench/core-std.rs

@@ -33,12 +33,15 @@ fn main() {
 fn maybe_run_test(argv: &[~str], name: ~str, test: &fn()) {
     let mut run_test = false;
 
-    if os::getenv(~"RUST_BENCH").is_some() { run_test = true }
-    else if argv.len() > 0 {
+    if os::getenv(~"RUST_BENCH").is_some() {
+        run_test = true
+    } else if argv.len() > 0 {
         run_test = argv.contains(&~"all") || argv.contains(&name)
     }
 
-    if !run_test { return }
+    if !run_test {
+        return
+    }
 
     let start = precise_time_s();
     test();
@@ -69,7 +72,7 @@ fn read_line() {
 }
 
 fn vec_plus() {
-    let r = rand::rng();
+    let mut r = rand::rng();
 
     let mut v = ~[];
     let mut i = 0;
@@ -86,7 +89,7 @@ fn vec_plus() {
 }
 
 fn vec_append() {
-    let r = rand::rng();
+    let mut r = rand::rng();
 
     let mut v = ~[];
     let mut i = 0;
@@ -103,7 +106,7 @@ fn vec_append() {
 }
 
 fn vec_push_all() {
-    let r = rand::rng();
+    let mut r = rand::rng();
 
     let mut v = ~[];
     for uint::range(0, 1500) |i| {

src/test/bench/graph500-bfs.rs

@@ -32,19 +32,20 @@ type graph = ~[~[node_id]];
 type bfs_result = ~[node_id];
 
 fn make_edges(scale: uint, edgefactor: uint) -> ~[(node_id, node_id)] {
-    let r = rand::XorShiftRng::new();
-
-    fn choose_edge<R: rand::Rng>(i: node_id, j: node_id, scale: uint, r: &R)
-        -> (node_id, node_id) {
+    let mut r = rand::XorShiftRng::new();
 
+    fn choose_edge<R: rand::Rng>(i: node_id,
+                                 j: node_id,
+                                 scale: uint,
+                                 r: &mut R)
+                                 -> (node_id, node_id) {
         let A = 0.57;
         let B = 0.19;
         let C = 0.19;
 
         if scale == 0u {
             (i, j)
-        }
-        else {
+        } else {
             let i = i * 2i64;
             let j = j * 2i64;
             let scale = scale - 1u;
@@ -73,7 +74,7 @@ fn make_edges(scale: uint, edgefactor: uint) -> ~[(node_id, node_id)] {
     }
 
     do vec::from_fn((1u << scale) * edgefactor) |_i| {
-        choose_edge(0i64, 0i64, scale, &r)
+        choose_edge(0i64, 0i64, scale, &mut r)
     }
 }
 
@@ -103,7 +104,7 @@ fn make_graph(N: uint, edges: ~[(node_id, node_id)]) -> graph {
 
 fn gen_search_keys(graph: &[~[node_id]], n: uint) -> ~[node_id] {
     let mut keys = HashSet::new();
-    let r = rand::rng();
+    let mut r = rand::rng();
 
     while keys.len() < n {
         let k = r.gen_uint_range(0u, graph.len());

src/test/bench/msgsend-pipes-shared.rs

@@ -65,15 +65,15 @@ fn run(args: &[~str]) {
     let mut worker_results = ~[];
     for uint::range(0, workers) |_i| {
         let to_child = to_child.clone();
-        do task::task().future_result(|+r| {
-            worker_results.push(r);
-        }).spawn || {
+        let mut builder = task::task();
+        builder.future_result(|r| worker_results.push(r));
+        do builder.spawn {
             for uint::range(0, size / workers) |_i| {
                 //error!("worker %?: sending %? bytes", i, num_bytes);
                 to_child.send(bytes(num_bytes));
             }
             //error!("worker %? exiting", i);
-        };
+        }
     }
     do task::spawn || {
         server(&from_parent, &to_parent);

src/test/bench/msgsend-pipes.rs

@@ -62,9 +62,9 @@ fn run(args: &[~str]) {
     for uint::range(0, workers) |_i| {
         let (from_parent_, to_child) = stream();
         from_parent.add(from_parent_);
-        do task::task().future_result(|+r| {
-            worker_results.push(r);
-        }).spawn || {
+        let mut builder = task::task();
+        builder.future_result(|r| worker_results.push(r));
+        do builder.spawn {
             for uint::range(0, size / workers) |_i| {
                 //error!("worker %?: sending %? bytes", i, num_bytes);
                 to_child.send(bytes(num_bytes));

src/test/bench/msgsend-ring-mutex-arcs.rs

@@ -103,7 +103,9 @@ fn main() {
     thread_ring(0, msg_per_task, num_chan.take(), num_port);
 
     // synchronize
-    for futures.each |f| { f.get() };
+    for futures.each_mut |f| {
+        f.get()
+    }
 
     let stop = time::precise_time_s();
 

src/test/bench/msgsend-ring-pipes.rs

@@ -96,7 +96,9 @@ fn main() {
     thread_ring(0, msg_per_task, num_chan.take(), num_port);
 
     // synchronize
-    for futures.each |f| { f.get() };
+    for futures.each_mut |f| {
+        let _ = f.get();
+    }
 
     let stop = time::precise_time_s();
 

src/test/bench/msgsend-ring-rw-arcs.rs

@@ -104,7 +104,9 @@ fn main() {
     thread_ring(0, msg_per_task, num_chan.take(), num_port);
 
     // synchronize
-    for futures.each |f| { f.get() };
+    for futures.each_mut |f| {
+        let _ = f.get();
+    }
 
     let stop = time::precise_time_s();
 

src/test/bench/noise.rs

@@ -13,7 +13,7 @@ fn lerp(a: f32, b: f32, v: f32) -> f32 { a * (1.0 - v) + b * v }
 #[inline(always)]
 fn smooth(v: f32) -> f32 { v * v * (3.0 - 2.0 * v) }
 
-fn random_gradient<R:Rng>(r: &R) -> Vec2 {
+fn random_gradient<R:Rng>(r: &mut R) -> Vec2 {
     let v = 2.0 * float::consts::pi * r.gen();
     Vec2 {
         x: float::cos(v) as f32,
@@ -33,11 +33,15 @@ struct Noise2DContext {
 
 pub impl Noise2DContext {
     fn new() -> Noise2DContext {
-        let r = rand::rng();
+        let mut r = rand::rng();
         let mut rgradients = [ Vec2 { x: 0.0, y: 0.0 }, ..256 ];
-        for int::range(0, 256) |i| { rgradients[i] = random_gradient(&r); }
+        for int::range(0, 256) |i| {
+            rgradients[i] = random_gradient(&mut r);
+        }
         let mut permutations = [ 0, ..256 ];
-        for int::range(0, 256) |i| { permutations[i] = i; }
+        for int::range(0, 256) |i| {
+            permutations[i] = i;
+        }
         r.shuffle_mut(permutations);
 
         Noise2DContext {
@@ -53,7 +57,11 @@ pub impl Noise2DContext {
     }
 
     #[inline]
-    fn get_gradients(&self, gradients: &mut [Vec2, ..4], origins: &mut [Vec2, ..4], x: f32, y: f32) {
+    fn get_gradients(&self,
+                     gradients: &mut [Vec2, ..4],
+                     origins: &mut [Vec2, ..4],
+                     x: f32,
+                     y: f32) {
         let x0f = f32::floor(x);
         let y0f = f32::floor(y);
         let x0 = x0f as int;

src/test/bench/shootout-fasta.rs

@@ -63,7 +63,10 @@ fn make_random_fasta(wr: @io::Writer,
                      genelist: ~[AminoAcids],
                      n: int) {
     wr.write_line(~">" + id + ~" " + desc);
-    let rng = @mut MyRandom {last: rand::rng().next()};
+    let mut rng = rand::rng();
+    let rng = @mut MyRandom {
+        last: rng.next()
+    };
     let mut op: ~str = ~"";
     for uint::range(0u, n as uint) |_i| {
         str::push_char(&mut op, select_random(myrandom_next(rng, 100u32),

src/test/bench/shootout-pfib.rs

@@ -26,7 +26,6 @@ use core::int::range;
 use core::comm::*;
 use core::io::WriterUtil;
 
-use core::result;
 use core::result::{Ok, Err};
 
 fn fib(n: int) -> int {
@@ -80,13 +79,15 @@ fn stress_task(&&id: int) {
 fn stress(num_tasks: int) {
     let mut results = ~[];
     for range(0, num_tasks) |i| {
-        do task::task().future_result(|+r| {
-            results.push(r);
-        }).spawn {
+        let mut builder = task::task();
+        builder.future_result(|r| results.push(r));
+        do builder.spawn {
             stress_task(i);
         }
     }
-    for results.each |r| { r.recv(); }
+    for results.each |r| {
+        r.recv();
+    }
 }
 
 fn main() {

src/test/bench/task-perf-linked-failure.rs

@@ -48,7 +48,10 @@ fn grandchild_group(num_tasks: uint) {
 
 fn spawn_supervised_blocking(myname: &str, +f: ~fn()) {
     let mut res = None;
-    task::task().future_result(|+r| res = Some(r)).supervised().spawn(f);
+    let mut builder = task::task();
+    builder.future_result(|r| res = Some(r));
+    builder.supervised();
+    builder.spawn(f);
     error!("%s group waiting", myname);
     let x = res.unwrap().recv();
     assert!(x == task::Success);

src/test/run-pass/issue-3176.rs

@@ -26,7 +26,8 @@ pub fn main() {
         c2.send(());
         error!("child blocks");
         let (p, c) = comm::stream();
-        (p, p3).select();
+        let mut tuple = (p, p3);
+        tuple.select();
         c.send(());
     };
     error!("parent tries");

src/test/run-pass/morestack6.rs

@@ -62,7 +62,7 @@ pub fn main() {
         calllink09,
         calllink10
     ];
-    let rng = rand::rng();
+    let mut rng = rand::rng();
     for fns.each |f| {
         let f = *f;
         let sz = rng.next() % 256u32 + 256u32;

src/test/run-pass/pipe-peek.rs

@@ -22,11 +22,11 @@ proto! oneshot (
 )
 
 pub fn main() {
-    let (c, p) = oneshot::init();
+    let mut (c, p) = oneshot::init();
 
-    assert!(!pipes::peek(&p));
+    assert!(!pipes::peek(&mut p));
 
     oneshot::client::signal(c);
 
-    assert!(pipes::peek(&p));
+    assert!(pipes::peek(&mut p));
 }

src/test/run-pass/pipe-pingpong-bounded.rs

@@ -40,7 +40,7 @@ mod pingpong {
         do pipes::entangle_buffer(buffer) |buffer, data| {
             data.ping.set_buffer(buffer);
             data.pong.set_buffer(buffer);
-            ptr::to_unsafe_ptr(&(data.ping))
+            ptr::to_mut_unsafe_ptr(&mut (data.ping))
         }
     }
     pub struct ping(server::pong);
@@ -50,11 +50,11 @@ mod pingpong {
         use core::pipes::*;
         use core::ptr;
 
-        pub fn ping(+pipe: ping) -> pong {
+        pub fn ping(mut pipe: ping) -> pong {
             {
-                let b = pipe.reuse_buffer();
-                let s = SendPacketBuffered(&b.buffer.data.pong);
-                let c = RecvPacketBuffered(&b.buffer.data.pong);
+                let mut b = pipe.reuse_buffer();
+                let s = SendPacketBuffered(&mut b.buffer.data.pong);
+                let c = RecvPacketBuffered(&mut b.buffer.data.pong);
                 let message = ::pingpong::ping(s);
                 send(pipe, message);
                 c
@@ -72,11 +72,11 @@ mod pingpong {
 
         pub type ping = pipes::RecvPacketBuffered<::pingpong::ping,
         ::pingpong::Packets>;
-        pub fn pong(+pipe: pong) -> ping {
+        pub fn pong(mut pipe: pong) -> ping {
             {
-                let b = pipe.reuse_buffer();
-                let s = SendPacketBuffered(&b.buffer.data.ping);
-                let c = RecvPacketBuffered(&b.buffer.data.ping);
+                let mut b = pipe.reuse_buffer();
+                let s = SendPacketBuffered(&mut b.buffer.data.ping);
+                let c = RecvPacketBuffered(&mut b.buffer.data.ping);
                 let message = ::pingpong::pong(s);
                 send(pipe, message);
                 c

src/test/run-pass/pipe-presentation-examples.rs

@@ -1,4 +1,8 @@
 // xfail-fast
+// xfail-test
+
+// XFAIL'd because this is going to be revamped, and it's not compatible as
+// written with the new mutability rules.
 
 // Copyright 2012 The Rust Project Developers. See the COPYRIGHT
 // file at the top-level directory of this distribution and at

src/test/run-pass/platform_thread.rs

@@ -24,9 +24,15 @@ fn run(i: int) {
         return;
     }
 
-    do task::task().sched_mode(task::PlatformThread).unlinked().spawn {
+    let mut builder = task::task();
+    builder.sched_mode(task::PlatformThread);
+    builder.unlinked();
+    do builder.spawn {
         task::yield();
-        do task::task().sched_mode(task::SingleThreaded).unlinked().spawn {
+        let mut builder = task::task();
+        builder.sched_mode(task::SingleThreaded);
+        builder.unlinked();
+        do builder.spawn {
             task::yield();
             run(i - 1);
             task::yield();

src/test/run-pass/task-comm-12.rs

@@ -17,7 +17,9 @@ fn start(&&task_number: int) { debug!("Started / Finished task."); }
 fn test00() {
     let i: int = 0;
     let mut result = None;
-    do task::task().future_result(|+r| { result = Some(r); }).spawn {
+    let mut builder = task::task();
+    builder.future_result(|r| result = Some(r));
+    do builder.spawn {
         start(i)
     }
 

src/test/run-pass/task-comm-3.rs

@@ -40,9 +40,9 @@ fn test00() {
     let mut results = ~[];
     while i < number_of_tasks {
         let ch = po.chan();
-        task::task().future_result(|+r| {
-            results.push(r);
-        }).spawn({
+        let mut builder = task::task();
+        builder.future_result(|r| results.push(r));
+        builder.spawn({
             let i = i;
             || test00_start(&ch, i, number_of_messages)
         });

src/test/run-pass/task-comm-9.rs

@@ -27,8 +27,9 @@ fn test00() {
     let ch = p.chan();
 
     let mut result = None;
-    do task::task().future_result(|+r| { result = Some(r); }).spawn
-          || {
+    let mut builder = task::task();
+    builder.future_result(|r| result = Some(r));
+    do builder.spawn {
         test00_start(&ch, number_of_messages);
     }
 

src/test/run-pass/yield.rs

@@ -11,7 +11,9 @@
 
 pub fn main() {
     let mut result = None;
-    task::task().future_result(|+r| { result = Some(r); }).spawn(child);
+    let mut builder = task::task();
+    builder.future_result(|+r| { result = Some(r); });
+    builder.spawn(child);
     error!("1");
     task::yield();
     error!("2");

src/test/run-pass/yield1.rs

@@ -11,7 +11,9 @@
 
 pub fn main() {
     let mut result = None;
-    task::task().future_result(|+r| { result = Some(r); }).spawn(child);
+    let mut builder = task::task();
+    builder.future_result(|+r| { result = Some(r); });
+    builder.spawn(child);
     error!("1");
     task::yield();
     result.unwrap().recv();