rust-lang/rust
1
0
Fork 0
Code Issues Pull Requests Actions 1 Packages Projects Releases Wiki Activity

Removing do keyword from libstd and librustc

Browse Source
This commit is contained in:
Scott Lawrence
2014-01-26 22:42:26 -05:00
parent af218d68e4
commit 25e7e7f807
27 changed files with 265 additions and 266 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
src/librustc/middle/typeck/check/mod.rs
View File

@@ -146,7 +146,7 @@ pub mod method;
/// closures defined within the function. For example: /// closures defined within the function. For example:
/// ///
/// fn foo() { /// fn foo() {
/// do bar() { ... } /// bar(proc() { ... })
/// } /// }
/// ///
/// Here, the function `foo()` and the closure passed to /// Here, the function `foo()` and the closure passed to

134
src/libstd/comm/mod.rs
View File

@@ -60,18 +60,18 @@
//! ```rust,should_fail //! ```rust,should_fail
//! // Create a simple streaming channel //! // Create a simple streaming channel
//! let (port, chan) = Chan::new(); //! let (port, chan) = Chan::new();
//! do spawn { //! spawn(proc() {
//! chan.send(10); //! chan.send(10);
//! } //! })
//! assert_eq!(port.recv(), 10); //! assert_eq!(port.recv(), 10);
//! //!
//! // Create a shared channel which can be sent along from many tasks //! // Create a shared channel which can be sent along from many tasks
//! let (port, chan) = SharedChan::new(); //! let (port, chan) = SharedChan::new();
//! for i in range(0, 10) { //! for i in range(0, 10) {
//! let chan = chan.clone(); //! let chan = chan.clone();
//! do spawn { //! spawn(proc() {
//! chan.send(i); //! chan.send(i);
//! } //! })
//! } //! }
//! //!
//! for _ in range(0, 10) { //! for _ in range(0, 10) {
@@ -264,7 +264,7 @@ macro_rules! test (
$($a)* #[test] fn native() { $($a)* #[test] fn native() {
use native; use native;
let (p, c) = Chan::new(); let (p, c) = Chan::new();
do native::task::spawn { c.send(f()) } native::task::spawn(proc() { c.send(f()) });
p.recv(); p.recv();
} }
} }
@@ -962,9 +962,9 @@ mod test {
test!(fn smoke_threads() { test!(fn smoke_threads() {
let (p, c) = Chan::new(); let (p, c) = Chan::new();
do spawn { spawn(proc() {
c.send(1); c.send(1);
} });
assert_eq!(p.recv(), 1); assert_eq!(p.recv(), 1);
}) })
@@ -990,18 +990,18 @@ mod test {
test!(fn port_gone_concurrent() { test!(fn port_gone_concurrent() {
let (p, c) = Chan::new(); let (p, c) = Chan::new();
do spawn { spawn(proc() {
p.recv(); p.recv();
} });
loop { c.send(1) } loop { c.send(1) }
} #[should_fail]) } #[should_fail])
test!(fn port_gone_concurrent_shared() { test!(fn port_gone_concurrent_shared() {
let (p, c) = SharedChan::new(); let (p, c) = SharedChan::new();
let c1 = c.clone(); let c1 = c.clone();
do spawn { spawn(proc() {
p.recv(); p.recv();
} });
loop { loop {
c.send(1); c.send(1);
c1.send(1); c1.send(1);
@@ -1024,18 +1024,18 @@ mod test {
test!(fn chan_gone_concurrent() { test!(fn chan_gone_concurrent() {
let (p, c) = Chan::new(); let (p, c) = Chan::new();
do spawn { spawn(proc() {
c.send(1); c.send(1);
c.send(1); c.send(1);
} });
loop { p.recv(); } loop { p.recv(); }
} #[should_fail]) } #[should_fail])
test!(fn stress() { test!(fn stress() {
let (p, c) = Chan::new(); let (p, c) = Chan::new();
do spawn { spawn(proc() {
for _ in range(0, 10000) { c.send(1); } for _ in range(0, 10000) { c.send(1); }
} });
for _ in range(0, 10000) { for _ in range(0, 10000) {
assert_eq!(p.recv(), 1); assert_eq!(p.recv(), 1);
} }
@@ -1047,7 +1047,7 @@ mod test {
let (p, c) = SharedChan::<int>::new(); let (p, c) = SharedChan::<int>::new();
let (p1, c1) = Chan::new(); let (p1, c1) = Chan::new();
do spawn { spawn(proc() {
for _ in range(0, AMT * NTHREADS) { for _ in range(0, AMT * NTHREADS) {
assert_eq!(p.recv(), 1); assert_eq!(p.recv(), 1);
} }
@@ -1056,13 +1056,13 @@ mod test {
_ => {} _ => {}
} }
c1.send(()); c1.send(());
} });
for _ in range(0, NTHREADS) { for _ in range(0, NTHREADS) {
let c = c.clone(); let c = c.clone();
do spawn { spawn(proc() {
for _ in range(0, AMT) { c.send(1); } for _ in range(0, AMT) { c.send(1); }
} });
} }
p1.recv(); p1.recv();
}) })
@@ -1073,20 +1073,20 @@ mod test {
let (p1, c1) = Chan::new(); let (p1, c1) = Chan::new();
let (port, chan) = SharedChan::new(); let (port, chan) = SharedChan::new();
let chan2 = chan.clone(); let chan2 = chan.clone();
do spawn { spawn(proc() {
c1.send(()); c1.send(());
for _ in range(0, 40) { for _ in range(0, 40) {
assert_eq!(p.recv(), 1); assert_eq!(p.recv(), 1);
} }
chan2.send(()); chan2.send(());
} });
p1.recv(); p1.recv();
do native::task::spawn { native::task::spawn(proc() {
for _ in range(0, 40) { for _ in range(0, 40) {
c.send(1); c.send(1);
} }
chan.send(()); chan.send(());
} });
port.recv(); port.recv();
port.recv(); port.recv();
} }
@@ -1095,12 +1095,12 @@ mod test {
fn recv_from_outside_runtime() { fn recv_from_outside_runtime() {
let (p, c) = Chan::<int>::new(); let (p, c) = Chan::<int>::new();
let (dp, dc) = Chan::new(); let (dp, dc) = Chan::new();
do native::task::spawn { native::task::spawn(proc() {
for _ in range(0, 40) { for _ in range(0, 40) {
assert_eq!(p.recv(), 1); assert_eq!(p.recv(), 1);
} }
dc.send(()); dc.send(());
}; });
for _ in range(0, 40) { for _ in range(0, 40) {
c.send(1); c.send(1);
} }
@@ -1113,16 +1113,16 @@ mod test {
let (p2, c2) = Chan::<int>::new(); let (p2, c2) = Chan::<int>::new();
let (port, chan) = SharedChan::new(); let (port, chan) = SharedChan::new();
let chan2 = chan.clone(); let chan2 = chan.clone();
do native::task::spawn { native::task::spawn(proc() {
assert_eq!(p1.recv(), 1); assert_eq!(p1.recv(), 1);
c2.send(2); c2.send(2);
chan2.send(()); chan2.send(());
} });
do native::task::spawn { native::task::spawn(proc() {
c1.send(1); c1.send(1);
assert_eq!(p2.recv(), 2); assert_eq!(p2.recv(), 2);
chan.send(()); chan.send(());
} });
port.recv(); port.recv();
port.recv(); port.recv();
} }
@@ -1148,11 +1148,11 @@ mod test {
test!(fn oneshot_single_thread_recv_chan_close() { test!(fn oneshot_single_thread_recv_chan_close() {
// Receiving on a closed chan will fail // Receiving on a closed chan will fail
let res = do task::try { let res = task::try(proc() {
let (port, chan) = Chan::<~int>::new(); let (port, chan) = Chan::<~int>::new();
{ let _c = chan; } { let _c = chan; }
port.recv(); port.recv();
}; });
// What is our res? // What is our res?
assert!(res.is_err()); assert!(res.is_err());
}) })
@@ -1208,30 +1208,30 @@ mod test {
test!(fn oneshot_multi_task_recv_then_send() { test!(fn oneshot_multi_task_recv_then_send() {
let (port, chan) = Chan::<~int>::new(); let (port, chan) = Chan::<~int>::new();
do spawn { spawn(proc() {
assert!(port.recv() == ~10); assert!(port.recv() == ~10);
} });
chan.send(~10); chan.send(~10);
}) })
test!(fn oneshot_multi_task_recv_then_close() { test!(fn oneshot_multi_task_recv_then_close() {
let (port, chan) = Chan::<~int>::new(); let (port, chan) = Chan::<~int>::new();
do spawn { spawn(proc() {
let _chan = chan; let _chan = chan;
} });
let res = do task::try { let res = task::try(proc() {
assert!(port.recv() == ~10); assert!(port.recv() == ~10);
}; });
assert!(res.is_err()); assert!(res.is_err());
}) })
test!(fn oneshot_multi_thread_close_stress() { test!(fn oneshot_multi_thread_close_stress() {
stress_factor().times(|| { stress_factor().times(|| {
let (port, chan) = Chan::<int>::new(); let (port, chan) = Chan::<int>::new();
do spawn { spawn(proc() {
let _p = port; let _p = port;
} });
let _chan = chan; let _chan = chan;
}) })
}) })
@@ -1239,43 +1239,43 @@ mod test {
test!(fn oneshot_multi_thread_send_close_stress() { test!(fn oneshot_multi_thread_send_close_stress() {
stress_factor().times(|| { stress_factor().times(|| {
let (port, chan) = Chan::<int>::new(); let (port, chan) = Chan::<int>::new();
do spawn { spawn(proc() {
let _p = port; let _p = port;
} });
do task::try { task::try(proc() {
chan.send(1); chan.send(1);
}; });
}) })
}) })
test!(fn oneshot_multi_thread_recv_close_stress() { test!(fn oneshot_multi_thread_recv_close_stress() {
stress_factor().times(|| { stress_factor().times(|| {
let (port, chan) = Chan::<int>::new(); let (port, chan) = Chan::<int>::new();
do spawn { spawn(proc() {
let port = port; let port = port;
let res = do task::try { let res = task::try(proc() {
port.recv(); port.recv();
}; });
assert!(res.is_err()); assert!(res.is_err());
}; });
do spawn { spawn(proc() {
let chan = chan; let chan = chan;
do spawn { spawn(proc() {
let _chan = chan; let _chan = chan;
} });
}; });
}) })
}) })
test!(fn oneshot_multi_thread_send_recv_stress() { test!(fn oneshot_multi_thread_send_recv_stress() {
stress_factor().times(|| { stress_factor().times(|| {
let (port, chan) = Chan::<~int>::new(); let (port, chan) = Chan::<~int>::new();
do spawn { spawn(proc() {
chan.send(~10); chan.send(~10);
} });
do spawn { spawn(proc() {
assert!(port.recv() == ~10); assert!(port.recv() == ~10);
} });
}) })
}) })
@@ -1289,19 +1289,19 @@ mod test {
fn send(chan: Chan<~int>, i: int) { fn send(chan: Chan<~int>, i: int) {
if i == 10 { return } if i == 10 { return }
do spawn { spawn(proc() {
chan.send(~i); chan.send(~i);
send(chan, i + 1); send(chan, i + 1);
} });
} }
fn recv(port: Port<~int>, i: int) { fn recv(port: Port<~int>, i: int) {
if i == 10 { return } if i == 10 { return }
do spawn { spawn(proc() {
assert!(port.recv() == ~i); assert!(port.recv() == ~i);
recv(port, i + 1); recv(port, i + 1);
}; });
} }
}) })
}) })
@@ -1318,9 +1318,9 @@ mod test {
let total = stress_factor() + 100; let total = stress_factor() + 100;
total.times(|| { total.times(|| {
let chan_clone = chan.clone(); let chan_clone = chan.clone();
do spawn { spawn(proc() {
chan_clone.send(()); chan_clone.send(());
} });
}); });
total.times(|| { total.times(|| {
@@ -1332,13 +1332,13 @@ mod test {
let (port, chan) = Chan::<int>::new(); let (port, chan) = Chan::<int>::new();
let (total_port, total_chan) = Chan::<int>::new(); let (total_port, total_chan) = Chan::<int>::new();
do spawn { spawn(proc() {
let mut acc = 0; let mut acc = 0;
for x in port.iter() { for x in port.iter() {
acc += x; acc += x;
} }
total_chan.send(acc); total_chan.send(acc);
} });
chan.send(3); chan.send(3);
chan.send(1); chan.send(1);
@@ -1351,7 +1351,7 @@ mod test {
let (port, chan) = Chan::<int>::new(); let (port, chan) = Chan::<int>::new();
let (count_port, count_chan) = Chan::<int>::new(); let (count_port, count_chan) = Chan::<int>::new();
do spawn { spawn(proc() {
let mut count = 0; let mut count = 0;
for x in port.iter() { for x in port.iter() {
if count >= 3 { if count >= 3 {
@@ -1361,7 +1361,7 @@ mod test {
} }
} }
count_chan.send(count); count_chan.send(count);
} });
chan.send(2); chan.send(2);
chan.send(2); chan.send(2);
@@ -1375,14 +1375,14 @@ mod test {
let (p, c) = Chan::<int>::new(); let (p, c) = Chan::<int>::new();
let (p1, c1) = Chan::<()>::new(); let (p1, c1) = Chan::<()>::new();
let (p2, c2) = Chan::<()>::new(); let (p2, c2) = Chan::<()>::new();
do spawn { spawn(proc() {
p1.recv(); p1.recv();
c.send(1); c.send(1);
c2.send(()); c2.send(());
p1.recv(); p1.recv();
drop(c); drop(c);
c2.send(()); c2.send(());
} });
assert_eq!(p.try_recv(), Empty); assert_eq!(p.try_recv(), Empty);
c1.send(()); c1.send(());

12
src/libstd/comm/select.rs
View File

@@ -378,12 +378,12 @@ mod test {
let (mut p2, _c2) = Chan::<int>::new(); let (mut p2, _c2) = Chan::<int>::new();
let (p3, c3) = Chan::<int>::new(); let (p3, c3) = Chan::<int>::new();
do spawn { spawn(proc() {
20.times(task::deschedule); 20.times(task::deschedule);
c1.send(1); c1.send(1);
p3.recv(); p3.recv();
20.times(task::deschedule); 20.times(task::deschedule);
} });
select! ( select! (
a = p1.recv() => { assert_eq!(a, 1); }, a = p1.recv() => { assert_eq!(a, 1); },
@@ -401,12 +401,12 @@ mod test {
let (mut p2, c2) = Chan::<int>::new(); let (mut p2, c2) = Chan::<int>::new();
let (p3, c3) = Chan::<()>::new(); let (p3, c3) = Chan::<()>::new();
do spawn { spawn(proc() {
20.times(task::deschedule); 20.times(task::deschedule);
c1.send(1); c1.send(1);
c2.send(2); c2.send(2);
p3.recv(); p3.recv();
} });
select! ( select! (
a = p1.recv() => { assert_eq!(a, 1); }, a = p1.recv() => { assert_eq!(a, 1); },
@@ -427,7 +427,7 @@ mod test {
let (mut p2, c2) = Chan::<int>::new(); let (mut p2, c2) = Chan::<int>::new();
let (p3, c3) = Chan::<()>::new(); let (p3, c3) = Chan::<()>::new();
do spawn { spawn(proc() {
for i in range(0, AMT) { for i in range(0, AMT) {
if i % 2 == 0 { if i % 2 == 0 {
c1.send(i); c1.send(i);
@@ -436,7 +436,7 @@ mod test {
} }
p3.recv(); p3.recv();
} }
} });
for i in range(0, AMT) { for i in range(0, AMT) {
select! ( select! (

6
src/libstd/io/comm_adapters.rs
View File

@@ -120,13 +120,13 @@ mod test {
#[test] #[test]
fn test_port_reader() { fn test_port_reader() {
let (port, chan) = Chan::new(); let (port, chan) = Chan::new();
do task::spawn { task::spawn(proc() {
chan.send(~[1u8, 2u8]); chan.send(~[1u8, 2u8]);
chan.send(~[]); chan.send(~[]);
chan.send(~[3u8, 4u8]); chan.send(~[3u8, 4u8]);
chan.send(~[5u8, 6u8]); chan.send(~[5u8, 6u8]);
chan.send(~[7u8, 8u8]); chan.send(~[7u8, 8u8]);
} });
let mut reader = PortReader::new(port); let mut reader = PortReader::new(port);
let mut buf = ~[0u8, ..3]; let mut buf = ~[0u8, ..3];
@@ -172,7 +172,7 @@ mod test {
writer.write_be_u32(42); writer.write_be_u32(42);
let wanted = ~[0u8, 0u8, 0u8, 42u8]; let wanted = ~[0u8, 0u8, 0u8, 42u8];
let got = do task::try { port.recv() }.unwrap(); let got = task::try(proc() { port.recv() }).unwrap();
assert_eq!(wanted, got); assert_eq!(wanted, got);
let mut err = None; let mut err = None;

100
src/libstd/io/net/tcp.rs
View File

@@ -167,11 +167,11 @@ mod test {
let addr = next_test_ip4(); let addr = next_test_ip4();
let (port, chan) = Chan::new(); let (port, chan) = Chan::new();
do spawn { spawn(proc() {
port.recv(); port.recv();
let mut stream = TcpStream::connect(addr); let mut stream = TcpStream::connect(addr);
stream.write([99]); stream.write([99]);
} });
let mut acceptor = TcpListener::bind(addr).listen(); let mut acceptor = TcpListener::bind(addr).listen();
chan.send(()); chan.send(());
@@ -185,11 +185,11 @@ mod test {
let addr = next_test_ip6(); let addr = next_test_ip6();
let (port, chan) = Chan::new(); let (port, chan) = Chan::new();
do spawn { spawn(proc() {
port.recv(); port.recv();
let mut stream = TcpStream::connect(addr); let mut stream = TcpStream::connect(addr);
stream.write([99]); stream.write([99]);
} });
let mut acceptor = TcpListener::bind(addr).listen(); let mut acceptor = TcpListener::bind(addr).listen();
chan.send(()); chan.send(());
@@ -203,11 +203,11 @@ mod test {
let addr = next_test_ip4(); let addr = next_test_ip4();
let (port, chan) = Chan::new(); let (port, chan) = Chan::new();
do spawn { spawn(proc() {
port.recv(); port.recv();
let _stream = TcpStream::connect(addr); let _stream = TcpStream::connect(addr);
// Close // Close
} });
let mut acceptor = TcpListener::bind(addr).listen(); let mut acceptor = TcpListener::bind(addr).listen();
chan.send(()); chan.send(());
@@ -221,11 +221,11 @@ mod test {
let addr = next_test_ip6(); let addr = next_test_ip6();
let (port, chan) = Chan::new(); let (port, chan) = Chan::new();
do spawn { spawn(proc() {
port.recv(); port.recv();
let _stream = TcpStream::connect(addr); let _stream = TcpStream::connect(addr);
// Close // Close
} });
let mut acceptor = TcpListener::bind(addr).listen(); let mut acceptor = TcpListener::bind(addr).listen();
chan.send(()); chan.send(());
@@ -239,11 +239,11 @@ mod test {
let addr = next_test_ip4(); let addr = next_test_ip4();
let (port, chan) = Chan::new(); let (port, chan) = Chan::new();
do spawn { spawn(proc() {
port.recv(); port.recv();
let _stream = TcpStream::connect(addr); let _stream = TcpStream::connect(addr);
// Close // Close
} });
let mut acceptor = TcpListener::bind(addr).listen(); let mut acceptor = TcpListener::bind(addr).listen();
chan.send(()); chan.send(());
@@ -267,11 +267,11 @@ mod test {
let addr = next_test_ip6(); let addr = next_test_ip6();
let (port, chan) = Chan::new(); let (port, chan) = Chan::new();
do spawn { spawn(proc() {
port.recv(); port.recv();
let _stream = TcpStream::connect(addr); let _stream = TcpStream::connect(addr);
// Close // Close
} });
let mut acceptor = TcpListener::bind(addr).listen(); let mut acceptor = TcpListener::bind(addr).listen();
chan.send(()); chan.send(());
@@ -295,11 +295,11 @@ mod test {
let addr = next_test_ip4(); let addr = next_test_ip4();
let (port, chan) = Chan::new(); let (port, chan) = Chan::new();
do spawn { spawn(proc() {
port.recv(); port.recv();
let _stream = TcpStream::connect(addr); let _stream = TcpStream::connect(addr);
// Close // Close
} });
let mut acceptor = TcpListener::bind(addr).listen(); let mut acceptor = TcpListener::bind(addr).listen();
chan.send(()); chan.send(());
@@ -326,11 +326,11 @@ mod test {
let addr = next_test_ip6(); let addr = next_test_ip6();
let (port, chan) = Chan::new(); let (port, chan) = Chan::new();
do spawn { spawn(proc() {
port.recv(); port.recv();
let _stream = TcpStream::connect(addr); let _stream = TcpStream::connect(addr);
// Close // Close
} });
let mut acceptor = TcpListener::bind(addr).listen(); let mut acceptor = TcpListener::bind(addr).listen();
chan.send(()); chan.send(());
@@ -358,13 +358,13 @@ mod test {
let max = 10; let max = 10;
let (port, chan) = Chan::new(); let (port, chan) = Chan::new();
do spawn { spawn(proc() {
port.recv(); port.recv();
max.times(|| { max.times(|| {
let mut stream = TcpStream::connect(addr); let mut stream = TcpStream::connect(addr);
stream.write([99]); stream.write([99]);
}); });
} });
let mut acceptor = TcpListener::bind(addr).listen(); let mut acceptor = TcpListener::bind(addr).listen();
chan.send(()); chan.send(());
@@ -380,13 +380,13 @@ mod test {
let max = 10; let max = 10;
let (port, chan) = Chan::new(); let (port, chan) = Chan::new();
do spawn { spawn(proc() {
port.recv(); port.recv();
max.times(|| { max.times(|| {
let mut stream = TcpStream::connect(addr); let mut stream = TcpStream::connect(addr);
stream.write([99]); stream.write([99]);
}); });
} });
let mut acceptor = TcpListener::bind(addr).listen(); let mut acceptor = TcpListener::bind(addr).listen();
chan.send(()); chan.send(());
@@ -402,20 +402,20 @@ mod test {
static MAX: int = 10; static MAX: int = 10;
let (port, chan) = Chan::new(); let (port, chan) = Chan::new();
do spawn { spawn(proc() {
let mut acceptor = TcpListener::bind(addr).listen(); let mut acceptor = TcpListener::bind(addr).listen();
chan.send(()); chan.send(());
for (i, stream) in acceptor.incoming().enumerate().take(MAX as uint) { for (i, stream) in acceptor.incoming().enumerate().take(MAX as uint) {
// Start another task to handle the connection // Start another task to handle the connection
do spawn { spawn(proc() {
let mut stream = stream; let mut stream = stream;
let mut buf = [0]; let mut buf = [0];
stream.read(buf); stream.read(buf);
assert!(buf[0] == i as u8); assert!(buf[0] == i as u8);
debug!("read"); debug!("read");
} });
} }
} });
port.recv(); port.recv();
connect(0, addr); connect(0, addr);
@@ -423,14 +423,14 @@ mod test {
fn connect(i: int, addr: SocketAddr) { fn connect(i: int, addr: SocketAddr) {
if i == MAX { return } if i == MAX { return }
do spawn { spawn(proc() {
debug!("connecting"); debug!("connecting");
let mut stream = TcpStream::connect(addr); let mut stream = TcpStream::connect(addr);
// Connect again before writing // Connect again before writing
connect(i + 1, addr); connect(i + 1, addr);
debug!("writing"); debug!("writing");
stream.write([i as u8]); stream.write([i as u8]);
} });
} }
}) })
@@ -439,20 +439,20 @@ mod test {
static MAX: int = 10; static MAX: int = 10;
let (port, chan) = Chan::<()>::new(); let (port, chan) = Chan::<()>::new();
do spawn { spawn(proc() {
let mut acceptor = TcpListener::bind(addr).listen(); let mut acceptor = TcpListener::bind(addr).listen();
chan.send(()); chan.send(());
for (i, stream) in acceptor.incoming().enumerate().take(MAX as uint) { for (i, stream) in acceptor.incoming().enumerate().take(MAX as uint) {
// Start another task to handle the connection // Start another task to handle the connection
do spawn { spawn(proc() {
let mut stream = stream; let mut stream = stream;
let mut buf = [0]; let mut buf = [0];
stream.read(buf); stream.read(buf);
assert!(buf[0] == i as u8); assert!(buf[0] == i as u8);
debug!("read"); debug!("read");
} });
} }
} });
port.recv(); port.recv();
connect(0, addr); connect(0, addr);
@@ -460,14 +460,14 @@ mod test {
fn connect(i: int, addr: SocketAddr) { fn connect(i: int, addr: SocketAddr) {
if i == MAX { return } if i == MAX { return }
do spawn { spawn(proc() {
debug!("connecting"); debug!("connecting");
let mut stream = TcpStream::connect(addr); let mut stream = TcpStream::connect(addr);
// Connect again before writing // Connect again before writing
connect(i + 1, addr); connect(i + 1, addr);
debug!("writing"); debug!("writing");
stream.write([i as u8]); stream.write([i as u8]);
} });
} }
}) })
@@ -476,20 +476,20 @@ mod test {
static MAX: int = 10; static MAX: int = 10;
let (port, chan) = Chan::new(); let (port, chan) = Chan::new();
do spawn { spawn(proc() {
let mut acceptor = TcpListener::bind(addr).listen(); let mut acceptor = TcpListener::bind(addr).listen();
chan.send(()); chan.send(());
for stream in acceptor.incoming().take(MAX as uint) { for stream in acceptor.incoming().take(MAX as uint) {
// Start another task to handle the connection // Start another task to handle the connection
do spawn { spawn(proc() {
let mut stream = stream; let mut stream = stream;
let mut buf = [0]; let mut buf = [0];
stream.read(buf); stream.read(buf);
assert!(buf[0] == 99); assert!(buf[0] == 99);
debug!("read"); debug!("read");
} });
} }
} });
port.recv(); port.recv();
connect(0, addr); connect(0, addr);
@@ -497,14 +497,14 @@ mod test {
fn connect(i: int, addr: SocketAddr) { fn connect(i: int, addr: SocketAddr) {
if i == MAX { return } if i == MAX { return }
do spawn { spawn(proc() {
debug!("connecting"); debug!("connecting");
let mut stream = TcpStream::connect(addr); let mut stream = TcpStream::connect(addr);
// Connect again before writing // Connect again before writing
connect(i + 1, addr); connect(i + 1, addr);
debug!("writing"); debug!("writing");
stream.write([99]); stream.write([99]);
} });
} }
}) })
@@ -513,20 +513,20 @@ mod test {
static MAX: int = 10; static MAX: int = 10;
let (port, chan) = Chan::new(); let (port, chan) = Chan::new();
do spawn { spawn(proc() {
let mut acceptor = TcpListener::bind(addr).listen(); let mut acceptor = TcpListener::bind(addr).listen();
chan.send(()); chan.send(());
for stream in acceptor.incoming().take(MAX as uint) { for stream in acceptor.incoming().take(MAX as uint) {
// Start another task to handle the connection // Start another task to handle the connection
do spawn { spawn(proc() {
let mut stream = stream; let mut stream = stream;
let mut buf = [0]; let mut buf = [0];
stream.read(buf); stream.read(buf);
assert!(buf[0] == 99); assert!(buf[0] == 99);
debug!("read"); debug!("read");
} });
} }
} });
port.recv(); port.recv();
connect(0, addr); connect(0, addr);
@@ -534,14 +534,14 @@ mod test {
fn connect(i: int, addr: SocketAddr) { fn connect(i: int, addr: SocketAddr) {
if i == MAX { return } if i == MAX { return }
do spawn { spawn(proc() {
debug!("connecting"); debug!("connecting");
let mut stream = TcpStream::connect(addr); let mut stream = TcpStream::connect(addr);
// Connect again before writing // Connect again before writing
connect(i + 1, addr); connect(i + 1, addr);
debug!("writing"); debug!("writing");
stream.write([99]); stream.write([99]);
} });
} }
}) })
@@ -558,11 +558,11 @@ mod test {
pub fn peer_name(addr: SocketAddr) { pub fn peer_name(addr: SocketAddr) {
let (port, chan) = Chan::new(); let (port, chan) = Chan::new();
do spawn { spawn(proc() {
let mut acceptor = TcpListener::bind(addr).listen(); let mut acceptor = TcpListener::bind(addr).listen();
chan.send(()); chan.send(());
acceptor.accept(); acceptor.accept();
} });
port.recv(); port.recv();
let stream = TcpStream::connect(addr); let stream = TcpStream::connect(addr);
@@ -592,7 +592,7 @@ mod test {
iotest!(fn partial_read() { iotest!(fn partial_read() {
let addr = next_test_ip4(); let addr = next_test_ip4();
let (p, c) = Chan::new(); let (p, c) = Chan::new();
do spawn { spawn(proc() {
let mut srv = TcpListener::bind(addr).listen(); let mut srv = TcpListener::bind(addr).listen();
c.send(()); c.send(());
let mut cl = srv.accept().unwrap(); let mut cl = srv.accept().unwrap();
@@ -600,7 +600,7 @@ mod test {
let mut b = [0]; let mut b = [0];
cl.read(b); cl.read(b);
c.send(()); c.send(());
} });
p.recv(); p.recv();
let mut c = TcpStream::connect(addr).unwrap(); let mut c = TcpStream::connect(addr).unwrap();
@@ -630,12 +630,12 @@ mod test {
let addr = next_test_ip4(); let addr = next_test_ip4();
let (port, chan) = Chan::new(); let (port, chan) = Chan::new();
do spawn { spawn(proc() {
port.recv(); port.recv();
let stream = TcpStream::connect(addr); let stream = TcpStream::connect(addr);
// Close // Close
port.recv(); port.recv();
} });
{ {
let mut acceptor = TcpListener::bind(addr).listen(); let mut acceptor = TcpListener::bind(addr).listen();

16
src/libstd/io/net/udp.rs
View File

@@ -119,7 +119,7 @@ mod test {
let (port, chan) = Chan::new(); let (port, chan) = Chan::new();
let (port2, chan2) = Chan::new(); let (port2, chan2) = Chan::new();
do spawn { spawn(proc() {
match UdpSocket::bind(client_ip) { match UdpSocket::bind(client_ip) {
Some(ref mut client) => { Some(ref mut client) => {
port.recv(); port.recv();
@@ -128,7 +128,7 @@ mod test {
None => fail!() None => fail!()
} }
chan2.send(()); chan2.send(());
} });
match UdpSocket::bind(server_ip) { match UdpSocket::bind(server_ip) {
Some(ref mut server) => { Some(ref mut server) => {
@@ -153,7 +153,7 @@ mod test {
let client_ip = next_test_ip6(); let client_ip = next_test_ip6();
let (port, chan) = Chan::<()>::new(); let (port, chan) = Chan::<()>::new();
do spawn { spawn(proc() {
match UdpSocket::bind(client_ip) { match UdpSocket::bind(client_ip) {
Some(ref mut client) => { Some(ref mut client) => {
port.recv(); port.recv();
@@ -161,7 +161,7 @@ mod test {
} }
None => fail!() None => fail!()
} }
} });
match UdpSocket::bind(server_ip) { match UdpSocket::bind(server_ip) {
Some(ref mut server) => { Some(ref mut server) => {
@@ -186,7 +186,7 @@ mod test {
let (port, chan) = Chan::new(); let (port, chan) = Chan::new();
let (port2, chan2) = Chan::new(); let (port2, chan2) = Chan::new();
do spawn { spawn(proc() {
match UdpSocket::bind(client_ip) { match UdpSocket::bind(client_ip) {
Some(client) => { Some(client) => {
let client = ~client; let client = ~client;
@@ -197,7 +197,7 @@ mod test {
None => fail!() None => fail!()
} }
chan2.send(()); chan2.send(());
} });
match UdpSocket::bind(server_ip) { match UdpSocket::bind(server_ip) {
Some(server) => { Some(server) => {
@@ -224,7 +224,7 @@ mod test {
let (port, chan) = Chan::new(); let (port, chan) = Chan::new();
let (port2, chan2) = Chan::new(); let (port2, chan2) = Chan::new();
do spawn { spawn(proc() {
match UdpSocket::bind(client_ip) { match UdpSocket::bind(client_ip) {
Some(client) => { Some(client) => {
let client = ~client; let client = ~client;
@@ -235,7 +235,7 @@ mod test {
None => fail!() None => fail!()
} }
chan2.send(()); chan2.send(());
} });
match UdpSocket::bind(server_ip) { match UdpSocket::bind(server_ip) {
Some(server) => { Some(server) => {

8
src/libstd/io/net/unix.rs
View File

@@ -147,10 +147,10 @@ mod tests {
let path2 = path1.clone(); let path2 = path1.clone();
let (port, chan) = Chan::new(); let (port, chan) = Chan::new();
do spawn { spawn(proc() {
port.recv(); port.recv();
client(UnixStream::connect(&path2).unwrap()); client(UnixStream::connect(&path2).unwrap());
} });
let mut acceptor = UnixListener::bind(&path1).listen(); let mut acceptor = UnixListener::bind(&path1).listen();
chan.send(()); chan.send(());
@@ -232,13 +232,13 @@ mod tests {
let path2 = path1.clone(); let path2 = path1.clone();
let (port, chan) = Chan::new(); let (port, chan) = Chan::new();
do spawn { spawn(proc() {
port.recv(); port.recv();
times.times(|| { times.times(|| {
let mut stream = UnixStream::connect(&path2); let mut stream = UnixStream::connect(&path2);
stream.write([100]); stream.write([100]);
}) })
} });
let mut acceptor = UnixListener::bind(&path1).listen(); let mut acceptor = UnixListener::bind(&path1).listen();
chan.send(()); chan.send(());

4
src/libstd/io/pipe.rs
View File

@@ -89,11 +89,11 @@ mod test {
let out = PipeStream::open(out); let out = PipeStream::open(out);
let mut input = PipeStream::open(input); let mut input = PipeStream::open(input);
let (p, c) = Chan::new(); let (p, c) = Chan::new();
do spawn { spawn(proc() {
let mut out = out; let mut out = out;
out.write([10]); out.write([10]);
p.recv(); // don't close the pipe until the other read has finished p.recv(); // don't close the pipe until the other read has finished
} });
let mut buf = [0, ..10]; let mut buf = [0, ..10];
input.read(buf); input.read(buf);

4
src/libstd/io/signal.rs
View File

@@ -65,14 +65,14 @@ pub enum Signum {
/// let mut listener = Listener::new(); /// let mut listener = Listener::new();
/// listener.register(Interrupt); /// listener.register(Interrupt);
/// ///
/// do spawn { /// spawn({
/// loop { /// loop {
/// match listener.port.recv() { /// match listener.port.recv() {
/// Interrupt => println!("Got Interrupt'ed"), /// Interrupt => println!("Got Interrupt'ed"),
/// _ => (), /// _ => (),
/// } /// }
/// } /// }
/// } /// });
/// ///
/// ``` /// ```
pub struct Listener { pub struct Listener {

8
src/libstd/io/stdio.rs
View File

@@ -372,10 +372,10 @@ mod tests {
let (p, c) = Chan::new(); let (p, c) = Chan::new();
let (mut r, w) = (PortReader::new(p), ChanWriter::new(c)); let (mut r, w) = (PortReader::new(p), ChanWriter::new(c));
do spawn { spawn(proc() {
set_stdout(~w as ~Writer); set_stdout(~w as ~Writer);
println!("hello!"); println!("hello!");
} });
assert_eq!(r.read_to_str(), ~"hello!\n"); assert_eq!(r.read_to_str(), ~"hello!\n");
}) })
@@ -384,10 +384,10 @@ mod tests {
let (p, c) = Chan::new(); let (p, c) = Chan::new();
let (mut r, w) = (PortReader::new(p), ChanWriter::new(c)); let (mut r, w) = (PortReader::new(p), ChanWriter::new(c));
do spawn { spawn(proc() {
set_stderr(~w as ~Writer); set_stderr(~w as ~Writer);
fail!("my special message"); fail!("my special message");
} });
let s = r.read_to_str(); let s = r.read_to_str();
assert!(s.contains("my special message")); assert!(s.contains("my special message"));
}) })

2
src/libstd/io/test.rs
View File

@@ -45,7 +45,7 @@ macro_rules! iotest (
$($a)* #[test] fn native() { $($a)* #[test] fn native() {
use native; use native;
let (p, c) = Chan::new(); let (p, c) = Chan::new();
do native::task::spawn { c.send(f()) } native::task::spawn(proc() { c.send(f()) });
p.recv(); p.recv();
} }
} }

12
src/libstd/io/timer.rs
View File

@@ -204,9 +204,9 @@ mod test {
let mut timer = Timer::new().unwrap(); let mut timer = Timer::new().unwrap();
let timer_port = timer.periodic(1000); let timer_port = timer.periodic(1000);
do spawn { spawn(proc() {
timer_port.recv_opt(); timer_port.recv_opt();
} });
// when we drop the TimerWatcher we're going to destroy the channel, // when we drop the TimerWatcher we're going to destroy the channel,
// which must wake up the task on the other end // which must wake up the task on the other end
@@ -217,9 +217,9 @@ mod test {
let mut timer = Timer::new().unwrap(); let mut timer = Timer::new().unwrap();
let timer_port = timer.periodic(1000); let timer_port = timer.periodic(1000);
do spawn { spawn(proc() {
timer_port.recv_opt(); timer_port.recv_opt();
} });
timer.oneshot(1); timer.oneshot(1);
}) })
@@ -229,9 +229,9 @@ mod test {
let mut timer = Timer::new().unwrap(); let mut timer = Timer::new().unwrap();
let timer_port = timer.periodic(1000); let timer_port = timer.periodic(1000);
do spawn { spawn(proc() {
timer_port.recv_opt(); timer_port.recv_opt();
} });
timer.sleep(1); timer.sleep(1);
}) })

20
src/libstd/local_data.rs
View File

@@ -355,14 +355,14 @@ mod tests {
fn test_tls_multitask() { fn test_tls_multitask() {
static my_key: Key<~str> = &Key; static my_key: Key<~str> = &Key;
set(my_key, ~"parent data"); set(my_key, ~"parent data");
do task::spawn { task::spawn(proc() {
// TLS shouldn't carry over. // TLS shouldn't carry over.
assert!(get(my_key, |k| k.map(|k| (*k).clone())).is_none()); assert!(get(my_key, |k| k.map(|k| (*k).clone())).is_none());
set(my_key, ~"child data"); set(my_key, ~"child data");
assert!(get(my_key, |k| k.map(|k| (*k).clone())).unwrap() == assert!(get(my_key, |k| k.map(|k| (*k).clone())).unwrap() ==
~"child data"); ~"child data");
// should be cleaned up for us // should be cleaned up for us
} });
// Must work multiple times // Must work multiple times
assert!(get(my_key, |k| k.map(|k| (*k).clone())).unwrap() == ~"parent data"); assert!(get(my_key, |k| k.map(|k| (*k).clone())).unwrap() == ~"parent data");
assert!(get(my_key, |k| k.map(|k| (*k).clone())).unwrap() == ~"parent data"); assert!(get(my_key, |k| k.map(|k| (*k).clone())).unwrap() == ~"parent data");
@@ -414,9 +414,9 @@ mod tests {
// subsequent upcall (esp. for logging, think vsnprintf) would run on // subsequent upcall (esp. for logging, think vsnprintf) would run on
// a stack smaller than 1 MB. // a stack smaller than 1 MB.
static my_key: Key<~str> = &Key; static my_key: Key<~str> = &Key;
do task::spawn { task::spawn(proc() {
set(my_key, ~"hax"); set(my_key, ~"hax");
} });
} }
#[test] #[test]
@@ -424,11 +424,11 @@ mod tests {
static str_key: Key<~str> = &Key; static str_key: Key<~str> = &Key;
static box_key: Key<@()> = &Key; static box_key: Key<@()> = &Key;
static int_key: Key<int> = &Key; static int_key: Key<int> = &Key;
do task::spawn { task::spawn(proc() {
set(str_key, ~"string data"); set(str_key, ~"string data");
set(box_key, @()); set(box_key, @());
set(int_key, 42); set(int_key, 42);
} });
} }
#[test] #[test]
@@ -437,7 +437,7 @@ mod tests {
static str_key: Key<~str> = &Key; static str_key: Key<~str> = &Key;
static box_key: Key<@()> = &Key; static box_key: Key<@()> = &Key;
static int_key: Key<int> = &Key; static int_key: Key<int> = &Key;
do task::spawn { task::spawn(proc() {
set(str_key, ~"string data"); set(str_key, ~"string data");
set(str_key, ~"string data 2"); set(str_key, ~"string data 2");
set(box_key, @()); set(box_key, @());
@@ -447,7 +447,7 @@ mod tests {
// with the crazy polymorphic transmute rather than the provided // with the crazy polymorphic transmute rather than the provided
// finaliser. // finaliser.
set(int_key, 31337); set(int_key, 31337);
} });
} }
#[test] #[test]
@@ -458,13 +458,13 @@ mod tests {
static int_key: Key<int> = &Key; static int_key: Key<int> = &Key;
set(str_key, ~"parent data"); set(str_key, ~"parent data");
set(box_key, @()); set(box_key, @());
do task::spawn { task::spawn(proc() {
// spawn_linked // spawn_linked
set(str_key, ~"string data"); set(str_key, ~"string data");
set(box_key, @()); set(box_key, @());
set(int_key, 42); set(int_key, 42);
fail!(); fail!();
} });
// Not quite nondeterministic. // Not quite nondeterministic.
set(int_key, 31337); set(int_key, 31337);
fail!(); fail!();

4
src/libstd/path/posix.rs
View File

@@ -569,11 +569,11 @@ mod tests {
use task; use task;
macro_rules! t( macro_rules! t(
($name:expr => $code:block) => ( ($name:expr => $code:expr) => (
{ {
let mut t = task::task(); let mut t = task::task();
t.name($name); t.name($name);
let res = do t.try $code; let res = t.try(proc() $code);
assert!(res.is_err()); assert!(res.is_err());
} }
) )

4
src/libstd/path/windows.rs
View File

@@ -1290,11 +1290,11 @@ mod tests {
use task; use task;
macro_rules! t( macro_rules! t(
($name:expr => $code:block) => ( ($name:expr => $code:expr) => (
{ {
let mut t = task::task(); let mut t = task::task();
t.name($name); t.name($name);
let res = do t.try $code; let res = t.try(proc() $code);
assert!(res.is_err()); assert!(res.is_err());
} }
) )

4
src/libstd/rand/os.rs
View File

@@ -159,7 +159,7 @@ mod test {
for _ in range(0, 20) { for _ in range(0, 20) {
let (p, c) = Chan::new(); let (p, c) = Chan::new();
chans.push(c); chans.push(c);
do task::spawn { task::spawn(proc() {
// wait until all the tasks are ready to go. // wait until all the tasks are ready to go.
p.recv(); p.recv();
@@ -177,7 +177,7 @@ mod test {
r.fill_bytes(v); r.fill_bytes(v);
task::deschedule(); task::deschedule();
} }
} })
} }
// start all the tasks // start all the tasks

21
src/libstd/rt/local.rs
View File

@@ -57,17 +57,17 @@ mod test {
#[test] #[test]
fn thread_local_task_smoke_test() { fn thread_local_task_smoke_test() {
do run_in_bare_thread { run_in_bare_thread(proc() {
let task = ~Task::new(); let task = ~Task::new();
Local::put(task); Local::put(task);
let task: ~Task = Local::take(); let task: ~Task = Local::take();
cleanup_task(task); cleanup_task(task);
} });
} }
#[test] #[test]
fn thread_local_task_two_instances() { fn thread_local_task_two_instances() {
do run_in_bare_thread { run_in_bare_thread(proc() {
let task = ~Task::new(); let task = ~Task::new();
Local::put(task); Local::put(task);
let task: ~Task = Local::take(); let task: ~Task = Local::take();
@@ -76,13 +76,12 @@ mod test {
Local::put(task); Local::put(task);
let task: ~Task = Local::take(); let task: ~Task = Local::take();
cleanup_task(task); cleanup_task(task);
} });
} }
#[test] #[test]
fn borrow_smoke_test() { fn borrow_smoke_test() {
do run_in_bare_thread { run_in_bare_thread(proc() {
let task = ~Task::new(); let task = ~Task::new();
Local::put(task); Local::put(task);
@@ -91,12 +90,12 @@ mod test {
} }
let task: ~Task = Local::take(); let task: ~Task = Local::take();
cleanup_task(task); cleanup_task(task);
} });
} }
#[test] #[test]
fn borrow_with_return() { fn borrow_with_return() {
do run_in_bare_thread { run_in_bare_thread(proc() {
let task = ~Task::new(); let task = ~Task::new();
Local::put(task); Local::put(task);
@@ -106,12 +105,12 @@ mod test {
let task: ~Task = Local::take(); let task: ~Task = Local::take();
cleanup_task(task); cleanup_task(task);
} });
} }
#[test] #[test]
fn try_take() { fn try_take() {
do run_in_bare_thread { run_in_bare_thread(proc() {
let task = ~Task::new(); let task = ~Task::new();
Local::put(task); Local::put(task);
@@ -120,7 +119,7 @@ mod test {
assert!(u.is_none()); assert!(u.is_none());
cleanup_task(t); cleanup_task(t);
} });
} }
fn cleanup_task(mut t: ~Task) { fn cleanup_task(mut t: ~Task) {

6
src/libstd/rt/thread.rs
View File

@@ -255,11 +255,11 @@ mod tests {
use super::Thread; use super::Thread;
#[test] #[test]
fn smoke() { do Thread::start {}.join(); } fn smoke() { Thread::start(proc (){}).join(); }
#[test] #[test]
fn data() { assert_eq!(do Thread::start { 1 }.join(), 1); } fn data() { assert_eq!(Thread::start(proc () { 1 }).join(), 1); }
#[test] #[test]
fn detached() { do Thread::spawn {} } fn detached() { Thread::spawn(proc () {}) }
} }

12
src/libstd/run.rs
View File

@@ -223,22 +223,22 @@ impl Process {
let (p, ch) = SharedChan::new(); let (p, ch) = SharedChan::new();
let ch_clone = ch.clone(); let ch_clone = ch.clone();
do spawn { spawn(proc() {
let _guard = io::ignore_io_error(); let _guard = io::ignore_io_error();
let mut error = error; let mut error = error;
match error { match error {
Some(ref mut e) => ch.send((2, e.read_to_end())), Some(ref mut e) => ch.send((2, e.read_to_end())),
None => ch.send((2, ~[])) None => ch.send((2, ~[]))
} }
} });
do spawn { spawn(proc() {
let _guard = io::ignore_io_error(); let _guard = io::ignore_io_error();
let mut output = output; let mut output = output;
match output { match output {
Some(ref mut e) => ch_clone.send((1, e.read_to_end())), Some(ref mut e) => ch_clone.send((1, e.read_to_end())),
None => ch_clone.send((1, ~[])) None => ch_clone.send((1, ~[]))
} }
} });
let status = self.finish(); let status = self.finish();
@@ -414,9 +414,9 @@ mod tests {
os::close(pipe_out.out as int); os::close(pipe_out.out as int);
os::close(pipe_err.out as int); os::close(pipe_err.out as int);
do spawn { spawn(proc() {
writeclose(pipe_in.out, "test"); writeclose(pipe_in.out, "test");
} });
let actual = readclose(pipe_out.input); let actual = readclose(pipe_out.input);
readclose(pipe_err.input); readclose(pipe_err.input);
process.finish(); process.finish();

24
src/libstd/sync/deque.rs
View File

@@ -425,7 +425,7 @@ mod tests {
static AMT: int = 100000; static AMT: int = 100000;
let mut pool = BufferPool::<int>::new(); let mut pool = BufferPool::<int>::new();
let (mut w, s) = pool.deque(); let (mut w, s) = pool.deque();
let t = do Thread::start { let t = Thread::start(proc() {
let mut s = s; let mut s = s;
let mut left = AMT; let mut left = AMT;
while left > 0 { while left > 0 {
@@ -437,7 +437,7 @@ mod tests {
Abort | Empty => {} Abort | Empty => {}
} }
} }
}; });
for _ in range(0, AMT) { for _ in range(0, AMT) {
w.push(1); w.push(1);
@@ -451,7 +451,7 @@ mod tests {
static AMT: int = 100000; static AMT: int = 100000;
let mut pool = BufferPool::<(int, int)>::new(); let mut pool = BufferPool::<(int, int)>::new();
let (mut w, s) = pool.deque(); let (mut w, s) = pool.deque();
let t = do Thread::start { let t = Thread::start(proc() {
let mut s = s; let mut s = s;
let mut left = AMT; let mut left = AMT;
while left > 0 { while left > 0 {
@@ -461,7 +461,7 @@ mod tests {
Abort | Empty => {} Abort | Empty => {}
} }
} }
}; });
for _ in range(0, AMT) { for _ in range(0, AMT) {
w.push((1, 10)); w.push((1, 10));
@@ -480,7 +480,7 @@ mod tests {
let threads = range(0, nthreads).map(|_| { let threads = range(0, nthreads).map(|_| {
let s = s.clone(); let s = s.clone();
do Thread::start { Thread::start(proc() {
unsafe { unsafe {
let mut s = s; let mut s = s;
while (*unsafe_remaining).load(SeqCst) > 0 { while (*unsafe_remaining).load(SeqCst) > 0 {
@@ -493,7 +493,7 @@ mod tests {
} }
} }
} }
} })
}).to_owned_vec(); }).to_owned_vec();
while remaining.load(SeqCst) > 0 { while remaining.load(SeqCst) > 0 {
@@ -522,9 +522,9 @@ mod tests {
let mut pool = BufferPool::<~int>::new(); let mut pool = BufferPool::<~int>::new();
let threads = range(0, AMT).map(|_| { let threads = range(0, AMT).map(|_| {
let (w, s) = pool.deque(); let (w, s) = pool.deque();
do Thread::start { Thread::start(proc() {
stampede(w, s, 4, 10000); stampede(w, s, 4, 10000);
} })
}).to_owned_vec(); }).to_owned_vec();
for thread in threads.move_iter() { for thread in threads.move_iter() {
@@ -543,7 +543,7 @@ mod tests {
let threads = range(0, NTHREADS).map(|_| { let threads = range(0, NTHREADS).map(|_| {
let s = s.clone(); let s = s.clone();
do Thread::start { Thread::start(proc() {
unsafe { unsafe {
let mut s = s; let mut s = s;
loop { loop {
@@ -555,7 +555,7 @@ mod tests {
} }
} }
} }
} })
}).to_owned_vec(); }).to_owned_vec();
let mut rng = rand::task_rng(); let mut rng = rand::task_rng();
@@ -606,7 +606,7 @@ mod tests {
let thread_box = unsafe { let thread_box = unsafe {
*cast::transmute::<&~AtomicUint,**mut AtomicUint>(&unique_box) *cast::transmute::<&~AtomicUint,**mut AtomicUint>(&unique_box)
}; };
(do Thread::start { (Thread::start(proc() {
unsafe { unsafe {
let mut s = s; let mut s = s;
loop { loop {
@@ -620,7 +620,7 @@ mod tests {
} }
} }
} }
}, unique_box) }), unique_box)
})); }));
let mut rng = rand::task_rng(); let mut rng = rand::task_rng();

8
src/libstd/sync/mpmc_bounded_queue.rs
View File

@@ -177,13 +177,13 @@ mod tests {
for _ in range(0, nthreads) { for _ in range(0, nthreads) {
let q = q.clone(); let q = q.clone();
let chan = chan.clone(); let chan = chan.clone();
do native::task::spawn { native::task::spawn(proc() {
let mut q = q; let mut q = q;
for i in range(0, nmsgs) { for i in range(0, nmsgs) {
assert!(q.push(i)); assert!(q.push(i));
} }
chan.send(()); chan.send(());
} });
} }
let mut completion_ports = ~[]; let mut completion_ports = ~[];
@@ -191,7 +191,7 @@ mod tests {
let (completion_port, completion_chan) = Chan::new(); let (completion_port, completion_chan) = Chan::new();
completion_ports.push(completion_port); completion_ports.push(completion_port);
let q = q.clone(); let q = q.clone();
do native::task::spawn { native::task::spawn(proc() {
let mut q = q; let mut q = q;
let mut i = 0u; let mut i = 0u;
loop { loop {
@@ -204,7 +204,7 @@ mod tests {
} }
} }
completion_chan.send(i); completion_chan.send(i);
} });
} }
for completion_port in completion_ports.mut_iter() { for completion_port in completion_ports.mut_iter() {

4
src/libstd/sync/mpsc_queue.rs
View File

@@ -227,13 +227,13 @@ mod tests {
for _ in range(0, nthreads) { for _ in range(0, nthreads) {
let q = p.clone(); let q = p.clone();
let chan = chan.clone(); let chan = chan.clone();
do native::task::spawn { native::task::spawn(proc() {
let mut q = q; let mut q = q;
for i in range(0, nmsgs) { for i in range(0, nmsgs) {
q.push(i); q.push(i);
} }
chan.send(()); chan.send(());
} });
} }
let mut i = 0u; let mut i = 0u;

4
src/libstd/sync/spsc_queue.rs
View File

@@ -315,7 +315,7 @@ mod test {
fn stress_bound(bound: uint) { fn stress_bound(bound: uint) {
let (c, mut p) = queue(bound, ()); let (c, mut p) = queue(bound, ());
let (port, chan) = Chan::new(); let (port, chan) = Chan::new();
do native::task::spawn { native::task::spawn(proc() {
let mut c = c; let mut c = c;
for _ in range(0, 100000) { for _ in range(0, 100000) {
loop { loop {
@@ -327,7 +327,7 @@ mod test {
} }
} }
chan.send(()); chan.send(());
} });
for _ in range(0, 100000) { for _ in range(0, 100000) {
p.push(1); p.push(1);
} }

88
src/libstd/task.rs
View File

@@ -45,9 +45,9 @@
* # Example * # Example
* *
* ``` * ```
* do spawn { * spawn(proc() {
* log(error, "Hello, World!"); * log(error, "Hello, World!");
* } * })
* ``` * ```
*/ */
@@ -265,9 +265,9 @@ impl TaskBuilder {
let result = self.future_result(); let result = self.future_result();
do self.spawn { self.spawn(proc() {
ch.send(f()); ch.send(f());
} });
match result.recv() { match result.recv() {
Ok(()) => Ok(po.recv()), Ok(()) => Ok(po.recv()),
@@ -365,52 +365,52 @@ pub fn failing() -> bool {
#[test] #[test]
fn test_unnamed_task() { fn test_unnamed_task() {
do spawn { spawn(proc() {
with_task_name(|name| { with_task_name(|name| {
assert!(name.is_none()); assert!(name.is_none());
}) })
} })
} }
#[test] #[test]
fn test_owned_named_task() { fn test_owned_named_task() {
let mut t = task(); let mut t = task();
t.name(~"ada lovelace"); t.name(~"ada lovelace");
do t.spawn { t.spawn(proc() {
with_task_name(|name| { with_task_name(|name| {
assert!(name.unwrap() == "ada lovelace"); assert!(name.unwrap() == "ada lovelace");
}) })
} })
} }
#[test] #[test]
fn test_static_named_task() { fn test_static_named_task() {
let mut t = task(); let mut t = task();
t.name("ada lovelace"); t.name("ada lovelace");
do t.spawn { t.spawn(proc() {
with_task_name(|name| { with_task_name(|name| {
assert!(name.unwrap() == "ada lovelace"); assert!(name.unwrap() == "ada lovelace");
}) })
} })
} }
#[test] #[test]
fn test_send_named_task() { fn test_send_named_task() {
let mut t = task(); let mut t = task();
t.name("ada lovelace".into_send_str()); t.name("ada lovelace".into_send_str());
do t.spawn { t.spawn(proc() {
with_task_name(|name| { with_task_name(|name| {
assert!(name.unwrap() == "ada lovelace"); assert!(name.unwrap() == "ada lovelace");
}) })
} })
} }
#[test] #[test]
fn test_run_basic() { fn test_run_basic() {
let (po, ch) = Chan::new(); let (po, ch) = Chan::new();
do task().spawn { task().spawn(proc() {
ch.send(()); ch.send(());
} });
po.recv(); po.recv();
} }
@@ -418,15 +418,15 @@ fn test_run_basic() {
fn test_add_wrapper() { fn test_add_wrapper() {
let (po, ch) = Chan::new(); let (po, ch) = Chan::new();
let mut b0 = task(); let mut b0 = task();
do b0.add_wrapper |body| { b0.add_wrapper(proc(body) {
let ch = ch; let ch = ch;
let result: proc() = proc() { let result: proc() = proc() {
body(); body();
ch.send(()); ch.send(());
}; };
result result
}; });
do b0.spawn { } b0.spawn(proc() { });
po.recv(); po.recv();
} }
@@ -434,14 +434,14 @@ fn test_add_wrapper() {
fn test_future_result() { fn test_future_result() {
let mut builder = task(); let mut builder = task();
let result = builder.future_result(); let result = builder.future_result();
do builder.spawn {} builder.spawn(proc() {});
assert!(result.recv().is_ok()); assert!(result.recv().is_ok());
let mut builder = task(); let mut builder = task();
let result = builder.future_result(); let result = builder.future_result();
do builder.spawn { builder.spawn(proc() {
fail!(); fail!();
} });
assert!(result.recv().is_err()); assert!(result.recv().is_err());
} }
@@ -454,9 +454,9 @@ fn test_back_to_the_future_result() {
#[test] #[test]
fn test_try_success() { fn test_try_success() {
match do try { match try(proc() {
~"Success!" ~"Success!"
} { }) {
result::Ok(~"Success!") => (), result::Ok(~"Success!") => (),
_ => fail!() _ => fail!()
} }
@@ -464,9 +464,9 @@ fn test_try_success() {
#[test] #[test]
fn test_try_fail() { fn test_try_fail() {
match do try { match try(proc() {
fail!() fail!()
} { }) {
result::Err(_) => (), result::Err(_) => (),
result::Ok(()) => fail!() result::Ok(()) => fail!()
} }
@@ -480,13 +480,13 @@ fn test_spawn_sched() {
fn f(i: int, ch: SharedChan<()>) { fn f(i: int, ch: SharedChan<()>) {
let ch = ch.clone(); let ch = ch.clone();
do spawn { spawn(proc() {
if i == 0 { if i == 0 {
ch.send(()); ch.send(());
} else { } else {
f(i - 1, ch); f(i - 1, ch);
} }
}; });
} }
f(10, ch); f(10, ch);
@@ -497,12 +497,12 @@ fn test_spawn_sched() {
fn test_spawn_sched_childs_on_default_sched() { fn test_spawn_sched_childs_on_default_sched() {
let (po, ch) = Chan::new(); let (po, ch) = Chan::new();
do spawn { spawn(proc() {
let ch = ch; let ch = ch;
do spawn { spawn(proc() {
ch.send(()); ch.send(());
}; });
}; });
po.recv(); po.recv();
} }
@@ -514,10 +514,10 @@ fn avoid_copying_the_body(spawnfn: |v: proc()|) {
let x = ~1; let x = ~1;
let x_in_parent = ptr::to_unsafe_ptr(&*x) as uint; let x_in_parent = ptr::to_unsafe_ptr(&*x) as uint;
do spawnfn { spawnfn(proc() {
let x_in_child = ptr::to_unsafe_ptr(&*x) as uint; let x_in_child = ptr::to_unsafe_ptr(&*x) as uint;
ch.send(x_in_child); ch.send(x_in_child);
} });
let x_in_child = p.recv(); let x_in_child = p.recv();
assert_eq!(x_in_parent, x_in_child); assert_eq!(x_in_parent, x_in_child);
@@ -532,18 +532,18 @@ fn test_avoid_copying_the_body_spawn() {
fn test_avoid_copying_the_body_task_spawn() { fn test_avoid_copying_the_body_task_spawn() {
avoid_copying_the_body(|f| { avoid_copying_the_body(|f| {
let builder = task(); let builder = task();
do builder.spawn || { builder.spawn(proc() {
f(); f();
} });
}) })
} }
#[test] #[test]
fn test_avoid_copying_the_body_try() { fn test_avoid_copying_the_body_try() {
avoid_copying_the_body(|f| { avoid_copying_the_body(|f| {
do try || { try(proc() {
f() f()
}; });
}) })
} }
@@ -575,9 +575,9 @@ fn test_simple_newsched_spawn() {
#[test] #[test]
fn test_try_fail_message_static_str() { fn test_try_fail_message_static_str() {
match do try { match try(proc() {
fail!("static string"); fail!("static string");
} { }) {
Err(e) => { Err(e) => {
type T = &'static str; type T = &'static str;
assert!(e.is::<T>()); assert!(e.is::<T>());
@@ -589,9 +589,9 @@ fn test_try_fail_message_static_str() {
#[test] #[test]
fn test_try_fail_message_owned_str() { fn test_try_fail_message_owned_str() {
match do try { match try(proc() {
fail!(~"owned string"); fail!(~"owned string");
} { }) {
Err(e) => { Err(e) => {
type T = ~str; type T = ~str;
assert!(e.is::<T>()); assert!(e.is::<T>());
@@ -603,9 +603,9 @@ fn test_try_fail_message_owned_str() {
#[test] #[test]
fn test_try_fail_message_any() { fn test_try_fail_message_any() {
match do try { match try(proc() {
fail!(~413u16 as ~Any); fail!(~413u16 as ~Any);
} { }) {
Err(e) => { Err(e) => {
type T = ~Any; type T = ~Any;
assert!(e.is::<T>()); assert!(e.is::<T>());
@@ -621,9 +621,9 @@ fn test_try_fail_message_any() {
fn test_try_fail_message_unit_struct() { fn test_try_fail_message_unit_struct() {
struct Juju; struct Juju;
match do try { match try(proc() {
fail!(Juju) fail!(Juju)
} { }) {
Err(ref e) if e.is::<Juju>() => {} Err(ref e) if e.is::<Juju>() => {}
Err(_) | Ok(()) => fail!() Err(_) | Ok(()) => fail!()
} }

8
src/libstd/unstable/mod.rs
View File

@@ -41,18 +41,18 @@ pub fn run_in_bare_thread(f: proc()) {
#[test] #[test]
fn test_run_in_bare_thread() { fn test_run_in_bare_thread() {
let i = 100; let i = 100;
do run_in_bare_thread { run_in_bare_thread(proc() {
assert_eq!(i, 100); assert_eq!(i, 100);
} });
} }
#[test] #[test]
fn test_run_in_bare_thread_exchange() { fn test_run_in_bare_thread_exchange() {
// Does the exchange heap work without the runtime? // Does the exchange heap work without the runtime?
let i = ~100; let i = ~100;
do run_in_bare_thread { run_in_bare_thread(proc() {
assert!(i == ~100); assert!(i == ~100);
} });
} }
/// Dynamically inquire about whether we're running under V. /// Dynamically inquire about whether we're running under V.

8
src/libstd/unstable/mutex.rs
View File

@@ -439,7 +439,7 @@ mod test {
let (p, c) = SharedChan::new(); let (p, c) = SharedChan::new();
for _ in range(0, 10) { for _ in range(0, 10) {
let c = c.clone(); let c = c.clone();
do spawn { spawn(proc() {
for _ in range(0, 4) { task::deschedule() } for _ in range(0, 4) { task::deschedule() }
unsafe { unsafe {
o.doit(|| { o.doit(|| {
@@ -449,7 +449,7 @@ mod test {
assert!(run); assert!(run);
} }
c.send(()); c.send(());
} });
} }
unsafe { unsafe {
@@ -479,11 +479,11 @@ mod test {
static mut lock: Mutex = MUTEX_INIT; static mut lock: Mutex = MUTEX_INIT;
unsafe { unsafe {
lock.lock(); lock.lock();
let t = do Thread::start { let t = Thread::start(proc() {
lock.lock(); lock.lock();
lock.signal(); lock.signal();
lock.unlock(); lock.unlock();
}; });
lock.wait(); lock.wait();
lock.unlock(); lock.unlock();
t.join(); t.join();

8
src/libstd/unstable/sync.rs
View File

@@ -179,12 +179,12 @@ mod tests {
let (port, chan) = Chan::new(); let (port, chan) = Chan::new();
futures.push(port); futures.push(port);
do task::spawn { task::spawn(proc() {
for _ in range(0u, count) { for _ in range(0u, count) {
total.with(|count| **count += 1); total.with(|count| **count += 1);
} }
chan.send(()); chan.send(());
} });
}; };
for f in futures.mut_iter() { f.recv() } for f in futures.mut_iter() { f.recv() }
@@ -200,9 +200,9 @@ mod tests {
// accesses will also fail. // accesses will also fail.
let x = Exclusive::new(1); let x = Exclusive::new(1);
let x2 = x.clone(); let x2 = x.clone();
do task::try || { task::try(proc() {
x2.with(|one| assert_eq!(*one, 2)) x2.with(|one| assert_eq!(*one, 2))
}; });
x.with(|one| assert_eq!(*one, 1)); x.with(|one| assert_eq!(*one, 1));
} }
} }