port over the tests to use the new API

Author: nikomatsakis

src/compiletest/compiletest.rs

@@ -193,21 +193,21 @@ fn closure_to_task(cx: cx, configport: port<[u8]>, testfn: fn@()) ->
    test::joinable {
     testfn();
     let testfile = recv(configport);
-
-    ret task::spawn_joinable(
-        (cx.config, cx.procsrv.chan, testfile), run_test_task);
+    let (config, chan) = (cx.config, cx.procsrv.chan);
+    ret task::spawn_joinable {||
+        run_test_task(config, chan, testfile);
+    };
 }
 
-fn run_test_task(args: (common::config, procsrv::reqchan, [u8])) {
-
-    let (config, procsrv_chan, testfile) = args;
-
+fn run_test_task(config: common::config,
+                 procsrv_chan: procsrv::reqchan,
+                 testfile: [u8]) {
     test::configure_test_task();
 
     let procsrv = procsrv::from_chan(procsrv_chan);
     let cx = {config: config, procsrv: procsrv};
 
-    runtest::run(cx, testfile);
+    runtest::run(cx, copy testfile);
 }
 
 // Local Variables:

src/compiletest/procsrv.rs

@@ -40,14 +40,13 @@ type response = {pid: pid_t, infd: fd_t,
 
 fn mk() -> handle {
     let setupport = port();
-    let task = task::spawn_joinable(
-        chan(setupport),
-        fn (setupchan: chan<chan<request>>) {
-            let reqport = port();
-            let reqchan = chan(reqport);
-            send(setupchan, reqchan);
-            worker(reqport);
-        });
+    let setupchan = chan(setupport);
+    let task = task::spawn_joinable {||
+        let reqport = port();
+        let reqchan = chan(reqport);
+        send(setupchan, reqchan);
+        worker(reqport);
+    };
     ret {task: option::some(task), chan: recv(setupport)};
 }
 

src/test/run-pass/basic-1.rs

@@ -11,8 +11,9 @@ fn a(c: chan<int>) { send(c, 10); }
 
 fn main() {
     let p = port();
-    task::spawn(chan(p), a);
-    task::spawn(chan(p), a);
+    let ch = chan(p);
+    task::spawn {|| a(ch); };
+    task::spawn {|| a(ch); };
     let n: int = 0;
     n = recv(p);
     n = recv(p);

src/test/run-pass/basic-2.rs

@@ -2,6 +2,7 @@
 
 use std;
 import comm;
+import comm::port;
 import comm::send;
 import comm::chan;
 import comm::recv;
@@ -10,9 +11,10 @@ import task;
 fn a(c: chan<int>) { #debug("task a0"); #debug("task a1"); send(c, 10); }
 
 fn main() {
-    let p = comm::port();
-    task::spawn(chan(p), a);
-    task::spawn(chan(p), b);
+    let p = port();
+    let ch = chan(p);
+    task::spawn {|| a(ch); };
+    task::spawn {|| b(ch); };
     let n: int = 0;
     n = recv(p);
     n = recv(p);

src/test/run-pass/basic.rs

@@ -31,8 +31,9 @@ fn main() {
     let n: int = 2 + 3 * 7;
     let s: str = "hello there";
     let p = comm::port();
-    task::spawn(chan(p), a);
-    task::spawn(chan(p), b);
+    let ch = comm::chan(p);
+    task::spawn {|| a(ch); };
+    task::spawn {|| b(ch); };
     let x: int = 10;
     x = g(n, s);
     log(debug, x);

src/test/run-pass/binops.rs

@@ -87,10 +87,10 @@ fn test_ptr() {
 }
 
 fn test_task() {
-    fn f(&&_i: ()) { }
+    fn f() { }
     let f1 = f, f2 = f;
-    let t1 = task::spawn((), f1);
-    let t2 = task::spawn((), f2);
+    let t1 = task::spawn {|| f1(); };
+    let t2 = task::spawn {|| f2(); };
 
     assert (t1 == t1);
     assert (t1 != t2);

src/test/run-pass/chan-leak.rs

@@ -23,7 +23,8 @@ fn request_task(c: chan<ctx>) {
 
 fn new() -> ctx {
     let p = port();
-    let t = task::spawn(chan(p), request_task);
+    let ch = chan(p);
+    let t = task::spawn {|| request_task(ch); };
     let cx: ctx;
     cx = recv(p);
     ret cx;

src/test/run-pass/child-outlives-parent.rs

@@ -5,4 +5,4 @@ import task;
 
 fn child2(&&s: str) { }
 
-fn main() { let x = task::spawn("hi", child2); }
+fn main() { let x = task::spawn {|| child2("hi"); }; }

src/test/run-pass/comm.rs

@@ -9,7 +9,8 @@ import task;
 
 fn main() {
     let p = comm::port();
-    let t = task::spawn(chan(p), child);
+    let ch = comm::chan(p);
+    let t = task::spawn {|| child(ch); };
     let y = recv(p);
     #error("received");
     log(error, y);

src/test/run-pass/hashmap-memory.rs

@@ -33,12 +33,12 @@ mod map_reduce {
     tag ctrl_proto { find_reducer([u8], chan<int>); mapper_done; }
 
     fn start_mappers(ctrl: chan<ctrl_proto>, inputs: [str]) {
-        for i: str in inputs { task::spawn((ctrl, i), map_task); }
+        for i: str in inputs {
+            task::spawn {|| map_task(ctrl, i); };
+        }
     }
 
-    fn map_task(&&args: (chan<ctrl_proto>, str)) {
-        let (ctrl, input) = args;
-
+    fn map_task(ctrl: chan<ctrl_proto>, input: str) {
         let intermediates = map::new_str_hash();
 
         fn emit(im: map::hashmap<str, int>, ctrl: chan<ctrl_proto>, key: str,

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

@@ -18,14 +18,15 @@ import comm::recv;
 fn grandchild(c: chan<int>) { send(c, 42); }
 
 fn child(c: chan<int>) {
-    let _grandchild = task::spawn_joinable(copy c, grandchild);
+    let _grandchild = task::spawn_joinable {|| grandchild(c); };
     join(_grandchild);
 }
 
 fn main() {
     let p = comm::port();
+    let ch = chan(p);
 
-    let _child = task::spawn_joinable(chan(p), child);
+    let _child = task::spawn_joinable {|| child(ch); };
 
     let x: int = recv(p);
 

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

@@ -15,8 +15,7 @@ fn producer(c: chan<[u8]>) {
     send(c, empty);
 }
 
-fn packager(&&args: (chan<chan<[u8]>>, chan<msg>)) {
-    let (cb, msg) = args;
+fn packager(cb: chan<chan<[u8]>>, msg: chan<msg>) {
     let p: port<[u8]> = port();
     send(cb, chan(p));
     while true {
@@ -39,11 +38,13 @@ fn packager(&&args: (chan<chan<[u8]>>, chan<msg>)) {
 
 fn main() {
     let p: port<msg> = port();
+    let ch = chan(p);
     let recv_reader: port<chan<[u8]>> = port();
-    let pack = task::spawn((chan(recv_reader), chan(p)), packager);
+    let recv_reader_chan = chan(recv_reader);
+    let pack = task::spawn {|| packager(recv_reader_chan, ch); };
 
     let source_chan: chan<[u8]> = recv(recv_reader);
-    let prod = task::spawn(source_chan, producer);
+    let prod = task::spawn {|| producer(source_chan); };
 
     while true {
         let msg = recv(p);

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

@@ -2,14 +2,15 @@ use std;
 import comm::*;
 import task::*;
 
-fn a(&&_args: ()) {
+fn a() {
     fn doit() {
         fn b(c: chan<chan<int>>) {
             let p = port();
             send(c, chan(p));
         }
         let p = port();
-        spawn(chan(p), b);
+        let ch = chan(p);
+        spawn {|| b(ch); };
         recv(p);
     }
     let i = 0;
@@ -20,6 +21,6 @@ fn a(&&_args: ()) {
 }
 
 fn main() {
-    let t = spawn_joinable((), a);
+    let t = spawn_joinable {|| a(); };
     join(t);
 }

src/test/run-pass/ivec-tag.rs

@@ -15,7 +15,8 @@ fn producer(c: chan<[u8]>) {
 
 fn main() {
     let p: port<[u8]> = port();
-    let prod = task::spawn(chan(p), producer);
+    let ch = chan(p);
+    let prod = task::spawn {|| producer(ch); };
 
     let data: [u8] = recv(p);
 }

src/test/run-pass/join.rs

@@ -5,11 +5,11 @@ use std;
 import task::*;
 
 fn main() {
-    let other = spawn_joinable((), child);
+    let other = spawn_joinable {|| child(); };
     #error("1");
     yield();
     join(other);
     #error("3");
 }
 
-fn child(&&_i: ()) { #error("2"); }
+fn child() { #error("2"); }

src/test/run-pass/lazychan.rs

@@ -6,15 +6,16 @@ import comm::*;
 
 fn main() {
     let p = port();
+    let ch = chan(p);
     let y: int;
 
-    task::spawn(chan(p), child);
+    task::spawn {|| child(ch); };
     y = recv(p);
     #debug("received 1");
     log(debug, y);
     assert (y == 10);
 
-    task::spawn(chan(p), child);
+    task::spawn {|| child(ch); };
     y = recv(p);
     #debug("received 2");
     log(debug, y);

src/test/run-pass/linked-failure.rs

@@ -5,17 +5,17 @@ import task;
 import comm::port;
 import comm::recv;
 
-fn child(&&_i: ()) { assert (1 == 2); }
+fn child() { assert (1 == 2); }
 
-fn parent(&&_i: ()) {
+fn parent() {
     // Since this task isn't supervised it won't bring down the whole
     // process
     task::unsupervise();
     let p = port::<int>();
-    task::spawn((), child);
+    task::spawn {|| child(); };
     let x = recv(p);
 }
 
 fn main() {
-    task::spawn((), parent);
+    task::spawn {|| parent(); };
 }

src/test/run-pass/lots-a-fail.rs

@@ -4,17 +4,17 @@ import task;
 import comm;
 import uint;
 
-fn die(&&_i: ()) {
+fn die() {
     fail;
 }
 
-fn iloop(&&_i: ()) {
+fn iloop() {
     task::unsupervise();
-    task::spawn((), die);
+    task::spawn {|| die(); };
 }
 
 fn main() {
     uint::range(0u, 100u) {|_i|
-        task::spawn((), iloop);
+        task::spawn {|| iloop(); };
     }
 }

src/test/run-pass/many.rs

@@ -4,21 +4,22 @@ use std;
 import task;
 import comm;
 
-fn sub(&&args: (comm::chan<int>, int)) {
-    let (parent, id) = args;
+fn sub(parent: comm::chan<int>, id: int) {
     if id == 0 {
         comm::send(parent, 0);
     } else {
         let p = comm::port();
-        let child = task::spawn((comm::chan(p), id - 1), sub);
+        let ch = comm::chan(p);
+        let child = task::spawn {|| sub(ch, id - 1); };
         let y = comm::recv(p);
         comm::send(parent, y + 1);
     }
 }
 
 fn main() {
     let p = comm::port();
-    let child = task::spawn((comm::chan(p), 200), sub);
+    let ch = comm::chan(p);
+    let child = task::spawn {|| sub(ch, 200); };
     let y = comm::recv(p);
     #debug("transmission complete");
     log(debug, y);

src/test/run-pass/morestack5.rs

@@ -17,7 +17,7 @@ fn main() {
     let sz = 400u;
     while sz < 500u {
         rustrt::set_min_stack(sz);
-        task::join(task::spawn_joinable(200, getbig));
+        task::join(task::spawn_joinable {|| getbig(200) });
         sz += 1u;
     }
 }

src/test/run-pass/morestack6.rs

@@ -32,12 +32,11 @@ fn calllink08() { rustrt::get_task_id(); }
 fn calllink09() { rustrt::sched_threads(); }
 fn calllink10() { rustrt::rust_get_task(); }
 
-fn runtest(&&args:(fn(), u32)) {
-    let (f, frame_backoff) = args;
+fn runtest(f: sendfn(), frame_backoff: u32) {
     runtest2(f, frame_backoff, 0 as *u8);
 }
 
-fn runtest2(f: fn(), frame_backoff: u32, last_stk: *u8) -> u32 {
+fn runtest2(f: sendfn(), frame_backoff: u32, last_stk: *u8) -> u32 {
     let curr_stk = rustrt::debug_get_stk_seg();
     if (last_stk != curr_stk && last_stk != 0 as *u8) {
         // We switched stacks, go back and try to hit the dynamic linker
@@ -73,6 +72,6 @@ fn main() {
         let sz = rng.next() % 256u32 + 256u32;
         let frame_backoff = rng.next() % 10u32 + 1u32;
         rustrt::set_min_stack(sz as uint);
-        task::join(task::spawn_joinable((f, frame_backoff), runtest));
+        task::join(task::spawn_joinable {|| runtest(f, frame_backoff);});
     }
 }