Removing do keyword from libstd and librustc

9 files changed, 80 insertions, 80 deletions

diff --git a/src/libstd/io/comm_adapters.rs b/src/libstd/io/comm_adapters.rs
index e15b9a861ca..0acfa71e315 100644
--- a/src/libstd/io/comm_adapters.rs
+++ b/src/libstd/io/comm_adapters.rs
@@ -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;
diff --git a/src/libstd/io/net/tcp.rs b/src/libstd/io/net/tcp.rs
index 92efc4e9306..2d074df4919 100644
--- a/src/libstd/io/net/tcp.rs
+++ b/src/libstd/io/net/tcp.rs
@@ -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();
diff --git a/src/libstd/io/net/udp.rs b/src/libstd/io/net/udp.rs
index 952ca7f730e..1cf30d469f7 100644
--- a/src/libstd/io/net/udp.rs
+++ b/src/libstd/io/net/udp.rs
@@ -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) => {
diff --git a/src/libstd/io/net/unix.rs b/src/libstd/io/net/unix.rs
index 232ca670597..dcf6d2ad203 100644
--- a/src/libstd/io/net/unix.rs
+++ b/src/libstd/io/net/unix.rs
@@ -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(());
diff --git a/src/libstd/io/pipe.rs b/src/libstd/io/pipe.rs
index 799adff37e3..9919d333f41 100644
--- a/src/libstd/io/pipe.rs
+++ b/src/libstd/io/pipe.rs
@@ -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);
diff --git a/src/libstd/io/signal.rs b/src/libstd/io/signal.rs
index 0f05254b034..5575e289b59 100644
--- a/src/libstd/io/signal.rs
+++ b/src/libstd/io/signal.rs
@@ -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 {
diff --git a/src/libstd/io/stdio.rs b/src/libstd/io/stdio.rs
index f3f071ab78b..d9fa2a4fc33 100644
--- a/src/libstd/io/stdio.rs
+++ b/src/libstd/io/stdio.rs
@@ -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"));
     })
diff --git a/src/libstd/io/test.rs b/src/libstd/io/test.rs
index d81de989df7..6ac73e7f61e 100644
--- a/src/libstd/io/test.rs
+++ b/src/libstd/io/test.rs
@@ -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();
             }
         }
diff --git a/src/libstd/io/timer.rs b/src/libstd/io/timer.rs
index 4bf89a1d559..24eaf6adf3f 100644
--- a/src/libstd/io/timer.rs
+++ b/src/libstd/io/timer.rs
@@ -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);
     })