test: De-~mut the test suite. rs=demuting

Author: pcwalton

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

@@ -87,17 +87,12 @@ fn main() {
     for uint::range(1u, num_tasks) |i| {
         //error!("spawning %?", i);
         let (new_chan, num_port) = init();
-        let num_chan2 = ~mut None;
-        *num_chan2 <-> num_chan;
-        let num_port = ~mut Some(num_port);
-        let new_future = do future::spawn() || {
-            let mut num_chan = None;
-            num_chan <-> *num_chan2;
-            let mut num_port1 = None;
-            num_port1 <-> *num_port;
-            thread_ring(i, msg_per_task,
-                        option::unwrap(num_chan),
-                        option::unwrap(num_port1))
+        let num_chan2 = Cell(num_chan);
+        let num_port = Cell(num_port);
+        let new_future = do future::spawn() {
+            let num_chan = num_chan2.take();
+            let num_port1 = num_port.take();
+            thread_ring(i, msg_per_task, num_chan, num_port1)
         };
         futures.push(new_future);
         num_chan = Some(new_chan);

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

@@ -17,10 +17,11 @@
 // This version uses automatically compiled channel contracts.
 
 extern mod std;
-use std::time;
-use std::future;
 
+use core::cell::Cell;
 use core::pipes::recv;
+use std::time;
+use std::future;
 
 proto! ring (
     num:send {
@@ -80,17 +81,12 @@ fn main() {
     for uint::range(1u, num_tasks) |i| {
         //error!("spawning %?", i);
         let (new_chan, num_port) = ring::init();
-        let num_chan2 = ~mut None;
-        *num_chan2 <-> num_chan;
-        let num_port = ~mut Some(num_port);
+        let num_chan2 = Cell(num_chan);
+        let num_port = Cell(num_port);
         let new_future = do future::spawn || {
-            let mut num_chan = None;
-            num_chan <-> *num_chan2;
-            let mut num_port1 = None;
-            num_port1 <-> *num_port;
-            thread_ring(i, msg_per_task,
-                        option::unwrap(num_chan),
-                        option::unwrap(num_port1))
+            let num_chan = num_chan2.take();
+            let num_port1 = num_port.take();
+            thread_ring(i, msg_per_task, num_chan, num_port1)
         };
         futures.push(new_future);
         num_chan = Some(new_chan);

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

@@ -87,17 +87,12 @@ fn main() {
     for uint::range(1u, num_tasks) |i| {
         //error!("spawning %?", i);
         let (new_chan, num_port) = init();
-        let num_chan2 = ~mut None;
-        *num_chan2 <-> num_chan;
-        let num_port = ~mut Some(num_port);
-        let new_future = do future::spawn || {
-            let mut num_chan = None;
-            num_chan <-> *num_chan2;
-            let mut num_port1 = None;
-            num_port1 <-> *num_port;
-            thread_ring(i, msg_per_task,
-                        option::unwrap(num_chan),
-                        option::unwrap(num_port1))
+        let num_chan2 = Cell(num_chan);
+        let num_port = Cell(num_port);
+        let new_future = do future::spawn {
+            let num_chan = num_chan2.take();
+            let num_port1 = num_port.take();
+            thread_ring(i, msg_per_task, num_chan, num_port1)
         };
         futures.push(new_future);
         num_chan = Some(new_chan);

src/test/bench/task-perf-jargon-metal-smoke.rs

@@ -17,13 +17,15 @@
 //
 // The filename is a song reference; google it in quotes.
 
+use core::cell::Cell;
+
 fn child_generation(gens_left: uint, -c: comm::Chan<()>) {
     // This used to be O(n^2) in the number of generations that ever existed.
     // With this code, only as many generations are alive at a time as tasks
     // alive at a time,
-    let c = ~mut Some(c);
-    do task::spawn_supervised || {
-        let c = option::swap_unwrap(c);
+    let c = Cell(c);
+    do task::spawn_supervised {
+        let c = c.take();
         if gens_left & 1 == 1 {
             task::yield(); // shake things up a bit
         }

src/test/compile-fail/mutable-huh-variance-deep.rs

@@ -11,9 +11,9 @@
 // error-pattern: mismatched types
 
 fn main() {
-    let v = ~[mut @mut ~mut ~[0]];
+    let v = @[mut @mut @mut @[0]];
 
-    fn f(&&v: ~[mut @mut ~mut ~[const int]]) {
+    fn f(&&v: @[mut @mut @mut @[const int]]) {
     }
 
     f(v);

src/test/compile-fail/mutable-huh-variance-unique.rs

@@ -8,6 +8,8 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+use core::cell::Cell;
+
 struct Port<T>(@T);
 
 fn main() {
@@ -25,11 +27,10 @@ fn main() {
         }
     }
 
-    let x = ~mut Some(foo(Port(@())));
+    let x = Cell(foo(Port(@())));
 
     do task::spawn {
-        let mut y = None;
-        *x <-> y; //~ ERROR value has non-owned type
+        let y = x.take();   //~ ERROR value has non-owned type
         log(error, y);
     }
 }

src/test/compile-fail/no-send-res-ports.rs

@@ -20,7 +20,7 @@ fn borrow(x: &int, f: fn(x: &int)) {
 struct F { f: ~int }
 
 pub fn main() {
-    let mut x = ~mut @F{f: ~3};
+    let mut x = ~@F{f: ~3};
     do borrow(x.f) |b_x| {
         assert *b_x == 3;
         assert ptr::addr_of(&(*x.f)) == ptr::addr_of(&(*b_x));

src/test/compile-fail/unique-mut.rs

@@ -21,9 +21,6 @@ impl Box {
     fn set_many2(@mut self, xs: &[uint]) {
         for xs.each |x| { self.x = *x; }
     }
-    fn set_many3(~mut self, xs: &[uint]) {
-        for xs.each |x| { self.x = *x; }
-    }
 }
 
 pub fn main() {}