---

yaml
---
r: 5873
b: refs/heads/master
c: 686d6a4
h: refs/heads/master
i:
  5871: 4b3f7ec
v: v3

Author: brson

[refs]

@@ -1,2 +1,2 @@
 ---
-refs/heads/master: e0bba33caaeeda99753ec0355d570665f9912d03
+refs/heads/master: 686d6a485f71b98fe9ea7dddd25de0c33efeea7a

trunk/src/compiletest/compiletest.rs

@@ -191,7 +191,7 @@ fn closure_to_task(cx: cx, configport: port<[u8]>, testfn: fn()) ->
     testfn();
     let testfile = recv(configport);
 
-    ret task::spawn_joinable2(
+    ret task::spawn_joinable(
         (cx.config, cx.procsrv.chan, testfile), run_test_task);
 }
 

trunk/src/compiletest/procsrv.rs

@@ -37,7 +37,7 @@ type response = {pid: int, infd: int, outfd: int, errfd: int};
 
 fn mk() -> handle {
     let setupport = port();
-    let task = task::spawn_joinable2(
+    let task = task::spawn_joinable(
         chan(setupport),
         fn# (setupchan: chan<chan<request>>) {
             let reqport = port();

trunk/src/lib/aio.rs

@@ -107,7 +107,7 @@ fn# server_task(args: (net::ip_addr, int, chan<server_event>,
         if rustrt::aio_is_null_client(client) {
             log "client was actually null, returning";
             ret;
-        } else { task::spawn2((client, events), accept_task); }
+        } else { task::spawn((client, events), accept_task); }
     }
 }
 
@@ -129,10 +129,10 @@ fn# request_task(c: chan<ctx>) {
             ret;
           }
           connect(remote(ip, portnum), client) {
-            task::spawn2((ip, portnum, client), connect_task);
+            task::spawn((ip, portnum, client), connect_task);
           }
           serve(ip, portnum, events, server) {
-            task::spawn2((ip, portnum, events, server), server_task);
+            task::spawn((ip, portnum, events, server), server_task);
           }
           write(socket, v, status) unsafe {
             rustrt::aio_writedata(socket, vec::unsafe::to_ptr::<u8>(v),
@@ -157,7 +157,7 @@ fn# iotask(c: chan<ctx>) {
 
     log "io task init";
     // Spawn our request task
-    let reqtask = task::spawn_joinable2(c, request_task);
+    let reqtask = task::spawn_joinable(c, request_task);
 
     log "uv run task init";
     // Enter IO loop. This never returns until aio_stop is called.
@@ -169,7 +169,7 @@ fn# iotask(c: chan<ctx>) {
 
 fn new() -> ctx {
     let p: port<ctx> = port();
-    task::spawn2(chan(p), iotask);
+    task::spawn(chan(p), iotask);
     ret recv(p);
 }
 

trunk/src/lib/task.rs

@@ -18,9 +18,9 @@ export task_result;
 export tr_success;
 export tr_failure;
 export get_task_id;
-export spawn2;
-export spawn_notify2;
-export spawn_joinable2;
+export spawn;
+export spawn_notify;
+export spawn_joinable;
 
 native "rust" mod rustrt {
     fn task_sleep(time_in_us: uint);
@@ -93,18 +93,18 @@ fn unpin() { rustrt::unpin_task(); }
 
 fn set_min_stack(stack_size: uint) { rustrt::set_min_stack(stack_size); }
 
-fn spawn2<~T>(-data: T, f: fn#(T)) -> task {
+fn spawn<~T>(-data: T, f: fn#(T)) -> task {
     spawn_inner2(data, f, none)
 }
 
-fn spawn_notify2<~T>(-data: T, f: fn#(T),
+fn spawn_notify<~T>(-data: T, f: fn#(T),
                          notify: comm::chan<task_notification>) -> task {
     spawn_inner2(data, f, some(notify))
 }
 
-fn spawn_joinable2<~T>(-data: T, f: fn#(T)) -> joinable_task {
+fn spawn_joinable<~T>(-data: T, f: fn#(T)) -> joinable_task {
     let p = comm::port::<task_notification>();
-    let id = spawn_notify2(data, f, comm::chan::<task_notification>(p));
+    let id = spawn_notify(data, f, comm::chan::<task_notification>(p));
     ret (id, p);
 }
 

trunk/src/lib/test.rs

@@ -325,7 +325,7 @@ fn default_test_to_task(&&f: default_test_fn) -> joinable {
         configure_test_task();
         f();
     }
-    ret task::spawn_joinable2(f, run_task);
+    ret task::spawn_joinable(f, run_task);
 }
 
 // Call from within a test task to make sure it's set up correctly

trunk/src/test/bench/shootout-pfib.rs

@@ -36,15 +36,15 @@ fn fib(n: int) -> int {
         } else {
             let p = port();
 
-            let t1 = task::spawn2((chan(p), n - 1), pfib);
-            let t2 = task::spawn2((chan(p), n - 2), pfib);
+            let t1 = task::spawn((chan(p), n - 1), pfib);
+            let t2 = task::spawn((chan(p), n - 2), pfib);
 
             send(c, recv(p) + recv(p));
         }
     }
 
     let p = port();
-    let t = task::spawn2((chan(p), n), pfib);
+    let t = task::spawn((chan(p), n), pfib);
     ret recv(p);
 }
 
@@ -75,7 +75,7 @@ fn# stress_task(&&id: int) {
 fn stress(num_tasks: int) {
     let tasks = [];
     for each i: int in range(0, num_tasks) {
-        tasks += [task::spawn_joinable2(copy i, stress_task)];
+        tasks += [task::spawn_joinable(copy i, stress_task)];
     }
     for t in tasks { task::join(t); }
 }

trunk/src/test/bench/task-perf-spawnalot.rs

@@ -7,7 +7,7 @@ import std::str;
 fn# f(&&n: uint) {
     let i = 0u;
     while i < n {
-        task::join(task::spawn_joinable2((), g));
+        task::join(task::spawn_joinable((), g));
         i += 1u;
     }
 }
@@ -20,5 +20,5 @@ fn main(args: [str]) {
             10u
         } else { uint::parse_buf(str::bytes(args[1]), 10u) };
     let i = 0u;
-    while i < n { task::spawn2(copy n, f); i += 1u; }
+    while i < n { task::spawn(copy n, f); i += 1u; }
 }

trunk/src/test/bench/task-perf-vector-party.rs

@@ -21,5 +21,5 @@ fn main(args: [str]) {
         if vec::len(args) < 2u {
             100u
         } else { uint::parse_buf(str::bytes(args[1]), 10u) };
-    for each i in uint::range(0u, 100u) { task::spawn2(copy n, f); }
+    for each i in uint::range(0u, 100u) { task::spawn(copy n, f); }
 }

trunk/src/test/bench/task-perf-word-count.rs

@@ -70,7 +70,7 @@ mod map_reduce {
        [joinable_task] {
         let tasks = [];
         for i: str in inputs {
-            tasks += [task::spawn_joinable2((ctrl, i), map_task)];
+            tasks += [task::spawn_joinable((ctrl, i), map_task)];
         }
         ret tasks;
     }
@@ -171,7 +171,7 @@ mod map_reduce {
                     // log_err "creating new reducer for " + k;
                     let p = port();
                     tasks +=
-                        [task::spawn_joinable2((k, chan(p)), reduce_task)];
+                        [task::spawn_joinable((k, chan(p)), reduce_task)];
                     c = recv(p);
                     reducers.insert(k, c);
                   }

trunk/src/test/compile-fail/spawn-non-nil-fn.rs

@@ -5,4 +5,4 @@ import std::task;
 
 fn# f(&&x: int) -> int { ret x; }
 
-fn main() { task::spawn2(10, f); }
+fn main() { task::spawn(10, f); }

trunk/src/test/run-fail/linked-failure.rs

@@ -10,6 +10,6 @@ fn# child(&&_i: ()) { assert (1 == 2); }
 
 fn main() {
     let p = port::<int>();
-    task::spawn2((), child);
+    task::spawn((), child);
     let x = recv(p);
 }

trunk/src/test/run-fail/linked-failure2.rs

@@ -11,6 +11,6 @@ fn# child(&&_i: ()) { fail; }
 
 fn main() {
     let p = port::<int>();
-    task::spawn2((), child);
+    task::spawn((), child);
     task::yield();
 }

trunk/src/test/run-fail/linked-failure3.rs

@@ -10,12 +10,12 @@ fn# grandchild(&&_i: ()) { fail; }
 
 fn# child(&&_i: ()) {
     let p = port::<int>();
-    task::spawn2((), grandchild);
+    task::spawn((), grandchild);
     let x = recv(p);
 }
 
 fn main() {
     let p = port::<int>();
-    task::spawn2((), child);
+    task::spawn((), child);
     let x = recv(p);
 }

trunk/src/test/run-fail/task-comm-recv-block.rs

@@ -10,7 +10,7 @@ fn# goodfail(&&_i: ()) {
 }
 
 fn main() {
-    task::spawn2((), goodfail);
+    task::spawn((), goodfail);
     let po = comm::port();
     // We shouldn't be able to get past this recv since there's no
     // message available

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

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

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

@@ -11,8 +11,8 @@ fn# a(c: chan<int>) { log "task a0"; log "task a1"; send(c, 10); }
 
 fn main() {
     let p = comm::port();
-    task::spawn2(chan(p), a);
-    task::spawn2(chan(p), b);
+    task::spawn(chan(p), a);
+    task::spawn(chan(p), b);
     let n: int = 0;
     n = recv(p);
     n = recv(p);

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

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

trunk/src/test/run-pass/binops.rs

@@ -89,8 +89,8 @@ fn test_ptr() {
 fn test_task() {
     fn# f(&&_i: ()) { }
     let f1 = f, f2 = f;
-    let t1 = task::spawn2((), f1);
-    let t2 = task::spawn2((), f2);
+    let t1 = task::spawn((), f1);
+    let t2 = task::spawn((), f2);
 
     assert (t1 == t1);
     assert (t1 != t2);

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

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

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

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

trunk/src/test/run-pass/comm.rs

@@ -9,7 +9,7 @@ import std::task;
 
 fn main() {
     let p = comm::port();
-    let t = task::spawn2(chan(p), child);
+    let t = task::spawn(chan(p), child);
     let y = recv(p);
     log_err "received";
     log_err y;

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

@@ -33,7 +33,7 @@ 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::spawn2((ctrl, i), map_task); }
+        for i: str in inputs { task::spawn((ctrl, i), map_task); }
     }
 
     fn# map_task(&&args: (chan<ctrl_proto>, str)) {

trunk/src/test/run-pass/issue-506.rs

@@ -11,4 +11,4 @@ native "rust" mod rustrt {
 
 fn# yield_wrap(&&_i: ()) unsafe { rustrt::task_yield(); }
 
-fn main() { task::spawn2((), yield_wrap); }
+fn main() { task::spawn((), yield_wrap); }

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

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

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

@@ -37,10 +37,10 @@ fn# packager(&&args: (chan<chan<[u8]>>, chan<msg>)) {
 fn main() {
     let p: port<msg> = port();
     let recv_reader: port<chan<[u8]>> = port();
-    let pack = task::spawn2((chan(recv_reader), chan(p)), packager);
+    let pack = task::spawn((chan(recv_reader), chan(p)), packager);
 
     let source_chan: chan<[u8]> = recv(recv_reader);
-    let prod = task::spawn2(source_chan, producer);
+    let prod = task::spawn(source_chan, producer);
 
     while true {
         let msg = recv(p);

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

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

trunk/src/test/run-pass/join.rs

@@ -5,7 +5,7 @@ use std;
 import std::task::*;
 
 fn main() {
-    let other = spawn_joinable2((), child);
+    let other = spawn_joinable((), child);
     log_err "1";
     yield();
     join(other);

trunk/src/test/run-pass/lazychan.rs

@@ -8,13 +8,13 @@ fn main() {
     let p = port();
     let y: int;
 
-    task::spawn2(chan(p), child);
+    task::spawn(chan(p), child);
     y = recv(p);
     log "received 1";
     log y;
     assert (y == 10);
 
-    task::spawn2(chan(p), child);
+    task::spawn(chan(p), child);
     y = recv(p);
     log "received 2";
     log y;

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

@@ -12,10 +12,10 @@ fn# parent(&&_i: ()) {
     // process
     task::unsupervise();
     let p = port::<int>();
-    task::spawn2((), child);
+    task::spawn((), child);
     let x = recv(p);
 }
 
 fn main() {
-    task::spawn2((), parent);
+    task::spawn((), parent);
 }

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

@@ -10,11 +10,11 @@ fn# die(&&_i: ()) {
 
 fn# iloop(&&_i: ()) {
     task::unsupervise();
-    task::spawn2((), die);
+    task::spawn((), die);
 }
 
 fn main() {
     for each i in uint::range(0u, 100u) {
-        task::spawn2((), iloop);
+        task::spawn((), iloop);
     }
 }