OpenE2K
/
rust
2
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Removing do keyword from libstd and librustc

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
Show Stats 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:
///
/// fn foo() {
/// do bar() { ... }
/// bar(proc() { ... })
/// }
///
/// Here, the function `foo()` and the closure passed to

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

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

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

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

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

@ -120,13 +120,13 @@ mod test {
#[test]
fn test_port_reader() {
let (port, chan) = Chan::new();
do task::spawn {
task::spawn(proc() {
chan.send(~[1u8, 2u8]);
chan.send(~[]);
chan.send(~[3u8, 4u8]);
chan.send(~[5u8, 6u8]);
chan.send(~[7u8, 8u8]);
}
});
let mut reader = PortReader::new(port);
let mut buf = ~[0u8, ..3];
@ -172,7 +172,7 @@ mod test {
writer.write_be_u32(42);
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);
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 (port, chan) = Chan::new();
do spawn {
spawn(proc() {
port.recv();
let mut stream = TcpStream::connect(addr);
stream.write([99]);
}
});
let mut acceptor = TcpListener::bind(addr).listen();
chan.send(());
@ -185,11 +185,11 @@ mod test {
let addr = next_test_ip6();
let (port, chan) = Chan::new();
do spawn {
spawn(proc() {
port.recv();
let mut stream = TcpStream::connect(addr);
stream.write([99]);
}
});
let mut acceptor = TcpListener::bind(addr).listen();
chan.send(());
@ -203,11 +203,11 @@ mod test {
let addr = next_test_ip4();
let (port, chan) = Chan::new();
do spawn {
spawn(proc() {
port.recv();
let _stream = TcpStream::connect(addr);
// Close
}
});
let mut acceptor = TcpListener::bind(addr).listen();
chan.send(());
@ -221,11 +221,11 @@ mod test {
let addr = next_test_ip6();
let (port, chan) = Chan::new();
do spawn {
spawn(proc() {
port.recv();
let _stream = TcpStream::connect(addr);
// Close
}
});
let mut acceptor = TcpListener::bind(addr).listen();
chan.send(());
@ -239,11 +239,11 @@ mod test {
let addr = next_test_ip4();
let (port, chan) = Chan::new();
do spawn {
spawn(proc() {
port.recv();
let _stream = TcpStream::connect(addr);
// Close
}
});
let mut acceptor = TcpListener::bind(addr).listen();
chan.send(());
@ -267,11 +267,11 @@ mod test {
let addr = next_test_ip6();
let (port, chan) = Chan::new();
do spawn {
spawn(proc() {
port.recv();
let _stream = TcpStream::connect(addr);
// Close
}
});
let mut acceptor = TcpListener::bind(addr).listen();
chan.send(());
@ -295,11 +295,11 @@ mod test {
let addr = next_test_ip4();
let (port, chan) = Chan::new();
do spawn {
spawn(proc() {
port.recv();
let _stream = TcpStream::connect(addr);
// Close
}
});
let mut acceptor = TcpListener::bind(addr).listen();
chan.send(());
@ -326,11 +326,11 @@ mod test {
let addr = next_test_ip6();
let (port, chan) = Chan::new();
do spawn {
spawn(proc() {
port.recv();
let _stream = TcpStream::connect(addr);
// Close
}
});
let mut acceptor = TcpListener::bind(addr).listen();
chan.send(());
@ -358,13 +358,13 @@ mod test {
let max = 10;
let (port, chan) = Chan::new();
do spawn {
spawn(proc() {
port.recv();
max.times(|| {
let mut stream = TcpStream::connect(addr);
stream.write([99]);
});
}
});
let mut acceptor = TcpListener::bind(addr).listen();
chan.send(());
@ -380,13 +380,13 @@ mod test {
let max = 10;
let (port, chan) = Chan::new();
do spawn {
spawn(proc() {
port.recv();
max.times(|| {
let mut stream = TcpStream::connect(addr);
stream.write([99]);
});
}
});
let mut acceptor = TcpListener::bind(addr).listen();
chan.send(());
@ -402,20 +402,20 @@ mod test {
static MAX: int = 10;
let (port, chan) = Chan::new();
do spawn {
spawn(proc() {
let mut acceptor = TcpListener::bind(addr).listen();
chan.send(());
for (i, stream) in acceptor.incoming().enumerate().take(MAX as uint) {
// Start another task to handle the connection
do spawn {
spawn(proc() {
let mut stream = stream;
let mut buf = [0];
stream.read(buf);
assert!(buf[0] == i as u8);
debug!("read");
}
});
}
}
});
port.recv();
connect(0, addr);
@ -423,14 +423,14 @@ mod test {
fn connect(i: int, addr: SocketAddr) {
if i == MAX { return }
do spawn {
spawn(proc() {
debug!("connecting");
let mut stream = TcpStream::connect(addr);
// Connect again before writing
connect(i + 1, addr);
debug!("writing");
stream.write([i as u8]);
}
});
}
})
@ -439,20 +439,20 @@ mod test {
static MAX: int = 10;
let (port, chan) = Chan::<()>::new();
do spawn {
spawn(proc() {
let mut acceptor = TcpListener::bind(addr).listen();
chan.send(());
for (i, stream) in acceptor.incoming().enumerate().take(MAX as uint) {
// Start another task to handle the connection
do spawn {
spawn(proc() {
let mut stream = stream;
let mut buf = [0];
stream.read(buf);
assert!(buf[0] == i as u8);
debug!("read");
}
});
}
}
});
port.recv();
connect(0, addr);
@ -460,14 +460,14 @@ mod test {
fn connect(i: int, addr: SocketAddr) {
if i == MAX { return }
do spawn {
spawn(proc() {
debug!("connecting");
let mut stream = TcpStream::connect(addr);
// Connect again before writing
connect(i + 1, addr);
debug!("writing");
stream.write([i as u8]);
}
});
}
})
@ -476,20 +476,20 @@ mod test {
static MAX: int = 10;
let (port, chan) = Chan::new();
do spawn {
spawn(proc() {
let mut acceptor = TcpListener::bind(addr).listen();
chan.send(());
for stream in acceptor.incoming().take(MAX as uint) {
// Start another task to handle the connection
do spawn {
spawn(proc() {
let mut stream = stream;
let mut buf = [0];
stream.read(buf);
assert!(buf[0] == 99);
debug!("read");
}
});
}
}
});
port.recv();
connect(0, addr);
@ -497,14 +497,14 @@ mod test {
fn connect(i: int, addr: SocketAddr) {
if i == MAX { return }
do spawn {
spawn(proc() {
debug!("connecting");
let mut stream = TcpStream::connect(addr);
// Connect again before writing
connect(i + 1, addr);
debug!("writing");
stream.write([99]);
}
});
}
})
@ -513,20 +513,20 @@ mod test {
static MAX: int = 10;
let (port, chan) = Chan::new();
do spawn {
spawn(proc() {
let mut acceptor = TcpListener::bind(addr).listen();
chan.send(());
for stream in acceptor.incoming().take(MAX as uint) {
// Start another task to handle the connection
do spawn {
spawn(proc() {
let mut stream = stream;
let mut buf = [0];
stream.read(buf);
assert!(buf[0] == 99);
debug!("read");
}
});
}
}
});
port.recv();
connect(0, addr);
@ -534,14 +534,14 @@ mod test {
fn connect(i: int, addr: SocketAddr) {
if i == MAX { return }
do spawn {
spawn(proc() {
debug!("connecting");
let mut stream = TcpStream::connect(addr);
// Connect again before writing
connect(i + 1, addr);
debug!("writing");
stream.write([99]);
}
});
}
})
@ -558,11 +558,11 @@ mod test {
pub fn peer_name(addr: SocketAddr) {
let (port, chan) = Chan::new();
do spawn {
spawn(proc() {
let mut acceptor = TcpListener::bind(addr).listen();
chan.send(());
acceptor.accept();
}
});
port.recv();
let stream = TcpStream::connect(addr);
@ -592,7 +592,7 @@ mod test {
iotest!(fn partial_read() {
let addr = next_test_ip4();
let (p, c) = Chan::new();
do spawn {
spawn(proc() {
let mut srv = TcpListener::bind(addr).listen();
c.send(());
let mut cl = srv.accept().unwrap();
@ -600,7 +600,7 @@ mod test {
let mut b = [0];
cl.read(b);
c.send(());
}
});
p.recv();
let mut c = TcpStream::connect(addr).unwrap();
@ -630,12 +630,12 @@ mod test {
let addr = next_test_ip4();
let (port, chan) = Chan::new();
do spawn {
spawn(proc() {
port.recv();
let stream = TcpStream::connect(addr);
// Close
port.recv();
}
});
{
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 (port2, chan2) = Chan::new();
do spawn {
spawn(proc() {
match UdpSocket::bind(client_ip) {
Some(ref mut client) => {
port.recv();
@ -128,7 +128,7 @@ mod test {
None => fail!()
}
chan2.send(());
}
});
match UdpSocket::bind(server_ip) {
Some(ref mut server) => {
@ -153,7 +153,7 @@ mod test {
let client_ip = next_test_ip6();
let (port, chan) = Chan::<()>::new();
do spawn {
spawn(proc() {
match UdpSocket::bind(client_ip) {
Some(ref mut client) => {
port.recv();
@ -161,7 +161,7 @@ mod test {
}
None => fail!()
}
}
});
match UdpSocket::bind(server_ip) {
Some(ref mut server) => {
@ -186,7 +186,7 @@ mod test {
let (port, chan) = Chan::new();
let (port2, chan2) = Chan::new();
do spawn {
spawn(proc() {
match UdpSocket::bind(client_ip) {
Some(client) => {
let client = ~client;
@ -197,7 +197,7 @@ mod test {
None => fail!()
}
chan2.send(());
}
});
match UdpSocket::bind(server_ip) {
Some(server) => {
@ -224,7 +224,7 @@ mod test {
let (port, chan) = Chan::new();
let (port2, chan2) = Chan::new();
do spawn {
spawn(proc() {
match UdpSocket::bind(client_ip) {
Some(client) => {
let client = ~client;
@ -235,7 +235,7 @@ mod test {
None => fail!()
}
chan2.send(());
}
});
match UdpSocket::bind(server_ip) {
Some(server) => {

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

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

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

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

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

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

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

@ -372,10 +372,10 @@ mod tests {
let (p, c) = Chan::new();
let (mut r, w) = (PortReader::new(p), ChanWriter::new(c));
do spawn {
spawn(proc() {
set_stdout(~w as ~Writer);
println!("hello!");
}
});
assert_eq!(r.read_to_str(), ~"hello!\n");
})
@ -384,10 +384,10 @@ mod tests {
let (p, c) = Chan::new();
let (mut r, w) = (PortReader::new(p), ChanWriter::new(c));
do spawn {
spawn(proc() {
set_stderr(~w as ~Writer);
fail!("my special message");
}
});
let s = r.read_to_str();
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() {
use native;
let (p, c) = Chan::new();
do native::task::spawn { c.send(f()) }
native::task::spawn(proc() { c.send(f()) });
p.recv();
}
}

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

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

20
src/libstd/local_data.rs
View File

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

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

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

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

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

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

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

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

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

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

@ -255,11 +255,11 @@ mod tests {
use super::Thread;
#[test]
fn smoke() { do Thread::start {}.join(); }
fn smoke() { Thread::start(proc (){}).join(); }
#[test]
fn data() { assert_eq!(do Thread::start { 1 }.join(), 1); }
fn data() { assert_eq!(Thread::start(proc () { 1 }).join(), 1); }
#[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 ch_clone = ch.clone();
do spawn {
spawn(proc() {
let _guard = io::ignore_io_error();
let mut error = error;
match error {
Some(ref mut e) => ch.send((2, e.read_to_end())),
None => ch.send((2, ~[]))
}
}
do spawn {
});
spawn(proc() {
let _guard = io::ignore_io_error();
let mut output = output;
match output {
Some(ref mut e) => ch_clone.send((1, e.read_to_end())),
None => ch_clone.send((1, ~[]))
}
}
});
let status = self.finish();
@ -414,9 +414,9 @@ mod tests {
os::close(pipe_out.out as int);
os::close(pipe_err.out as int);
do spawn {
spawn(proc() {
writeclose(pipe_in.out, "test");
}
});
let actual = readclose(pipe_out.input);
readclose(pipe_err.input);
process.finish();

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

@ -425,7 +425,7 @@ mod tests {
static AMT: int = 100000;
let mut pool = BufferPool::<int>::new();
let (mut w, s) = pool.deque();
let t = do Thread::start {
let t = Thread::start(proc() {
let mut s = s;
let mut left = AMT;
while left > 0 {
@ -437,7 +437,7 @@ mod tests {
Abort | Empty => {}
}
}
};
});
for _ in range(0, AMT) {
w.push(1);
@ -451,7 +451,7 @@ mod tests {
static AMT: int = 100000;
let mut pool = BufferPool::<(int, int)>::new();
let (mut w, s) = pool.deque();
let t = do Thread::start {
let t = Thread::start(proc() {
let mut s = s;
let mut left = AMT;
while left > 0 {
@ -461,7 +461,7 @@ mod tests {
Abort | Empty => {}
}
}
};
});
for _ in range(0, AMT) {
w.push((1, 10));
@ -480,7 +480,7 @@ mod tests {
let threads = range(0, nthreads).map(|_| {
let s = s.clone();
do Thread::start {
Thread::start(proc() {
unsafe {
let mut s = s;
while (*unsafe_remaining).load(SeqCst) > 0 {
@ -493,7 +493,7 @@ mod tests {
}
}
}
}
})
}).to_owned_vec();
while remaining.load(SeqCst) > 0 {
@ -522,9 +522,9 @@ mod tests {
let mut pool = BufferPool::<~int>::new();
let threads = range(0, AMT).map(|_| {
let (w, s) = pool.deque();
do Thread::start {
Thread::start(proc() {
stampede(w, s, 4, 10000);
}
})
}).to_owned_vec();
for thread in threads.move_iter() {
@ -543,7 +543,7 @@ mod tests {
let threads = range(0, NTHREADS).map(|_| {
let s = s.clone();
do Thread::start {
Thread::start(proc() {
unsafe {
let mut s = s;
loop {
@ -555,7 +555,7 @@ mod tests {
}
}
}
}
})
}).to_owned_vec();
let mut rng = rand::task_rng();
@ -606,7 +606,7 @@ mod tests {
let thread_box = unsafe {
*cast::transmute::<&~AtomicUint,**mut AtomicUint>(&unique_box)
};
(do Thread::start {
(Thread::start(proc() {
unsafe {
let mut s = s;
loop {
@ -620,7 +620,7 @@ mod tests {
}
}
}
}, unique_box)
}), unique_box)
}));
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) {
let q = q.clone();
let chan = chan.clone();
do native::task::spawn {
native::task::spawn(proc() {
let mut q = q;
for i in range(0, nmsgs) {
assert!(q.push(i));
}
chan.send(());
}
});
}
let mut completion_ports = ~[];
@ -191,7 +191,7 @@ mod tests {
let (completion_port, completion_chan) = Chan::new();
completion_ports.push(completion_port);
let q = q.clone();
do native::task::spawn {
native::task::spawn(proc() {
let mut q = q;
let mut i = 0u;
loop {
@ -204,7 +204,7 @@ mod tests {
}
}
completion_chan.send(i);
}
});
}
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) {
let q = p.clone();
let chan = chan.clone();
do native::task::spawn {
native::task::spawn(proc() {
let mut q = q;
for i in range(0, nmsgs) {
q.push(i);
}
chan.send(());
}
});
}
let mut i = 0u;

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

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

88
src/libstd/task.rs
View File

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

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

@ -41,18 +41,18 @@ pub fn run_in_bare_thread(f: proc()) {
#[test]
fn test_run_in_bare_thread() {
let i = 100;
do run_in_bare_thread {
run_in_bare_thread(proc() {
assert_eq!(i, 100);
}
});
}
#[test]
fn test_run_in_bare_thread_exchange() {
// Does the exchange heap work without the runtime?
let i = ~100;
do run_in_bare_thread {
run_in_bare_thread(proc() {
assert!(i == ~100);
}
});
}
/// 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();
for _ in range(0, 10) {
let c = c.clone();
do spawn {
spawn(proc() {
for _ in range(0, 4) { task::deschedule() }
unsafe {
o.doit(|| {
@ -449,7 +449,7 @@ mod test {
assert!(run);
}
c.send(());
}
});
}
unsafe {
@ -479,11 +479,11 @@ mod test {
static mut lock: Mutex = MUTEX_INIT;
unsafe {
lock.lock();
let t = do Thread::start {
let t = Thread::start(proc() {
lock.lock();
lock.signal();
lock.unlock();
};
});
lock.wait();
lock.unlock();
t.join();

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

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