Removing do keyword from libstd and librustc

27 files changed, 265 insertions, 266 deletions

diff --git a/src/librustc/middle/typeck/check/mod.rs b/src/librustc/middle/typeck/check/mod.rs
index a0b50f65f20..0582528b3e2 100644
--- a/src/librustc/middle/typeck/check/mod.rs
+++ b/src/librustc/middle/typeck/check/mod.rs
@@ -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
diff --git a/src/libstd/comm/mod.rs b/src/libstd/comm/mod.rs
index dbffb6a0fd9..8c56e65c22c 100644
--- a/src/libstd/comm/mod.rs
+++ b/src/libstd/comm/mod.rs
@@ -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(());
diff --git a/src/libstd/comm/select.rs b/src/libstd/comm/select.rs
index 57ea205134a..af435c3fc5f 100644
--- a/src/libstd/comm/select.rs
+++ b/src/libstd/comm/select.rs
@@ -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! (
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);
     })
diff --git a/src/libstd/local_data.rs b/src/libstd/local_data.rs
index 7406fe8ee40..719cf2450c5 100644
--- a/src/libstd/local_data.rs
+++ b/src/libstd/local_data.rs
@@ -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!();
diff --git a/src/libstd/path/posix.rs b/src/libstd/path/posix.rs
index e95bd2d8ca2..8029ec696f8 100644
--- a/src/libstd/path/posix.rs
+++ b/src/libstd/path/posix.rs
@@ -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());
                 }
             )
diff --git a/src/libstd/path/windows.rs b/src/libstd/path/windows.rs
index cc0705ee76f..a07471afc1a 100644
--- a/src/libstd/path/windows.rs
+++ b/src/libstd/path/windows.rs
@@ -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());
                 }
             )
diff --git a/src/libstd/rand/os.rs b/src/libstd/rand/os.rs
index a8fd75c1bee..c359d79d275 100644
--- a/src/libstd/rand/os.rs
+++ b/src/libstd/rand/os.rs
@@ -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
diff --git a/src/libstd/rt/local.rs b/src/libstd/rt/local.rs
index 37596b35015..76a672b79ca 100644
--- a/src/libstd/rt/local.rs
+++ b/src/libstd/rt/local.rs
@@ -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) {
diff --git a/src/libstd/rt/thread.rs b/src/libstd/rt/thread.rs
index d543af1bf9b..83f5ca346a9 100644
--- a/src/libstd/rt/thread.rs
+++ b/src/libstd/rt/thread.rs
@@ -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 () {}) }
 }
diff --git a/src/libstd/run.rs b/src/libstd/run.rs
index f42163791a6..482477b2f0e 100644
--- a/src/libstd/run.rs
+++ b/src/libstd/run.rs
@@ -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();
diff --git a/src/libstd/sync/deque.rs b/src/libstd/sync/deque.rs
index b65feedb2ae..7feff127d69 100644
--- a/src/libstd/sync/deque.rs
+++ b/src/libstd/sync/deque.rs
@@ -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();
diff --git a/src/libstd/sync/mpmc_bounded_queue.rs b/src/libstd/sync/mpmc_bounded_queue.rs
index 18be85152d7..bb0e96f96de 100644
--- a/src/libstd/sync/mpmc_bounded_queue.rs
+++ b/src/libstd/sync/mpmc_bounded_queue.rs
@@ -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() {
diff --git a/src/libstd/sync/mpsc_queue.rs b/src/libstd/sync/mpsc_queue.rs
index a249d6ed2e8..1ec8ac5d83e 100644
--- a/src/libstd/sync/mpsc_queue.rs
+++ b/src/libstd/sync/mpsc_queue.rs
@@ -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;
diff --git a/src/libstd/sync/spsc_queue.rs b/src/libstd/sync/spsc_queue.rs
index b4b327cc9d1..35a5846f11a 100644
--- a/src/libstd/sync/spsc_queue.rs
+++ b/src/libstd/sync/spsc_queue.rs
@@ -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);
             }
diff --git a/src/libstd/task.rs b/src/libstd/task.rs
index 8ed4b70c0a2..c8b69083086 100644
--- a/src/libstd/task.rs
+++ b/src/libstd/task.rs
@@ -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!()
     }
diff --git a/src/libstd/unstable/mod.rs b/src/libstd/unstable/mod.rs
index f4573785996..87870ef0331 100644
--- a/src/libstd/unstable/mod.rs
+++ b/src/libstd/unstable/mod.rs
@@ -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.
diff --git a/src/libstd/unstable/mutex.rs b/src/libstd/unstable/mutex.rs
index ba965f2b5c5..39f0d7b5638 100644
--- a/src/libstd/unstable/mutex.rs
+++ b/src/libstd/unstable/mutex.rs
@@ -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();
diff --git a/src/libstd/unstable/sync.rs b/src/libstd/unstable/sync.rs
index 687efea939b..3b2c86c3712 100644
--- a/src/libstd/unstable/sync.rs
+++ b/src/libstd/unstable/sync.rs
@@ -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));
         }
     }