diff --git a/src/librustuv/async.rs b/src/librustuv/async.rs
index 5085dd64b675..5dc50beb8506 100644
--- a/src/librustuv/async.rs
+++ b/src/librustuv/async.rs
@@ -152,10 +152,10 @@ mod test_remote {
         let watcher = AsyncWatcher::new(&mut local_loop().loop_,
                                         cb as ~Callback);
 
-        let thread = do Thread::start {
+        let thread = Thread::start(proc() {
             let mut watcher = watcher;
             watcher.fire();
-        };
+        });
 
         assert_eq!(port.recv(), 1);
         thread.join();
diff --git a/src/librustuv/homing.rs b/src/librustuv/homing.rs
index d6061088469d..8d3e71312cd9 100644
--- a/src/librustuv/homing.rs
+++ b/src/librustuv/homing.rs
@@ -170,14 +170,14 @@ mod test {
             event_loop_factory: None,
         });
 
-        do pool.spawn(TaskOpts::new()) {
+        pool.spawn(TaskOpts::new(), proc() {
             let listener = UdpWatcher::bind(local_loop(), next_test_ip4());
             chan.send(listener.unwrap());
-        }
+        });
 
-        let task = do pool.task(TaskOpts::new()) {
+        let task = pool.task(TaskOpts::new(), proc() {
             port.recv();
-        };
+        });
         pool.spawn_sched().send(sched::TaskFromFriend(task));
 
         pool.shutdown();
@@ -191,20 +191,20 @@ mod test {
             event_loop_factory: None,
         });
 
-        do pool.spawn(TaskOpts::new()) {
+        pool.spawn(TaskOpts::new(), proc() {
             let addr1 = next_test_ip4();
             let addr2 = next_test_ip4();
             let listener = UdpWatcher::bind(local_loop(), addr2);
             chan.send((listener.unwrap(), addr1));
             let mut listener = UdpWatcher::bind(local_loop(), addr1).unwrap();
             listener.sendto([1, 2, 3, 4], addr2);
-        }
+        });
 
-        let task = do pool.task(TaskOpts::new()) {
+        let task = pool.task(TaskOpts::new(), proc() {
             let (mut watcher, addr) = port.recv();
             let mut buf = [0, ..10];
             assert_eq!(watcher.recvfrom(buf).unwrap(), (4, addr));
-        };
+        });
         pool.spawn_sched().send(sched::TaskFromFriend(task));
 
         pool.shutdown();
diff --git a/src/librustuv/lib.rs b/src/librustuv/lib.rs
index 1817be8a5940..0b889e17a445 100644
--- a/src/librustuv/lib.rs
+++ b/src/librustuv/lib.rs
@@ -433,10 +433,10 @@ mod test {
 
     #[test]
     fn loop_smoke_test() {
-        do run_in_bare_thread {
+        run_in_bare_thread(proc() {
             let mut loop_ = Loop::new();
             loop_.run();
             loop_.close();
-        }
+        });
     }
 }
diff --git a/src/librustuv/net.rs b/src/librustuv/net.rs
index 012ab9ed1226..8919ecfa97ef 100644
--- a/src/librustuv/net.rs
+++ b/src/librustuv/net.rs
@@ -692,7 +692,7 @@ mod test {
         let (port, chan) = Chan::new();
         let addr = next_test_ip4();
 
-        do spawn {
+        spawn(proc() {
             let w = match TcpListener::bind(local_loop(), addr) {
                 Ok(w) => w, Err(e) => fail!("{:?}", e)
             };
@@ -712,7 +712,7 @@ mod test {
                 }
                 Err(e) => fail!("{:?}", e)
             }
-        }
+        });
 
         port.recv();
         let mut w = match TcpWatcher::connect(local_loop(), addr) {
@@ -728,7 +728,7 @@ mod test {
         let (port, chan) = Chan::new();
         let addr = next_test_ip6();
 
-        do spawn {
+        spawn(proc() {
             let w = match TcpListener::bind(local_loop(), addr) {
                 Ok(w) => w, Err(e) => fail!("{:?}", e)
             };
@@ -748,7 +748,7 @@ mod test {
                 }
                 Err(e) => fail!("{:?}", e)
             }
-        }
+        });
 
         port.recv();
         let mut w = match TcpWatcher::connect(local_loop(), addr) {
@@ -765,7 +765,7 @@ mod test {
         let client = next_test_ip4();
         let server = next_test_ip4();
 
-        do spawn {
+        spawn(proc() {
             match UdpWatcher::bind(local_loop(), server) {
                 Ok(mut w) => {
                     chan.send(());
@@ -780,7 +780,7 @@ mod test {
                 }
                 Err(e) => fail!("{:?}", e)
             }
-        }
+        });
 
         port.recv();
         let mut w = match UdpWatcher::bind(local_loop(), client) {
@@ -797,7 +797,7 @@ mod test {
         let client = next_test_ip6();
         let server = next_test_ip6();
 
-        do spawn {
+        spawn(proc() {
             match UdpWatcher::bind(local_loop(), server) {
                 Ok(mut w) => {
                     chan.send(());
@@ -812,7 +812,7 @@ mod test {
                 }
                 Err(e) => fail!("{:?}", e)
             }
-        }
+        });
 
         port.recv();
         let mut w = match UdpWatcher::bind(local_loop(), client) {
@@ -829,7 +829,7 @@ mod test {
         static MAX: uint = 5000;
         let (port, chan) = Chan::new();
 
-        do spawn {
+        spawn(proc() {
             let listener = TcpListener::bind(local_loop(), addr).unwrap();
             let mut acceptor = listener.listen().unwrap();
             chan.send(());
@@ -841,7 +841,7 @@ mod test {
                 uvdebug!("wrote bytes");
                 total_bytes_written += buf.len();
             }
-        }
+        });
 
         port.recv();
         let mut stream = TcpWatcher::connect(local_loop(), addr).unwrap();
@@ -864,12 +864,12 @@ mod test {
         let client_addr = next_test_ip4();
         let (port, chan) = Chan::new();
 
-        do spawn {
+        spawn(proc() {
             let mut client = UdpWatcher::bind(local_loop(), client_addr).unwrap();
             port.recv();
             assert!(client.sendto([1], server_addr).is_ok());
             assert!(client.sendto([2], server_addr).is_ok());
-        }
+        });
 
         let mut server = UdpWatcher::bind(local_loop(), server_addr).unwrap();
         chan.send(());
@@ -896,7 +896,7 @@ mod test {
         let (p1, c1) = Chan::new();
         let (p2, c2) = Chan::new();
 
-        do spawn {
+        spawn(proc() {
             let l = local_loop();
             let mut server_out = UdpWatcher::bind(l, server_out_addr).unwrap();
             let mut server_in = UdpWatcher::bind(l, server_in_addr).unwrap();
@@ -918,7 +918,7 @@ mod test {
                 assert_eq!(src, client_out_addr);
             }
             assert!(total_bytes_sent >= MAX);
-        }
+        });
 
         let l = local_loop();
         let mut client_out = UdpWatcher::bind(l, client_out_addr).unwrap();
@@ -950,7 +950,7 @@ mod test {
         let addr = next_test_ip4();
         let (port, chan) = Chan::<Port<()>>::new();
 
-        do spawn {
+        spawn(proc() {
             let port2 = port.recv();
             let mut stream = TcpWatcher::connect(local_loop(), addr).unwrap();
             stream.write([0, 1, 2, 3, 4, 5, 6, 7]);
@@ -959,7 +959,7 @@ mod test {
             stream.write([0, 1, 2, 3, 4, 5, 6, 7]);
             stream.write([0, 1, 2, 3, 4, 5, 6, 7]);
             port2.recv();
-        }
+        });
 
         let listener = TcpListener::bind(local_loop(), addr).unwrap();
         let mut acceptor = listener.listen().unwrap();
@@ -992,7 +992,7 @@ mod test {
     fn test_simple_tcp_server_and_client_on_diff_threads() {
         let addr = next_test_ip4();
 
-        do spawn {
+        spawn(proc() {
             let listener = TcpListener::bind(local_loop(), addr).unwrap();
             let mut acceptor = listener.listen().unwrap();
             let mut stream = acceptor.accept().unwrap();
@@ -1002,7 +1002,7 @@ mod test {
             for i in range(0u, nread) {
                 assert_eq!(buf[i], i as u8);
             }
-        }
+        });
 
         let mut stream = TcpWatcher::connect(local_loop(), addr);
         while stream.is_err() {
@@ -1024,12 +1024,12 @@ mod test {
         let (port, chan) = Chan::new();
         let addr = next_test_ip4();
 
-        do spawn {
+        spawn(proc() {
             let w = TcpListener::bind(local_loop(), addr).unwrap();
             let mut w = w.listen().unwrap();
             chan.send(());
             w.accept();
-        }
+        });
         port.recv();
         let _w = TcpWatcher::connect(local_loop(), addr).unwrap();
         fail!();
@@ -1050,10 +1050,10 @@ mod test {
         // force the handle to be created on a different scheduler, failure in
         // the original task will force a homing operation back to this
         // scheduler.
-        do spawn {
+        spawn(proc() {
             let w = UdpWatcher::bind(local_loop(), addr).unwrap();
             chan.send(w);
-        }
+        });
 
         let _w = port.recv();
         fail!();
diff --git a/src/librustuv/pipe.rs b/src/librustuv/pipe.rs
index 36a7a6319432..cfe86d739abc 100644
--- a/src/librustuv/pipe.rs
+++ b/src/librustuv/pipe.rs
@@ -278,7 +278,7 @@ mod tests {
         let path2 = path.clone();
         let (port, chan) = Chan::new();
 
-        do spawn {
+        spawn(proc() {
             let p = PipeListener::bind(local_loop(), &path2.to_c_str()).unwrap();
             let mut p = p.listen().unwrap();
             chan.send(());
@@ -287,7 +287,7 @@ mod tests {
             assert!(client.read(buf).unwrap() == 1);
             assert_eq!(buf[0], 1);
             assert!(client.write([2]).is_ok());
-        }
+        });
         port.recv();
         let mut c = PipeWatcher::connect(local_loop(), &path.to_c_str()).unwrap();
         assert!(c.write([1]).is_ok());
@@ -302,12 +302,12 @@ mod tests {
         let path2 = path.clone();
         let (port, chan) = Chan::new();
 
-        do spawn {
+        spawn(proc() {
             let p = PipeListener::bind(local_loop(), &path2.to_c_str()).unwrap();
             let mut p = p.listen().unwrap();
             chan.send(());
             p.accept();
-        }
+        });
         port.recv();
         let _c = PipeWatcher::connect(local_loop(), &path.to_c_str()).unwrap();
         fail!()
diff --git a/src/librustuv/signal.rs b/src/librustuv/signal.rs
index 6772c6d19361..8cb0c1f0a52d 100644
--- a/src/librustuv/signal.rs
+++ b/src/librustuv/signal.rs
@@ -85,9 +85,9 @@ mod test {
         let _signal = SignalWatcher::new(local_loop(), signal::Interrupt,
                                          chan);
 
-        do spawn {
+        spawn(proc() {
             port.try_recv();
-        }
+        });
 
         // when we drop the SignalWatcher we're going to destroy the channel,
         // which must wake up the task on the other end
diff --git a/src/librustuv/timer.rs b/src/librustuv/timer.rs
index 4a0ad44d3114..aeda1a45175e 100644
--- a/src/librustuv/timer.rs
+++ b/src/librustuv/timer.rs
@@ -245,9 +245,9 @@ mod test {
         let mut timer = TimerWatcher::new(local_loop());
         let timer_port = timer.period(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
@@ -259,9 +259,9 @@ mod test {
         let mut timer = TimerWatcher::new(local_loop());
         let timer_port = timer.period(1000);
 
-        do spawn {
+        spawn(proc() {
             timer_port.recv_opt();
-        }
+        });
 
         timer.oneshot(1);
     }
@@ -271,9 +271,9 @@ mod test {
         let mut timer = TimerWatcher::new(local_loop());
         let timer_port = timer.period(1000);
 
-        do spawn {
+        spawn(proc() {
             timer_port.recv_opt();
-        }
+        });
 
         timer.sleep(1);
     }
diff --git a/src/librustuv/uvio.rs b/src/librustuv/uvio.rs
index dbf129d0b699..e0bff059b0c9 100644
--- a/src/librustuv/uvio.rs
+++ b/src/librustuv/uvio.rs
@@ -111,16 +111,16 @@ pub fn new_loop() -> ~rtio::EventLoop {
 #[test]
 fn test_callback_run_once() {
     use std::rt::rtio::EventLoop;
-    do run_in_bare_thread {
+    run_in_bare_thread(proc() {
         let mut event_loop = UvEventLoop::new();
         let mut count = 0;
         let count_ptr: *mut int = &mut count;
-        do event_loop.callback {
+        event_loop.callback(proc() {
             unsafe { *count_ptr += 1 }
-        }
+        });
         event_loop.run();
         assert_eq!(count, 1);
-    }
+    });
 }
 
 pub struct UvIoFactory {