diff --git a/doc/guide-conditions.md b/doc/guide-conditions.md
index d4cc3d8ffbe9a..d97de7799024c 100644
--- a/doc/guide-conditions.md
+++ b/doc/guide-conditions.md
@@ -261,7 +261,7 @@ use std::task;
 fn main() {
 
     // Isolate failure within a subtask.
-    let result = do task::try {
+    let result = task::try(proc() {
 
         // The protected logic.
         let pairs = read_int_pairs();
@@ -269,7 +269,7 @@ fn main() {
             println!("{:4.4d}, {:4.4d}", a, b);
         }
 
-    };
+    });
     if result.is_err() {
             println!("parsing failed");
     }
diff --git a/doc/guide-pointers.md b/doc/guide-pointers.md
index 3365fd479ca8e..19696b42a3747 100644
--- a/doc/guide-pointers.md
+++ b/doc/guide-pointers.md
@@ -221,9 +221,9 @@ struct Point {
 
 fn main() {
     let a = Point { x: 10, y: 20 };
-    do spawn {
+    spawn(proc() {
         println!("{}", a.x);
-    }
+    });
 }
 ~~~
 
@@ -238,9 +238,9 @@ struct Point {
 
 fn main() {
     let a = ~Point { x: 10, y: 20 };
-    do spawn {
+    spawn(proc() {
         println!("{}", a.x);
-    }
+    });
 }
 ~~~
 
diff --git a/doc/guide-runtime.md b/doc/guide-runtime.md
index fa5a2b23ca878..b6a54b042e96a 100644
--- a/doc/guide-runtime.md
+++ b/doc/guide-runtime.md
@@ -236,9 +236,9 @@ extern mod green;
 
 #[start]
 fn start(argc: int, argv: **u8) -> int {
-    do green::start(argc, argv) {
+    green::start(argc, argv, proc() {
         main();
-    }
+    })
 }
 
 fn main() {}
diff --git a/doc/guide-tasks.md b/doc/guide-tasks.md
index d9a80b9385303..c3bdbe3a3ee89 100644
--- a/doc/guide-tasks.md
+++ b/doc/guide-tasks.md
@@ -77,11 +77,6 @@ spawn(print_message);
 
 // Print something more profound in a different task using a lambda expression
 spawn(proc() println!("I am also running in a different task!") );
-
-// The canonical way to spawn is using `do` notation
-do spawn {
-    println!("I too am running in a different task!");
-}
 ~~~~
 
 In Rust, there is nothing special about creating tasks: a task is not a
@@ -103,10 +98,10 @@ an environment that it carries across tasks.
 // Generate some state locally
 let child_task_number = generate_task_number();
 
-do spawn {
+spawn(proc() {
     // Capture it in the remote task
     println!("I am child number {}", child_task_number);
-}
+});
 ~~~
 
 ## Communication
@@ -132,10 +127,10 @@ concurrently:
 
 let (port, chan): (Port<int>, Chan<int>) = Chan::new();
 
-do spawn || {
+spawn(proc() {
     let result = some_expensive_computation();
     chan.send(result);
-}
+});
 
 some_other_expensive_computation();
 let result = port.recv();
@@ -160,10 +155,10 @@ spawns the child task.
 # use std::task::spawn;
 # fn some_expensive_computation() -> int { 42 }
 # let (port, chan) = Chan::new();
-do spawn || {
+spawn(proc() {
     let result = some_expensive_computation();
     chan.send(result);
-}
+});
 ~~~~
 
 Notice that the creation of the task closure transfers `chan` to the child
@@ -195,15 +190,15 @@ of tasks? The following program is ill-typed:
 # fn some_expensive_computation() -> int { 42 }
 let (port, chan) = Chan::new();
 
-do spawn {
+spawn(proc() {
     chan.send(some_expensive_computation());
-}
+});
 
 // ERROR! The previous spawn statement already owns the channel,
 // so the compiler will not allow it to be captured again
-do spawn {
+spawn(proc() {
     chan.send(some_expensive_computation());
-}
+});
 ~~~
 
 Instead we can use a `SharedChan`, a type that allows a single
@@ -217,9 +212,9 @@ let (port, chan) = SharedChan::new();
 for init_val in range(0u, 3) {
     // Create a new channel handle to distribute to the child task
     let child_chan = chan.clone();
-    do spawn {
+    spawn(proc() {
         child_chan.send(some_expensive_computation(init_val));
-    }
+    });
 }
 
 let result = port.recv() + port.recv() + port.recv();
@@ -247,9 +242,9 @@ might look like the example below.
 // Create a vector of ports, one for each child task
 let ports = vec::from_fn(3, |init_val| {
     let (port, chan) = Chan::new();
-    do spawn {
+    spawn(proc() {
         chan.send(some_expensive_computation(init_val));
-    }
+    });
     port
 });
 
@@ -296,7 +291,7 @@ fn partial_sum(start: uint) -> f64 {
 }
 
 fn main() {
-    let mut futures = vec::from_fn(1000, |ind| do extra::future::Future::spawn { partial_sum(ind) });
+    let mut futures = vec::from_fn(1000, |ind| extra::future::Future::spawn( proc() { partial_sum(ind) }));
 
     let mut final_res = 0f64;
     for ft in futures.mut_iter()  {
@@ -339,11 +334,11 @@ fn main() {
         let (port, chan)  = Chan::new();
         chan.send(numbers_arc.clone());
 
-        do spawn {
+        spawn(proc() {
             let local_arc : Arc<~[f64]> = port.recv();
             let task_numbers = local_arc.get();
             println!("{}-norm = {}", num, pnorm(task_numbers, num));
-        }
+        });
     }
 }
 ~~~
@@ -417,13 +412,13 @@ termination with an error).
 # use std::task;
 # fn some_condition() -> bool { false }
 # fn calculate_result() -> int { 0 }
-let result: Result<int, ()> = do task::try {
+let result: Result<int, ()> = task::try(proc() {
     if some_condition() {
         calculate_result()
     } else {
         fail!("oops!");
     }
-};
+});
 assert!(result.is_err());
 ~~~
 
@@ -502,9 +497,9 @@ Here is the code for the parent task:
 
 let (from_child, to_child) = DuplexStream::new();
 
-do spawn {
+spawn(proc() {
     stringifier(&to_child);
-};
+});
 
 from_child.send(22);
 assert!(from_child.recv() == ~"22");
diff --git a/doc/rust.md b/doc/rust.md
index f933cac51f6d2..1dd312febb718 100644
--- a/doc/rust.md
+++ b/doc/rust.md
@@ -2751,52 +2751,6 @@ but must enclose it.
 
 A `loop` expression is only permitted in the body of a loop.
 
-### Do expressions
-
-~~~~ {.ebnf .gram}
-do_expr : "do" expr [ '|' ident_list '|' ] ? '{' block '}' ;
-~~~~
-
-A _do expression_ provides a more-familiar block syntax
-for invoking a function and passing it a newly-created a procedure.
-
-The optional `ident_list` and `block` provided in a `do` expression are parsed
-as though they constitute a procedure expression;
-if the `ident_list` is missing, an empty `ident_list` is implied.
-
-The procedure expression is then provided as a _trailing argument_
-to the outermost [call](#call-expressions) or
-[method call](#method-call-expressions) expression
-in the `expr` following `do`.
-If the `expr` is a [path expression](#path-expressions), it is parsed as though it is a call expression.
-If the `expr` is a [field expression](#field-expressions), it is parsed as though it is a method call expression.
-
-In this example, both calls to `f` are equivalent:
-
-~~~~
-# fn f(f: proc(int)) { }
-# fn g(i: int) { }
-
-f(proc(j) { g(j) });
-
-do f |j| {
-    g(j);
-}
-~~~~
-
-In this example, both calls to the (binary) function `k` are equivalent:
-
-~~~~
-# fn k(x:int, f: proc(int)) { }
-# fn l(i: int) { }
-
-k(3, proc(j) { l(j) });
-
-do k(3) |j| {
-   l(j);
-}
-~~~~
-
 ### For expressions
 
 ~~~~ {.ebnf .gram}
diff --git a/doc/tutorial.md b/doc/tutorial.md
index 6112a713bbfc9..9304badb1c6e6 100644
--- a/doc/tutorial.md
+++ b/doc/tutorial.md
@@ -1796,48 +1796,20 @@ call_it(proc(n) {
 });
 ~~~~
 
-This is such a useful pattern that Rust has a special form of function
-call for these functions.
-
-~~~~
-# fn call_it(op: proc(v: int)) { }
-do call_it() |n| {
-    println!("{}", n);
-}
-~~~~
-
-The call is prefixed with the keyword `do` and, instead of writing the
-final procedure inside the argument list, it appears outside of the
-parentheses, where it looks more like a typical block of
-code.
-
-`do` is a convenient way to create tasks with the `task::spawn`
-function.  `spawn` has the signature `spawn(fn: proc())`. In other
-words, it is a function that takes an owned closure that takes no
-arguments.
-
-~~~~
-use std::task::spawn;
-
-do spawn() || {
-    debug!("I'm a task, whatever");
-}
-~~~~
-
-Look at all those bars and parentheses -- that's two empty argument
-lists back to back. Since that is so unsightly, empty argument lists
-may be omitted from `do` expressions.
+A practical example of this pattern is found when using the `spawn` function,
+which starts a new task.
 
 ~~~~
 use std::task::spawn;
-
-do spawn {
-   debug!("Kablam!");
-}
+spawn(proc() {
+    debug!("I'm a new task")
+});
 ~~~~
 
-If you want to see the output of `debug!` statements, you will need to turn on `debug!` logging.
-To enable `debug!` logging, set the RUST_LOG environment variable to the name of your crate, which, for a file named `foo.rs`, will be `foo` (e.g., with bash, `export RUST_LOG=foo`).
+If you want to see the output of `debug!` statements, you will need to turn on
+`debug!` logging.  To enable `debug!` logging, set the RUST_LOG environment
+variable to the name of your crate, which, for a file named `foo.rs`, will be
+`foo` (e.g., with bash, `export RUST_LOG=foo`).
 
 # Methods
 
diff --git a/src/compiletest/runtest.rs b/src/compiletest/runtest.rs
index 6a940e1d7f202..c57d2492d459c 100644
--- a/src/compiletest/runtest.rs
+++ b/src/compiletest/runtest.rs
@@ -317,10 +317,10 @@ fn run_debuginfo_test(config: &config, props: &TestProps, testfile: &Path) {
             loop {
                 //waiting 1 second for gdbserver start
                 timer::sleep(1000);
-                let result = do task::try {
+                let result = task::try(proc() {
                     tcp::TcpStream::connect(
                         SocketAddr { ip: Ipv4Addr(127, 0, 0, 1), port: 5039 });
-                };
+                });
                 if result.is_err() {
                     continue;
                 }
diff --git a/src/libextra/arc.rs b/src/libextra/arc.rs
index f914fa1ac0936..bf47e3bdf89ea 100644
--- a/src/libextra/arc.rs
+++ b/src/libextra/arc.rs
@@ -28,12 +28,12 @@
  *       let (port, chan) = Chan::new();
  *       chan.send(shared_numbers.clone());
  *
- *       do spawn {
+ *       spawn(proc() {
  *           let shared_numbers = port.recv();
  *           let local_numbers = shared_numbers.get();
  *
  *           // Work with the local numbers
- *       }
+ *       });
  *   }
  * ```
  */
@@ -567,12 +567,12 @@ mod tests {
 
         let (p, c) = Chan::new();
 
-        do task::spawn {
+        task::spawn(proc() {
             let arc_v: Arc<~[int]> = p.recv();
 
             let v = arc_v.get().clone();
             assert_eq!(v[3], 4);
-        };
+        });
 
         c.send(arc_v.clone());
 
@@ -587,14 +587,14 @@ mod tests {
         let arc = ~MutexArc::new(false);
         let arc2 = ~arc.clone();
         let (p,c) = Chan::new();
-        do task::spawn {
+        task::spawn(proc() {
             // wait until parent gets in
             p.recv();
             arc2.access_cond(|state, cond| {
                 *state = true;
                 cond.signal();
             })
-        }
+        });
 
         arc.access_cond(|state, cond| {
             c.send(());
@@ -611,14 +611,14 @@ mod tests {
         let arc2 = ~arc.clone();
         let (p, c) = Chan::new();
 
-        do spawn {
+        spawn(proc() {
             let _ = p.recv();
             arc2.access_cond(|one, cond| {
                 cond.signal();
                 // Parent should fail when it wakes up.
                 assert_eq!(*one, 0);
             })
-        }
+        });
 
         arc.access_cond(|one, cond| {
             c.send(());
@@ -632,11 +632,11 @@ mod tests {
     fn test_mutex_arc_poison() {
         let arc = ~MutexArc::new(1);
         let arc2 = ~arc.clone();
-        do task::try || {
+        task::try(proc() {
             arc2.access(|one| {
                 assert_eq!(*one, 2);
             })
-        };
+        });
         arc.access(|one| {
             assert_eq!(*one, 1);
         })
@@ -649,13 +649,13 @@ mod tests {
             // to underlaying data.
             let arc = ~MutexArc::new(1);
             let arc2 = ~MutexArc::new(*arc);
-            do task::spawn || {
+            task::spawn(proc() {
                 (*arc2).unsafe_access(|mutex| {
                     (*mutex).access(|one| {
                         assert!(*one == 1);
                     })
                 })
-            };
+            });
         }
     }
 
@@ -682,11 +682,11 @@ mod tests {
     fn test_rw_arc_poison_wr() {
         let arc = RWArc::new(1);
         let arc2 = arc.clone();
-        do task::try {
+        task::try(proc() {
             arc2.write(|one| {
                 assert_eq!(*one, 2);
             })
-        };
+        });
         arc.read(|one| {
             assert_eq!(*one, 1);
         })
@@ -696,11 +696,11 @@ mod tests {
     fn test_rw_arc_poison_ww() {
         let arc = RWArc::new(1);
         let arc2 = arc.clone();
-        do task::try {
+        task::try(proc() {
             arc2.write(|one| {
                 assert_eq!(*one, 2);
             })
-        };
+        });
         arc.write(|one| {
             assert_eq!(*one, 1);
         })
@@ -709,13 +709,13 @@ mod tests {
     fn test_rw_arc_poison_dw() {
         let arc = RWArc::new(1);
         let arc2 = arc.clone();
-        do task::try {
+        task::try(proc() {
             arc2.write_downgrade(|mut write_mode| {
                 write_mode.write(|one| {
                     assert_eq!(*one, 2);
                 })
             })
-        };
+        });
         arc.write(|one| {
             assert_eq!(*one, 1);
         })
@@ -724,11 +724,11 @@ mod tests {
     fn test_rw_arc_no_poison_rr() {
         let arc = RWArc::new(1);
         let arc2 = arc.clone();
-        do task::try {
+        task::try(proc() {
             arc2.read(|one| {
                 assert_eq!(*one, 2);
             })
-        };
+        });
         arc.read(|one| {
             assert_eq!(*one, 1);
         })
@@ -737,11 +737,11 @@ mod tests {
     fn test_rw_arc_no_poison_rw() {
         let arc = RWArc::new(1);
         let arc2 = arc.clone();
-        do task::try {
+        task::try(proc() {
             arc2.read(|one| {
                 assert_eq!(*one, 2);
             })
-        };
+        });
         arc.write(|one| {
             assert_eq!(*one, 1);
         })
@@ -750,14 +750,14 @@ mod tests {
     fn test_rw_arc_no_poison_dr() {
         let arc = RWArc::new(1);
         let arc2 = arc.clone();
-        do task::try {
+        task::try(proc() {
             arc2.write_downgrade(|write_mode| {
                 let read_mode = arc2.downgrade(write_mode);
                 read_mode.read(|one| {
                     assert_eq!(*one, 2);
                 })
             })
-        };
+        });
         arc.write(|one| {
             assert_eq!(*one, 1);
         })
@@ -768,7 +768,7 @@ mod tests {
         let arc2 = arc.clone();
         let (p, c) = Chan::new();
 
-        do task::spawn {
+        task::spawn(proc() {
             arc2.write(|num| {
                 10.times(|| {
                     let tmp = *num;
@@ -778,7 +778,7 @@ mod tests {
                 });
                 c.send(());
             })
-        }
+        });
 
         // Readers try to catch the writer in the act
         let mut children = ~[];
@@ -786,11 +786,11 @@ mod tests {
             let arc3 = arc.clone();
             let mut builder = task::task();
             children.push(builder.future_result());
-            do builder.spawn {
+            builder.spawn(proc() {
                 arc3.read(|num| {
                     assert!(*num >= 0);
                 })
-            }
+            });
         });
 
         // Wait for children to pass their asserts
@@ -840,19 +840,19 @@ mod tests {
             let ((rp1, rc1), (rp2, rc2)) = (Chan::new(), Chan::new());
             reader_convos.push((rc1, rp2));
             let arcn = arc.clone();
-            do task::spawn {
+            task::spawn(proc() {
                 rp1.recv(); // wait for downgrader to give go-ahead
                 arcn.read(|state| {
                     assert_eq!(*state, 31337);
                     rc2.send(());
                 })
-            }
+            });
         });
 
         // Writer task
         let arc2 = arc.clone();
         let ((wp1, wc1), (wp2, wc2)) = (Chan::new(), Chan::new());
-        do task::spawn || {
+        task::spawn(proc() {
             wp1.recv();
             arc2.write_cond(|state, cond| {
                 assert_eq!(*state, 0);
@@ -867,7 +867,7 @@ mod tests {
                 *state = 42;
             });
             wc2.send(());
-        }
+        });
 
         // Downgrader (us)
         arc.write_downgrade(|mut write_mode| {
@@ -912,7 +912,7 @@ mod tests {
 
         // writer task
         let xw = x.clone();
-        do task::spawn {
+        task::spawn(proc() {
             xw.write_cond(|state, c| {
                 wc.send(()); // tell downgrader it's ok to go
                 c.wait();
@@ -921,7 +921,7 @@ mod tests {
                 // trying to receive the "reader cloud lock hand-off".
                 *state = false;
             })
-        }
+        });
 
         wp.recv(); // wait for writer to get in
 
@@ -934,10 +934,10 @@ mod tests {
             // make a reader task to trigger the "reader cloud lock" handoff
             let xr = x.clone();
             let (rp, rc) = Chan::new();
-            do task::spawn {
+            task::spawn(proc() {
                 rc.send(());
                 xr.read(|_state| { })
-            }
+            });
             rp.recv(); // wait for reader task to exist
 
             let read_mode = x.downgrade(write_mode);
diff --git a/src/libextra/comm.rs b/src/libextra/comm.rs
index 748289080532c..69a1383e44da4 100644
--- a/src/libextra/comm.rs
+++ b/src/libextra/comm.rs
@@ -115,9 +115,9 @@ mod test {
     pub fn basic_rendezvous_test() {
         let (port, chan) = rendezvous();
 
-        do spawn {
+        spawn(proc() {
             chan.send("abc");
-        }
+        });
 
         assert!(port.recv() == "abc");
     }
@@ -126,29 +126,29 @@ mod test {
     fn recv_a_lot() {
         // Rendezvous streams should be able to handle any number of messages being sent
         let (port, chan) = rendezvous();
-        do spawn {
+        spawn(proc() {
             10000.times(|| { chan.send(()) })
-        }
+        });
         10000.times(|| { port.recv() })
     }
 
     #[test]
     fn send_and_fail_and_try_recv() {
         let (port, chan) = rendezvous();
-        do spawn {
+        spawn(proc() {
             chan.duplex_stream.send(()); // Can't access this field outside this module
             fail!()
-        }
+        });
         port.recv()
     }
 
     #[test]
     fn try_send_and_recv_then_fail_before_ack() {
         let (port, chan) = rendezvous();
-        do spawn {
+        spawn(proc() {
             port.duplex_stream.recv();
             fail!()
-        }
+        });
         chan.try_send(());
     }
 
@@ -156,10 +156,10 @@ mod test {
     #[should_fail]
     fn send_and_recv_then_fail_before_ack() {
         let (port, chan) = rendezvous();
-        do spawn {
+        spawn(proc() {
             port.duplex_stream.recv();
             fail!()
-        }
+        });
         chan.send(());
     }
 }
diff --git a/src/libextra/dlist.rs b/src/libextra/dlist.rs
index 4023a4d7e7fbe..0706d4e5a6874 100644
--- a/src/libextra/dlist.rs
+++ b/src/libextra/dlist.rs
@@ -971,10 +971,10 @@ mod tests {
     #[test]
     fn test_send() {
         let n = list_from([1,2,3]);
-        do spawn {
+        spawn(proc() {
             check_links(&n);
             assert_eq!(~[&1,&2,&3], n.iter().collect::<~[&int]>());
-        }
+        });
     }
 
     #[test]
diff --git a/src/libextra/future.rs b/src/libextra/future.rs
index c6c876aff7935..b9121290f33f4 100644
--- a/src/libextra/future.rs
+++ b/src/libextra/future.rs
@@ -18,7 +18,7 @@
  * use extra::future::Future;
  * # fn fib(n: uint) -> uint {42};
  * # fn make_a_sandwich() {};
- * let mut delayed_fib = do Future::spawn { fib(5000) };
+ * let mut delayed_fib = Future::spawn(proc() { fib(5000) });
  * make_a_sandwich();
  * println!("fib(5000) = {}", delayed_fib.get())
  * ```
@@ -112,9 +112,9 @@ impl<A:Send> Future<A> {
          * waiting for the result to be received on the port.
          */
 
-        do Future::from_fn {
+        Future::from_fn(proc() {
             port.recv()
-        }
+        })
     }
 
     pub fn spawn(blk: proc() -> A) -> Future<A> {
@@ -127,9 +127,9 @@ impl<A:Send> Future<A> {
 
         let (port, chan) = Chan::new();
 
-        do spawn {
+        spawn(proc() {
             chan.send(blk());
-        }
+        });
 
         Future::from_port(port)
     }
@@ -195,11 +195,11 @@ mod test {
     #[test]
     fn test_sendable_future() {
         let expected = "schlorf";
-        let f = do Future::spawn { expected };
-        do task::spawn {
+        let f = Future::spawn(proc() { expected });
+        task::spawn(proc() {
             let mut f = f;
             let actual = f.get();
             assert_eq!(actual, expected);
-        }
+        });
     }
 }
diff --git a/src/libextra/json.rs b/src/libextra/json.rs
index a35c474337d61..d8c1cb51a1181 100644
--- a/src/libextra/json.rs
+++ b/src/libextra/json.rs
@@ -2201,7 +2201,7 @@ mod tests {
     }
     fn check_err<T: Decodable<Decoder>>(to_parse: &'static str, expected_error: &str) {
         use std::task;
-        let res = do task::try {
+        let res = task::try(proc() {
             // either fails in `decode` (which is what we want), or
             // returns Some(error_message)/None if the string was
             // invalid or valid JSON.
@@ -2212,7 +2212,7 @@ mod tests {
                     None
                 }
             }
-        };
+        });
         match res {
             Ok(Some(parse_error)) => fail!("`{}` is not valid json: {}",
                                            to_parse, parse_error),
diff --git a/src/libextra/sync.rs b/src/libextra/sync.rs
index 60929b71e5f11..3acaf83525646 100644
--- a/src/libextra/sync.rs
+++ b/src/libextra/sync.rs
@@ -695,11 +695,11 @@ impl<'a> RWLockReadMode<'a> {
 ///     let c = barrier.clone();
 ///     // The same messages will be printed together.
 ///     // You will NOT see any interleaving.
-///     do spawn {
+///     spawn(proc() {
 ///         println!("before wait");
 ///         c.wait();
 ///         println!("after wait");
-///     }
+///     });
 /// });
 /// ```
 #[deriving(Clone)]
@@ -778,11 +778,11 @@ mod tests {
     fn test_sem_as_mutex() {
         let s = Semaphore::new(1);
         let s2 = s.clone();
-        do task::spawn {
+        task::spawn(proc() {
             s2.access(|| {
                 5.times(|| { task::deschedule(); })
             })
-        }
+        });
         s.access(|| {
             5.times(|| { task::deschedule(); })
         })
@@ -793,10 +793,10 @@ mod tests {
         let (p, c) = Chan::new();
         let s = Semaphore::new(0);
         let s2 = s.clone();
-        do task::spawn {
+        task::spawn(proc() {
             s2.acquire();
             c.send(());
-        }
+        });
         5.times(|| { task::deschedule(); });
         s.release();
         let _ = p.recv();
@@ -805,11 +805,11 @@ mod tests {
         let (p, c) = Chan::new();
         let s = Semaphore::new(0);
         let s2 = s.clone();
-        do task::spawn {
+        task::spawn(proc() {
             5.times(|| { task::deschedule(); });
             s2.release();
             let _ = p.recv();
-        }
+        });
         s.acquire();
         c.send(());
     }
@@ -821,12 +821,12 @@ mod tests {
         let s2 = s.clone();
         let (p1,c1) = Chan::new();
         let (p2,c2) = Chan::new();
-        do task::spawn {
+        task::spawn(proc() {
             s2.access(|| {
                 let _ = p2.recv();
                 c1.send(());
             })
-        }
+        });
         s.access(|| {
             c2.send(());
             let _ = p1.recv();
@@ -842,11 +842,11 @@ mod tests {
         let mut child_data = Some((s2, c));
         s.access(|| {
             let (s2, c) = child_data.take_unwrap();
-            do task::spawn {
+            task::spawn(proc() {
                 c.send(());
                 s2.access(|| { });
                 c.send(());
-            }
+            });
             let _ = p.recv(); // wait for child to come alive
             5.times(|| { task::deschedule(); }); // let the child contend
         });
@@ -865,13 +865,12 @@ mod tests {
         let mut sharedstate = ~0;
         {
             let ptr: *int = &*sharedstate;
-            do task::spawn {
+            task::spawn(proc() {
                 let sharedstate: &mut int =
                     unsafe { cast::transmute(ptr) };
                 access_shared(sharedstate, &m2, 10);
                 c.send(());
-
-            }
+            });
         }
         {
             access_shared(sharedstate, &m, 10);
@@ -897,24 +896,24 @@ mod tests {
         // Child wakes up parent
         m.lock_cond(|cond| {
             let m2 = m.clone();
-            do task::spawn {
+            task::spawn(proc() {
                 m2.lock_cond(|cond| {
                     let woken = cond.signal();
                     assert!(woken);
                 })
-            }
+            });
             cond.wait();
         });
         // Parent wakes up child
         let (port,chan) = Chan::new();
         let m3 = m.clone();
-        do task::spawn {
+        task::spawn(proc() {
             m3.lock_cond(|cond| {
                 chan.send(());
                 cond.wait();
                 chan.send(());
             })
-        }
+        });
         let _ = port.recv(); // Wait until child gets in the mutex
         m.lock_cond(|cond| {
             let woken = cond.signal();
@@ -931,13 +930,13 @@ mod tests {
             let mi = m.clone();
             let (port, chan) = Chan::new();
             ports.push(port);
-            do task::spawn {
+            task::spawn(proc() {
                 mi.lock_cond(|cond| {
                     chan.send(());
                     cond.wait();
                     chan.send(());
                 })
-            }
+            });
         });
 
         // wait until all children get in the mutex
@@ -961,9 +960,9 @@ mod tests {
     fn test_mutex_cond_no_waiter() {
         let m = Mutex::new();
         let m2 = m.clone();
-        do task::try {
+        task::try(proc() {
             m.lock_cond(|_x| { })
-        };
+        });
         m2.lock_cond(|cond| {
             assert!(!cond.signal());
         })
@@ -974,11 +973,11 @@ mod tests {
         let m = Mutex::new();
         let m2 = m.clone();
 
-        let result: result::Result<(), ~Any> = do task::try {
+        let result: result::Result<(), ~Any> = task::try(proc() {
             m2.lock(|| {
                 fail!();
             })
-        };
+        });
         assert!(result.is_err());
         // child task must have finished by the time try returns
         m.lock(|| { })
@@ -991,18 +990,18 @@ mod tests {
         let m = Mutex::new();
         let m2 = m.clone();
 
-        let result: result::Result<(), ~Any> = do task::try {
+        let result: result::Result<(), ~Any> = task::try(proc() {
             let (p, c) = Chan::new();
-            do task::spawn { // linked
+            task::spawn(proc() { // linked
                 let _ = p.recv(); // wait for sibling to get in the mutex
                 task::deschedule();
                 fail!();
-            }
+            });
             m2.lock_cond(|cond| {
                 c.send(()); // tell sibling go ahead
                 cond.wait(); // block forever
             })
-        };
+        });
         assert!(result.is_err());
         // child task must have finished by the time try returns
         m.lock_cond(|cond| {
@@ -1019,14 +1018,14 @@ mod tests {
         let m2 = m.clone();
         let (p, c) = Chan::new();
 
-        let result: result::Result<(), ~Any> = do task::try {
+        let result: result::Result<(), ~Any> = task::try(proc() {
             let mut sibling_convos = ~[];
             2.times(|| {
                 let (p, c) = Chan::new();
                 sibling_convos.push(p);
                 let mi = m2.clone();
                 // spawn sibling task
-                do task::spawn { // linked
+                task::spawn(proc() { // linked
                     mi.lock_cond(|cond| {
                         c.send(()); // tell sibling to go ahead
                         (|| {
@@ -1037,7 +1036,7 @@ mod tests {
                             error!("task unwinding and done sending");
                         })
                     })
-                }
+                });
             });
             for p in sibling_convos.mut_iter() {
                 let _ = p.recv(); // wait for sibling to get in the mutex
@@ -1045,7 +1044,7 @@ mod tests {
             m2.lock(|| { });
             c.send(sibling_convos); // let parent wait on all children
             fail!();
-        };
+        });
         assert!(result.is_err());
         // child task must have finished by the time try returns
         let mut r = p.recv();
@@ -1061,52 +1060,52 @@ mod tests {
         let m = Mutex::new();
         m.lock_cond(|cond| {
             let m2 = m.clone();
-            do task::spawn {
+            task::spawn(proc() {
                 m2.lock_cond(|cond| {
                     cond.signal_on(0);
                 })
-            }
+            });
             cond.wait();
         })
     }
     #[test]
     #[ignore(reason = "linked failure?")]
     fn test_mutex_different_conds() {
-        let result = do task::try {
+        let result = task::try(proc() {
             let m = Mutex::new_with_condvars(2);
             let m2 = m.clone();
             let (p, c) = Chan::new();
-            do task::spawn {
+            task::spawn(proc() {
                 m2.lock_cond(|cond| {
                     c.send(());
                     cond.wait_on(1);
                 })
-            }
+            });
             let _ = p.recv();
             m.lock_cond(|cond| {
                 if !cond.signal_on(0) {
                     fail!(); // success; punt sibling awake.
                 }
             })
-        };
+        });
         assert!(result.is_err());
     }
     #[test]
     fn test_mutex_no_condvars() {
-        let result = do task::try {
+        let result = task::try(proc() {
             let m = Mutex::new_with_condvars(0);
             m.lock_cond(|cond| { cond.wait(); })
-        };
+        });
         assert!(result.is_err());
-        let result = do task::try {
+        let result = task::try(proc() {
             let m = Mutex::new_with_condvars(0);
             m.lock_cond(|cond| { cond.signal(); })
-        };
+        });
         assert!(result.is_err());
-        let result = do task::try {
+        let result = task::try(proc() {
             let m = Mutex::new_with_condvars(0);
             m.lock_cond(|cond| { cond.broadcast(); })
-        };
+        });
         assert!(result.is_err());
     }
     /************************************************************************
@@ -1141,12 +1140,12 @@ mod tests {
         let mut sharedstate = ~0;
         {
             let ptr: *int = &*sharedstate;
-            do task::spawn {
+            task::spawn(proc() {
                 let sharedstate: &mut int =
                     unsafe { cast::transmute(ptr) };
                 access_shared(sharedstate, &x2, mode1, 10);
                 c.send(());
-            }
+            });
         }
         {
             access_shared(sharedstate, x, mode2, 10);
@@ -1189,7 +1188,7 @@ mod tests {
         let x2 = x.clone();
         let (p1, c1) = Chan::new();
         let (p2, c2) = Chan::new();
-        do task::spawn {
+        task::spawn(proc() {
             if !make_mode2_go_first {
                 let _ = p2.recv(); // parent sends to us once it locks, or ...
             }
@@ -1200,7 +1199,7 @@ mod tests {
                 let _ = p2.recv();
                 c1.send(());
             })
-        }
+        });
         if make_mode2_go_first {
             let _ = p1.recv(); // child sends to us once it locks, or ...
         }
@@ -1244,24 +1243,24 @@ mod tests {
         // Child wakes up parent
         x.write_cond(|cond| {
             let x2 = x.clone();
-            do task::spawn {
+            task::spawn(proc() {
                 x2.write_cond(|cond| {
                     let woken = cond.signal();
                     assert!(woken);
                 })
-            }
+            });
             cond.wait();
         });
         // Parent wakes up child
         let (port, chan) = Chan::new();
         let x3 = x.clone();
-        do task::spawn {
+        task::spawn(proc() {
             x3.write_cond(|cond| {
                 chan.send(());
                 cond.wait();
                 chan.send(());
             })
-        }
+        });
         let _ = port.recv(); // Wait until child gets in the rwlock
         x.read(|| { }); // Must be able to get in as a reader in the meantime
         x.write_cond(|cond| { // Or as another writer
@@ -1292,13 +1291,13 @@ mod tests {
             let xi = x.clone();
             let (port, chan) = Chan::new();
             ports.push(port);
-            do task::spawn {
+            task::spawn(proc() {
                 lock_cond(&xi, dg1, |cond| {
                     chan.send(());
                     cond.wait();
                     chan.send(());
                 })
-            }
+            });
         });
 
         // wait until all children get in the mutex
@@ -1327,11 +1326,11 @@ mod tests {
         let x = RWLock::new();
         let x2 = x.clone();
 
-        let result: result::Result<(), ~Any> = do task::try || {
+        let result: result::Result<(), ~Any> = task::try(proc() {
             lock_rwlock_in_mode(&x2, mode1, || {
                 fail!();
             })
-        };
+        });
         assert!(result.is_err());
         // child task must have finished by the time try returns
         lock_rwlock_in_mode(&x, mode2, || { })
@@ -1392,10 +1391,10 @@ mod tests {
         9.times(|| {
             let c = barrier.clone();
             let chan = chan.clone();
-            do spawn {
+            spawn(proc() {
                 c.wait();
                 chan.send(true);
-            }
+            });
         });
 
         // At this point, all spawned tasks should be blocked,
diff --git a/src/libextra/test.rs b/src/libextra/test.rs
index c621461fc36a0..cd04cddba4a69 100644
--- a/src/libextra/test.rs
+++ b/src/libextra/test.rs
@@ -873,7 +873,7 @@ pub fn run_test(force_ignore: bool,
     fn run_test_inner(desc: TestDesc,
                       monitor_ch: SharedChan<MonitorMsg>,
                       testfn: proc()) {
-        do spawn {
+        spawn(proc() {
             let mut task = task::task();
             task.name(match desc.name {
                 DynTestName(ref name) => SendStrOwned(name.clone()),
@@ -885,7 +885,7 @@ pub fn run_test(force_ignore: bool,
             let task_result = result_future.recv();
             let test_result = calc_result(&desc, task_result.is_ok());
             monitor_ch.send((desc.clone(), test_result));
-        }
+        });
     }
 
     match testfn {
diff --git a/src/libextra/workcache.rs b/src/libextra/workcache.rs
index d8a97ae207703..70bbe02d32f17 100644
--- a/src/libextra/workcache.rs
+++ b/src/libextra/workcache.rs
@@ -414,14 +414,14 @@ impl<'a> Prep<'a> {
                 let blk = bo.take_unwrap();
 
                 // FIXME: What happens if the task fails?
-                do spawn {
+                spawn(proc() {
                     let mut exe = Exec {
                         discovered_inputs: WorkMap::new(),
                         discovered_outputs: WorkMap::new(),
                     };
                     let v = blk(&mut exe);
                     chan.send((exe, v));
-                }
+                });
                 Work::from_task(self, port)
             }
         }
@@ -495,7 +495,7 @@ fn test() {
 
         // FIXME (#9639): This needs to handle non-utf8 paths
         prep.declare_input("file", pth.as_str().unwrap(), file_content);
-        do prep.exec |_exe| {
+        prep.exec(proc(_exe) {
             let out = make_path(~"foo.o");
             // FIXME (#9639): This needs to handle non-utf8 paths
             run::process_status("gcc", [pth.as_str().unwrap().to_owned(),
@@ -507,7 +507,7 @@ fn test() {
 
             // FIXME (#9639): This needs to handle non-utf8 paths
             out.as_str().unwrap().to_owned()
-        }
+        })
     });
 
     println!("{}", s);
diff --git a/src/libgreen/basic.rs b/src/libgreen/basic.rs
index f303f100e0355..89c3398ab62d0 100644
--- a/src/libgreen/basic.rs
+++ b/src/libgreen/basic.rs
@@ -247,18 +247,18 @@ mod test {
 
     #[test]
     fn smoke() {
-        do run {}
+        run(proc() {});
     }
 
     #[test]
     fn some_channels() {
-        do run {
+        run(proc() {
             let (p, c) = Chan::new();
-            do spawn {
+            spawn(proc() {
                 c.send(());
-            }
+            });
             p.recv();
-        }
+        });
     }
 
     #[test]
@@ -269,13 +269,13 @@ mod test {
         });
 
         for _ in range(0, 20) {
-            do pool.spawn(TaskOpts::new()) {
+            pool.spawn(TaskOpts::new(), proc() {
                 let (p, c) = Chan::new();
-                do spawn {
+                spawn(proc() {
                     c.send(());
-                }
+                });
                 p.recv();
-            }
+            });
         }
 
         pool.shutdown();
diff --git a/src/libgreen/lib.rs b/src/libgreen/lib.rs
index d746d5012c431..f8d629589fc3c 100644
--- a/src/libgreen/lib.rs
+++ b/src/libgreen/lib.rs
@@ -60,10 +60,10 @@ pub mod task;
 #[cfg(not(test))]
 pub fn lang_start(main: *u8, argc: int, argv: **u8) -> int {
     use std::cast;
-    do start(argc, argv) {
+    start(argc, argv, proc() {
         let main: extern "Rust" fn() = unsafe { cast::transmute(main) };
         main();
-    }
+    })
 }
 
 /// Set up a default runtime configuration, given compiler-supplied arguments.
@@ -222,7 +222,7 @@ impl SchedPool {
                                             pool.task_state.clone());
             pool.handles.push(sched.make_handle());
             let sched = sched;
-            pool.threads.push(do Thread::start { sched.bootstrap(); });
+            pool.threads.push(Thread::start(proc() { sched.bootstrap(); }));
         }
 
         return pool;
@@ -284,7 +284,7 @@ impl SchedPool {
         let ret = sched.make_handle();
         self.handles.push(sched.make_handle());
         let sched = sched;
-        self.threads.push(do Thread::start { sched.bootstrap() });
+        self.threads.push(Thread::start(proc() { sched.bootstrap() }));
 
         return ret;
     }
diff --git a/src/libgreen/sched.rs b/src/libgreen/sched.rs
index 8fa1e6732dcc8..7ac874ebd9542 100644
--- a/src/libgreen/sched.rs
+++ b/src/libgreen/sched.rs
@@ -998,10 +998,10 @@ mod test {
     fn trivial_run_in_newsched_task_test() {
         let mut task_ran = false;
         let task_ran_ptr: *mut bool = &mut task_ran;
-        do run {
+        run(proc() {
             unsafe { *task_ran_ptr = true };
             rtdebug!("executed from the new scheduler")
-        }
+        });
         assert!(task_ran);
     }
 
@@ -1012,13 +1012,13 @@ mod test {
         let task_run_count_ptr: *mut uint = &mut task_run_count;
         // with only one thread this is safe to run in without worries of
         // contention.
-        do run {
+        run(proc() {
             for _ in range(0u, total) {
-                do spawn || {
+                spawn(proc() {
                     unsafe { *task_run_count_ptr = *task_run_count_ptr + 1};
-                }
+                });
             }
-        }
+        });
         assert!(task_run_count == total);
     }
 
@@ -1026,17 +1026,17 @@ mod test {
     fn multiple_task_nested_test() {
         let mut task_run_count = 0;
         let task_run_count_ptr: *mut uint = &mut task_run_count;
-        do run {
-            do spawn {
+        run(proc() {
+            spawn(proc() {
                 unsafe { *task_run_count_ptr = *task_run_count_ptr + 1 };
-                do spawn {
+                spawn(proc() {
                     unsafe { *task_run_count_ptr = *task_run_count_ptr + 1 };
-                    do spawn {
+                    spawn(proc() {
                         unsafe { *task_run_count_ptr = *task_run_count_ptr + 1 };
-                    }
-                }
-            }
-        }
+                    })
+                })
+            })
+        });
         assert!(task_run_count == 3);
     }
 
@@ -1052,15 +1052,15 @@ mod test {
             let mut handle1 = pool.spawn_sched();
             let mut handle2 = pool.spawn_sched();
 
-            handle1.send(TaskFromFriend(do pool.task(TaskOpts::new()) {
+            handle1.send(TaskFromFriend(pool.task(TaskOpts::new(), proc() {
                 chan.send(sched_id());
-            }));
+            })));
             let sched1_id = port.recv();
 
-            let mut task = do pool.task(TaskOpts::new()) {
+            let mut task = pool.task(TaskOpts::new(), proc() {
                 assert_eq!(sched_id(), sched1_id);
                 dchan.send(());
-            };
+            });
             task.give_home(HomeSched(handle1));
             handle2.send(TaskFromFriend(task));
         }
@@ -1080,7 +1080,7 @@ mod test {
         use std::rt::thread::Thread;
         use std::sync::deque::BufferPool;
 
-        do run_in_bare_thread {
+        run_in_bare_thread(proc() {
             let sleepers = SleeperList::new();
             let mut pool = BufferPool::new();
             let (normal_worker, normal_stealer) = pool.deque();
@@ -1146,23 +1146,23 @@ mod test {
                 ret
             }
 
-            let task1 = do GreenTask::new_homed(&mut special_sched.stack_pool,
-                                                None, HomeSched(t1_handle)) {
+            let task1 = GreenTask::new_homed(&mut special_sched.stack_pool,
+                                             None, HomeSched(t1_handle), proc() {
                 rtassert!(on_appropriate_sched());
-            };
+            });
 
-            let task2 = do GreenTask::new(&mut normal_sched.stack_pool, None) {
+            let task2 = GreenTask::new(&mut normal_sched.stack_pool, None, proc() {
                 rtassert!(on_appropriate_sched());
-            };
+            });
 
-            let task3 = do GreenTask::new(&mut normal_sched.stack_pool, None) {
+            let task3 = GreenTask::new(&mut normal_sched.stack_pool, None, proc() {
                 rtassert!(on_appropriate_sched());
-            };
+            });
 
-            let task4 = do GreenTask::new_homed(&mut special_sched.stack_pool,
-                                                None, HomeSched(t4_handle)) {
+            let task4 = GreenTask::new_homed(&mut special_sched.stack_pool,
+                                             None, HomeSched(t4_handle), proc() {
                 rtassert!(on_appropriate_sched());
-            };
+            });
 
             // Signal from the special task that we are done.
             let (port, chan) = Chan::<()>::new();
@@ -1173,8 +1173,7 @@ mod test {
                 sched.run_task(task, next)
             }
 
-            let normal_task = do GreenTask::new(&mut normal_sched.stack_pool,
-                                                None) {
+            let normal_task = GreenTask::new(&mut normal_sched.stack_pool, None, proc() {
                 run(task2);
                 run(task4);
                 port.recv();
@@ -1182,26 +1181,25 @@ mod test {
                 nh.send(Shutdown);
                 let mut sh = special_handle;
                 sh.send(Shutdown);
-            };
+            });
             normal_sched.enqueue_task(normal_task);
 
-            let special_task = do GreenTask::new(&mut special_sched.stack_pool,
-                                                 None) {
+            let special_task = GreenTask::new(&mut special_sched.stack_pool, None, proc() {
                 run(task1);
                 run(task3);
                 chan.send(());
-            };
+            });
             special_sched.enqueue_task(special_task);
 
             let normal_sched = normal_sched;
-            let normal_thread = do Thread::start { normal_sched.bootstrap() };
+            let normal_thread = Thread::start(proc() { normal_sched.bootstrap() });
 
             let special_sched = special_sched;
-            let special_thread = do Thread::start { special_sched.bootstrap() };
+            let special_thread = Thread::start(proc() { special_sched.bootstrap() });
 
             normal_thread.join();
             special_thread.join();
-        }
+        });
     }
 
     //#[test]
@@ -1226,11 +1224,11 @@ mod test {
         // the work queue, but we are performing I/O, that once we do put
         // something in the work queue again the scheduler picks it up and
         // doesn't exit before emptying the work queue
-        do pool.spawn(TaskOpts::new()) {
-            do spawn {
+        pool.spawn(TaskOpts::new(), proc() {
+            spawn(proc() {
                 timer::sleep(10);
-            }
-        }
+            });
+        });
 
         pool.shutdown();
     }
@@ -1243,19 +1241,19 @@ mod test {
         let mut pool1 = pool();
         let mut pool2 = pool();
 
-        do pool1.spawn(TaskOpts::new()) {
+        pool1.spawn(TaskOpts::new(), proc() {
             let id = sched_id();
             chan1.send(());
             port2.recv();
             assert_eq!(id, sched_id());
-        }
+        });
 
-        do pool2.spawn(TaskOpts::new()) {
+        pool2.spawn(TaskOpts::new(), proc() {
             let id = sched_id();
             port1.recv();
             assert_eq!(id, sched_id());
             chan2.send(());
-        }
+        });
 
         pool1.shutdown();
         pool2.shutdown();
@@ -1275,13 +1273,13 @@ mod test {
 
     #[test]
     fn multithreading() {
-        do run {
+        run(proc() {
             let mut ports = ~[];
             10.times(|| {
                 let (port, chan) = Chan::new();
-                do spawn {
+                spawn(proc() {
                     chan.send(());
-                }
+                });
                 ports.push(port);
             });
 
@@ -1291,12 +1289,12 @@ mod test {
                     None => break,
                 }
             }
-        }
+        });
     }
 
      #[test]
     fn thread_ring() {
-        do run {
+        run(proc() {
             let (end_port, end_chan) = Chan::new();
 
             let n_tasks = 10;
@@ -1309,19 +1307,19 @@ mod test {
                 let (next_p, ch) = Chan::new();
                 let imm_i = i;
                 let imm_p = p;
-                do spawn {
+                spawn(proc() {
                     roundtrip(imm_i, n_tasks, &imm_p, &ch);
-                };
+                });
                 p = next_p;
                 i += 1;
             }
             let p = p;
-            do spawn {
+            spawn(proc() {
                 roundtrip(1, n_tasks, &p, &ch1);
-            }
+            });
 
             end_port.recv();
-        }
+        });
 
         fn roundtrip(id: int, n_tasks: int,
                      p: &Port<(int, Chan<()>)>,
@@ -1349,7 +1347,7 @@ mod test {
     fn start_closure_dtor() {
         // Regression test that the `start` task entrypoint can
         // contain dtors that use task resources
-        do run {
+        run(proc() {
             struct S { field: () }
 
             impl Drop for S {
@@ -1360,10 +1358,10 @@ mod test {
 
             let s = S { field: () };
 
-            do spawn {
+            spawn(proc() {
                 let _ss = &s;
-            }
-        }
+            });
+        });
     }
 
     // FIXME: #9407: xfail-test
@@ -1374,36 +1372,36 @@ mod test {
             threads: 2, // this must be > 1
             event_loop_factory: Some(basic::event_loop),
         });
-        do pool.spawn(TaskOpts::new()) {
+        pool.spawn(TaskOpts::new(), proc() {
             let (port, chan) = Chan::new();
 
             // This task should not be able to starve the sender;
             // The sender should get stolen to another thread.
-            do spawn {
+            spawn(proc() {
                 while port.try_recv() != comm::Data(()) { }
-            }
+            });
 
             chan.send(());
-        }
+        });
         pool.shutdown();
     }
 
     #[test]
     fn dont_starve_2() {
-        do run {
+        run(proc() {
             let (port, chan) = Chan::new();
             let (_port2, chan2) = Chan::new();
 
             // This task should not be able to starve the other task.
             // The sends should eventually yield.
-            do spawn {
+            spawn(proc() {
                 while port.try_recv() != comm::Data(()) {
                     chan2.send(());
                 }
-            }
+            });
 
             chan.send(());
-        }
+        });
     }
 
     // Regression test for a logic bug that would cause single-threaded
@@ -1411,9 +1409,9 @@ mod test {
     #[test]
     fn single_threaded_yield() {
         use std::task::deschedule;
-        do run {
+        run(proc() {
             5.times(deschedule);
-        }
+        });
     }
 
     #[test]
@@ -1461,11 +1459,11 @@ mod test {
 
                 let (setup_po, setup_ch) = Chan::new();
                 let (parent_po, parent_ch) = Chan::new();
-                do spawn {
+                spawn(proc() {
                     let (child_po, child_ch) = Chan::new();
                     setup_ch.send(child_ch);
                     pingpong(&child_po, &parent_ch);
-                };
+                });
 
                 let child_ch = setup_po.recv();
                 child_ch.send(20);
diff --git a/src/libgreen/task.rs b/src/libgreen/task.rs
index 31752941231cb..f5dafe578cafd 100644
--- a/src/libgreen/task.rs
+++ b/src/libgreen/task.rs
@@ -494,19 +494,19 @@ mod tests {
     #[test]
     fn smoke() {
         let (p, c) = Chan::new();
-        do spawn_opts(TaskOpts::new()) {
+        spawn_opts(TaskOpts::new(), proc() {
             c.send(());
-        }
+        });
         p.recv();
     }
 
     #[test]
     fn smoke_fail() {
         let (p, c) = Chan::<()>::new();
-        do spawn_opts(TaskOpts::new()) {
+        spawn_opts(TaskOpts::new(), proc() {
             let _c = c;
             fail!()
-        }
+        });
         assert_eq!(p.recv_opt(), None);
     }
 
@@ -533,38 +533,38 @@ mod tests {
     #[test]
     fn yield_test() {
         let (p, c) = Chan::new();
-        do spawn_opts(TaskOpts::new()) {
+        spawn_opts(TaskOpts::new(), proc() {
             10.times(task::deschedule);
             c.send(());
-        }
+        });
         p.recv();
     }
 
     #[test]
     fn spawn_children() {
         let (p, c) = Chan::new();
-        do spawn_opts(TaskOpts::new()) {
+        spawn_opts(TaskOpts::new(), proc() {
             let (p, c2) = Chan::new();
-            do spawn {
+            spawn(proc() {
                 let (p, c3) = Chan::new();
-                do spawn {
+                spawn(proc() {
                     c3.send(());
-                }
+                });
                 p.recv();
                 c2.send(());
-            }
+            });
             p.recv();
             c.send(());
-        }
+        });
         p.recv();
     }
 
     #[test]
     fn spawn_inherits() {
         let (p, c) = Chan::new();
-        do spawn_opts(TaskOpts::new()) {
+        spawn_opts(TaskOpts::new(), proc() {
             let c = c;
-            do spawn {
+            spawn(proc() {
                 let mut task: ~Task = Local::take();
                 match task.maybe_take_runtime::<GreenTask>() {
                     Some(ops) => {
@@ -574,8 +574,8 @@ mod tests {
                 }
                 Local::put(task);
                 c.send(());
-            }
-        }
+            });
+        });
         p.recv();
     }
 }
diff --git a/src/libnative/io/timer_helper.rs b/src/libnative/io/timer_helper.rs
index 3c20d073f2913..9fc182203860b 100644
--- a/src/libnative/io/timer_helper.rs
+++ b/src/libnative/io/timer_helper.rs
@@ -46,10 +46,10 @@ pub fn boot(helper: fn(imp::signal, Port<Req>)) {
             let (receive, send) = imp::new();
             HELPER_SIGNAL = send;
 
-            do task::spawn {
+            task::spawn(proc() {
                 bookkeeping::decrement();
                 helper(receive, msgp);
-            }
+            });
 
             rt::at_exit(proc() { shutdown() });
         })
diff --git a/src/libnative/task.rs b/src/libnative/task.rs
index d2f68c4ef681d..438ac4add39fc 100644
--- a/src/libnative/task.rs
+++ b/src/libnative/task.rs
@@ -272,19 +272,19 @@ mod tests {
     #[test]
     fn smoke() {
         let (p, c) = Chan::new();
-        do spawn {
+        spawn(proc() {
             c.send(());
-        }
+        });
         p.recv();
     }
 
     #[test]
     fn smoke_fail() {
         let (p, c) = Chan::<()>::new();
-        do spawn {
+        spawn(proc() {
             let _c = c;
             fail!()
-        }
+        });
         assert_eq!(p.recv_opt(), None);
     }
 
@@ -311,38 +311,38 @@ mod tests {
     #[test]
     fn yield_test() {
         let (p, c) = Chan::new();
-        do spawn {
+        spawn(proc() {
             10.times(task::deschedule);
             c.send(());
-        }
+        });
         p.recv();
     }
 
     #[test]
     fn spawn_children() {
         let (p, c) = Chan::new();
-        do spawn {
+        spawn(proc() {
             let (p, c2) = Chan::new();
-            do spawn {
+            spawn(proc() {
                 let (p, c3) = Chan::new();
-                do spawn {
+                spawn(proc() {
                     c3.send(());
-                }
+                });
                 p.recv();
                 c2.send(());
-            }
+            });
             p.recv();
             c.send(());
-        }
+        });
         p.recv();
     }
 
     #[test]
     fn spawn_inherits() {
         let (p, c) = Chan::new();
-        do spawn {
+        spawn(proc() {
             let c = c;
-            do spawn {
+            spawn(proc() {
                 let mut task: ~Task = Local::take();
                 match task.maybe_take_runtime::<Ops>() {
                     Some(ops) => {
@@ -352,8 +352,8 @@ mod tests {
                 }
                 Local::put(task);
                 c.send(());
-            }
-        }
+            });
+        });
         p.recv();
     }
 }
diff --git a/src/librustc/middle/cfg/construct.rs b/src/librustc/middle/cfg/construct.rs
index 923e5eba10947..eb9c434ca2849 100644
--- a/src/librustc/middle/cfg/construct.rs
+++ b/src/librustc/middle/cfg/construct.rs
@@ -398,7 +398,6 @@ impl CFGBuilder {
             }
 
             ast::ExprAddrOf(_, e) |
-            ast::ExprDoBody(e) |
             ast::ExprCast(e, _) |
             ast::ExprUnary(_, _, e) |
             ast::ExprParen(e) |
diff --git a/src/librustc/middle/dataflow.rs b/src/librustc/middle/dataflow.rs
index a0ef6e503a127..164b231fedc71 100644
--- a/src/librustc/middle/dataflow.rs
+++ b/src/librustc/middle/dataflow.rs
@@ -706,7 +706,6 @@ impl<'a, O:DataFlowOperator> PropagationContext<'a, O> {
             ast::ExprPath(..) => {}
 
             ast::ExprAddrOf(_, e) |
-            ast::ExprDoBody(e) |
             ast::ExprCast(e, _) |
             ast::ExprUnary(_, _, e) |
             ast::ExprParen(e) |
diff --git a/src/librustc/middle/liveness.rs b/src/librustc/middle/liveness.rs
index dfe9af9f3f039..6a1fa488121bb 100644
--- a/src/librustc/middle/liveness.rs
+++ b/src/librustc/middle/liveness.rs
@@ -538,7 +538,7 @@ fn visit_expr(v: &mut LivenessVisitor, expr: &Expr, this: @IrMaps) {
       ExprIndex(..) | ExprField(..) | ExprVstore(..) | ExprVec(..) |
       ExprCall(..) | ExprMethodCall(..) | ExprTup(..) | ExprLogLevel |
       ExprBinary(..) | ExprAddrOf(..) |
-      ExprDoBody(..) | ExprCast(..) | ExprUnary(..) | ExprBreak(_) |
+      ExprCast(..) | ExprUnary(..) | ExprBreak(_) |
       ExprAgain(_) | ExprLit(_) | ExprRet(..) | ExprBlock(..) |
       ExprAssign(..) | ExprAssignOp(..) | ExprMac(..) |
       ExprStruct(..) | ExprRepeat(..) | ExprParen(..) |
@@ -1245,7 +1245,6 @@ impl Liveness {
           }
 
           ExprAddrOf(_, e) |
-          ExprDoBody(e) |
           ExprCast(e, _) |
           ExprUnary(_, _, e) |
           ExprParen(e) => {
@@ -1529,7 +1528,7 @@ fn check_expr(this: &mut Liveness, expr: &Expr) {
       ExprCall(..) | ExprMethodCall(..) | ExprIf(..) | ExprMatch(..) |
       ExprWhile(..) | ExprLoop(..) | ExprIndex(..) | ExprField(..) |
       ExprVstore(..) | ExprVec(..) | ExprTup(..) | ExprLogLevel |
-      ExprBinary(..) | ExprDoBody(..) |
+      ExprBinary(..) |
       ExprCast(..) | ExprUnary(..) | ExprRet(..) | ExprBreak(..) |
       ExprAgain(..) | ExprLit(_) | ExprBlock(..) |
       ExprMac(..) | ExprAddrOf(..) | ExprStruct(..) | ExprRepeat(..) |
diff --git a/src/librustc/middle/mem_categorization.rs b/src/librustc/middle/mem_categorization.rs
index b6271b68046ad..fadcd516e4ba8 100644
--- a/src/librustc/middle/mem_categorization.rs
+++ b/src/librustc/middle/mem_categorization.rs
@@ -436,7 +436,7 @@ impl mem_categorization_ctxt {
           ast::ExprAddrOf(..) | ast::ExprCall(..) |
           ast::ExprAssign(..) | ast::ExprAssignOp(..) |
           ast::ExprFnBlock(..) | ast::ExprProc(..) | ast::ExprRet(..) |
-          ast::ExprDoBody(..) | ast::ExprUnary(..) |
+          ast::ExprUnary(..) |
           ast::ExprMethodCall(..) | ast::ExprCast(..) | ast::ExprVstore(..) |
           ast::ExprVec(..) | ast::ExprTup(..) | ast::ExprIf(..) |
           ast::ExprLogLevel | ast::ExprBinary(..) | ast::ExprWhile(..) |
diff --git a/src/librustc/middle/moves.rs b/src/librustc/middle/moves.rs
index 054e293643937..b0171eafeb3fa 100644
--- a/src/librustc/middle/moves.rs
+++ b/src/librustc/middle/moves.rs
@@ -570,10 +570,6 @@ impl VisitContext {
                 self.consume_expr(count);
             }
 
-            ExprDoBody(base) => {
-                self.use_expr(base, comp_mode);
-            }
-
             ExprFnBlock(ref decl, body) |
             ExprProc(ref decl, body) => {
                 for a in decl.inputs.iter() {
diff --git a/src/librustc/middle/trans/debuginfo.rs b/src/librustc/middle/trans/debuginfo.rs
index a1c979d11852f..b9877d327cb1a 100644
--- a/src/librustc/middle/trans/debuginfo.rs
+++ b/src/librustc/middle/trans/debuginfo.rs
@@ -2655,20 +2655,6 @@ fn populate_scope_map(cx: &CrateContext,
                 })
             }
 
-            ast::ExprDoBody(inner_exp) => {
-                let inner_expr_is_expr_fn_block = match *inner_exp {
-                    ast::Expr { node: ast::ExprFnBlock(..), .. } => true,
-                    _ => false
-                };
-
-                if !inner_expr_is_expr_fn_block {
-                    cx.sess.span_bug(inner_exp.span, "debuginfo: Inner expression was expected \
-                                                      to be an ast::expr_fn_block.");
-                }
-
-                walk_expr(cx, inner_exp, scope_stack, scope_map);
-            }
-
             ast::ExprCall(fn_exp, ref args, _) => {
                 walk_expr(cx, fn_exp, scope_stack, scope_map);
 
diff --git a/src/librustc/middle/trans/expr.rs b/src/librustc/middle/trans/expr.rs
index 8de2c1d4cb228..d0a01f56b530c 100644
--- a/src/librustc/middle/trans/expr.rs
+++ b/src/librustc/middle/trans/expr.rs
@@ -867,9 +867,6 @@ fn trans_rvalue_dps_unadjusted<'a>(bcx: &'a Block<'a>,
             closure::trans_expr_fn(bcx, sigil, decl, body,
                                    expr.id, expr.id, dest)
         }
-        ast::ExprDoBody(blk) => {
-            trans_into(bcx, blk, dest)
-        }
         ast::ExprCall(f, ref args, _) => {
             callee::trans_call(bcx, expr, f,
                                callee::ArgExprs(*args), expr.id, dest)
diff --git a/src/librustc/middle/ty.rs b/src/librustc/middle/ty.rs
index a31b8413550a7..469df730a1290 100644
--- a/src/librustc/middle/ty.rs
+++ b/src/librustc/middle/ty.rs
@@ -3166,7 +3166,6 @@ pub fn expr_kind(tcx: ctxt,
         ast::ExprMatch(..) |
         ast::ExprFnBlock(..) |
         ast::ExprProc(..) |
-        ast::ExprDoBody(..) |
         ast::ExprBlock(..) |
         ast::ExprRepeat(..) |
         ast::ExprVstore(_, ast::ExprVstoreSlice) |
diff --git a/src/librustc/middle/typeck/check/mod.rs b/src/librustc/middle/typeck/check/mod.rs
index a0b50f65f202c..fe9998786f35f 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
@@ -1640,8 +1640,6 @@ pub fn check_expr_with_unifier(fcx: @FnCtxt,
         } else {
             let suffix = match sugar {
                 ast::NoSugar => "",
-                ast::DoSugar => " (including the closure passed by \
-                                 the `do` keyword)",
                 ast::ForSugar => " (including the closure passed by \
                                   the `for` keyword)"
             };
@@ -1690,8 +1688,7 @@ pub fn check_expr_with_unifier(fcx: @FnCtxt,
             for (i, arg) in args.iter().take(t).enumerate() {
                 let is_block = match arg.node {
                     ast::ExprFnBlock(..) |
-                    ast::ExprProc(..) |
-                    ast::ExprDoBody(..) => true,
+                    ast::ExprProc(..) => true,
                     _ => false
                 };
 
@@ -2928,44 +2925,6 @@ pub fn check_expr_with_unifier(fcx: @FnCtxt,
                       Vanilla,
                       expected);
       }
-      ast::ExprDoBody(b) => {
-        let expected_sty = unpack_expected(fcx,
-                                           expected,
-                                           |x| Some((*x).clone()));
-        let inner_ty = match expected_sty {
-            Some(ty::ty_closure(ref closure_ty))
-                    if closure_ty.sigil == ast::OwnedSigil => {
-                expected.unwrap()
-            }
-            _ => match expected {
-                Some(expected_t) => {
-                    fcx.type_error_message(expr.span, |actual| {
-                        format!("last argument in `do` call \
-                              has non-procedure type: {}",
-                             actual)
-                    }, expected_t, None);
-                    let err_ty = ty::mk_err();
-                    fcx.write_ty(id, err_ty);
-                    err_ty
-                }
-                None => {
-                    fcx.tcx().sess.impossible_case(
-                        expr.span,
-                        "do body must have expected type")
-                }
-            }
-        };
-        match b.node {
-          ast::ExprFnBlock(decl, body) => {
-            check_expr_fn(fcx, b, None,
-                          decl, body, DoBlock, Some(inner_ty));
-            demand::suptype(fcx, b.span, inner_ty, fcx.expr_ty(b));
-          }
-          // argh
-          _ => fail!("expected fn ty")
-        }
-        fcx.write_ty(expr.id, fcx.node_ty(b.id));
-      }
       ast::ExprBlock(b) => {
         check_block_with_expected(fcx, b, expected);
         fcx.write_ty(id, fcx.node_ty(b.id));
diff --git a/src/librustc/middle/typeck/check/regionck.rs b/src/librustc/middle/typeck/check/regionck.rs
index 1653429e457c6..f134fb3b6ae85 100644
--- a/src/librustc/middle/typeck/check/regionck.rs
+++ b/src/librustc/middle/typeck/check/regionck.rs
@@ -1045,7 +1045,6 @@ pub mod guarantor {
             ast::ExprMatch(..) |
             ast::ExprFnBlock(..) |
             ast::ExprProc(..) |
-            ast::ExprDoBody(..) |
             ast::ExprBlock(..) |
             ast::ExprRepeat(..) |
             ast::ExprVec(..) => {
diff --git a/src/librustdoc/lib.rs b/src/librustdoc/lib.rs
index 768ed8ae078db..f7a484e3d3e00 100644
--- a/src/librustdoc/lib.rs
+++ b/src/librustdoc/lib.rs
@@ -211,10 +211,10 @@ fn rust_input(cratefile: &str, matches: &getopts::Matches) -> Output {
     let cfgs = matches.opt_strs("cfg");
     let cr = Path::new(cratefile);
     info!("starting to run rustc");
-    let (crate, analysis) = do std::task::try {
+    let (crate, analysis) = std::task::try(proc() {
         let cr = cr;
         core::run_core(libs.move_iter().collect(), cfgs, &cr)
-    }.unwrap();
+    }).unwrap();
     info!("finished with rustc");
     local_data::set(analysiskey, analysis);
 
diff --git a/src/librustpkg/lib.rs b/src/librustpkg/lib.rs
index 14936cee4f03d..b43ffec2783ca 100644
--- a/src/librustpkg/lib.rs
+++ b/src/librustpkg/lib.rs
@@ -799,14 +799,14 @@ pub fn main_args(args: &[~str]) -> int {
     debug!("Will store workcache in {}", ws.display());
 
     // Wrap the rest in task::try in case of a condition failure in a task
-    let result = do task::try {
+    let result = task::try(proc() {
         BuildContext {
             context: context,
             sysroot: sysroot.clone(), // Currently, only tests override this
             workcache_context: api::default_context(sysroot.clone(),
                                                     default_workspace()).workcache_context
         }.run(command, args.clone())
-    };
+    });
     // FIXME #9262: This is using the same error code for all errors,
     // and at least one test case succeeds if rustpkg returns COPY_FAILED_CODE,
     // when actually, it might set the exit code for that even if a different
diff --git a/src/librustpkg/tests.rs b/src/librustpkg/tests.rs
index 22128a668ed3e..091399c3fb7de 100644
--- a/src/librustpkg/tests.rs
+++ b/src/librustpkg/tests.rs
@@ -607,13 +607,13 @@ fn test_install_invalid() {
     let ctxt = fake_ctxt(sysroot, &temp_workspace);
 
     // Uses task::try because of #9001
-    let result = do task::try {
+    let result = task::try(proc() {
         let pkg_src = PkgSrc::new(temp_workspace.clone(),
                                   temp_workspace.clone(),
                                   false,
                                   crateid.clone());
         ctxt.install(pkg_src, &WhatToBuild::new(MaybeCustom, Everything));
-    };
+    });
     assert!(result.unwrap_err()
             .to_str().contains("supplied path for package dir does not exist"));
 }
diff --git a/src/librustpkg/testsuite/pass/src/c-dependencies/pkg.rs b/src/librustpkg/testsuite/pass/src/c-dependencies/pkg.rs
index b6dba40ebd46a..dcc39ae0e92b4 100644
--- a/src/librustpkg/testsuite/pass/src/c-dependencies/pkg.rs
+++ b/src/librustpkg/testsuite/pass/src/c-dependencies/pkg.rs
@@ -50,7 +50,7 @@ pub fn main() {
         prep.declare_input("file",
                            foo_c_name.as_str().unwrap().to_owned(),
                            digest_file_with_date(&foo_c_name));
-        let out_path = do prep.exec |exec| {
+        let out_path = prep.exec(|exec| {
             let out_path = api::build_library_in_workspace(exec,
                                                            &mut sub_cx.clone(),
                                                            "cdep",
@@ -60,7 +60,7 @@ pub fn main() {
                                                            "foo");
             let out_p = Path::new(out_path.unwrap());
             out_p.as_str().unwrap().to_owned()
-        };
+        });
         out_path
     });
     let out_lib_path = Path::new(out_lib_path);
@@ -68,14 +68,14 @@ pub fn main() {
     context.add_library_path(out_lib_path.dir_path());
 
     let context_clone = context.clone();
-    let task_res = do task::try {
+    let task_res = task::try(proc() {
         let mut cc = context_clone.clone();
         api::install_pkg(&mut cc,
                          os::getcwd(),
                          ~"cdep",
                          None,
                          ~[(~"binary", out_lib_path.clone()), (~"file", foo_c_name.clone())]);
-    };
+    });
 
     if task_res.is_err() {
         os::set_exit_status(COPY_FAILED_CODE);
diff --git a/src/librustuv/async.rs b/src/librustuv/async.rs
index 5085dd64b6759..5dc50beb85061 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 d6061088469d1..8d3e71312cd95 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 1817be8a5940b..0b889e17a445e 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 012ab9ed1226b..8919ecfa97ef4 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 36a7a63194326..cfe86d739abcf 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 6772c6d193614..8cb0c1f0a52d7 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 4a0ad44d31147..aeda1a45175ea 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 dbf129d0b699c..e0bff059b0c91 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 {
diff --git a/src/libstd/comm/mod.rs b/src/libstd/comm/mod.rs
index dbffb6a0fd9b2..8c56e65c22c66 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 57ea205134a7a..af435c3fc5f31 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 e15b9a861ca1b..0acfa71e3151c 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 92efc4e9306f3..2d074df49199b 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 952ca7f730ed7..1cf30d469f7aa 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 232ca67059732..dcf6d2ad20358 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 799adff37e37f..9919d333f41b4 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 0f05254b03489..5575e289b59a7 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 f3f071ab78bff..d9fa2a4fc336b 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 d81de989df7d8..6ac73e7f61e71 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 4bf89a1d5596c..24eaf6adf3f3e 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 7406fe8ee408d..719cf2450c505 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 e95bd2d8ca2f3..8029ec696f82a 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 cc0705ee76fb4..a07471afc1a67 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 a8fd75c1beeed..c359d79d27509 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 37596b3501542..76a672b79cada 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 d543af1bf9bf7..83f5ca346a936 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 f42163791a6ab..482477b2f0eb9 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 b65feedb2ae5e..7feff127d691a 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 18be85152d715..bb0e96f96de2b 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 a249d6ed2e8ce..1ec8ac5d83e05 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 b4b327cc9d163..35a5846f11aba 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 8ed4b70c0a28a..c8b690830866e 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 f4573785996c4..87870ef033142 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 ba965f2b5c5b2..39f0d7b5638bc 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 687efea939b52..3b2c86c371217 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));
         }
     }
diff --git a/src/libsyntax/ast.rs b/src/libsyntax/ast.rs
index 10b1aad81382e..3070ecde71e6b 100644
--- a/src/libsyntax/ast.rs
+++ b/src/libsyntax/ast.rs
@@ -539,7 +539,6 @@ impl Expr {
 #[deriving(Clone, Eq, Encodable, Decodable, IterBytes)]
 pub enum CallSugar {
     NoSugar,
-    DoSugar,
     ForSugar
 }
 
@@ -566,7 +565,6 @@ pub enum Expr_ {
     ExprMatch(@Expr, ~[Arm]),
     ExprFnBlock(P<FnDecl>, P<Block>),
     ExprProc(P<FnDecl>, P<Block>),
-    ExprDoBody(@Expr),
     ExprBlock(P<Block>),
 
     ExprAssign(@Expr, @Expr),
diff --git a/src/libsyntax/fold.rs b/src/libsyntax/fold.rs
index c739fb911ba7f..d02f6384990a9 100644
--- a/src/libsyntax/fold.rs
+++ b/src/libsyntax/fold.rs
@@ -752,7 +752,6 @@ pub fn noop_fold_expr<T: Folder>(e: @Expr, folder: &mut T) -> @Expr {
         ExprUnary(callee_id, binop, ohs) => {
             ExprUnary(folder.new_id(callee_id), binop, folder.fold_expr(ohs))
         }
-        ExprDoBody(f) => ExprDoBody(folder.fold_expr(f)),
         ExprLit(_) => e.node.clone(),
         ExprCast(expr, ty) => {
             ExprCast(folder.fold_expr(expr), folder.fold_ty(ty))
diff --git a/src/libsyntax/parse/classify.rs b/src/libsyntax/parse/classify.rs
index 61c80919b6e71..accf5e7354045 100644
--- a/src/libsyntax/parse/classify.rs
+++ b/src/libsyntax/parse/classify.rs
@@ -29,9 +29,7 @@ pub fn expr_requires_semi_to_be_stmt(e: @ast::Expr) -> bool {
       | ast::ExprWhile(..)
       | ast::ExprLoop(..)
       | ast::ExprForLoop(..)
-      | ast::ExprCall(_, _, ast::DoSugar)
       | ast::ExprCall(_, _, ast::ForSugar)
-      | ast::ExprMethodCall(_, _, _, _, ast::DoSugar)
       | ast::ExprMethodCall(_, _, _, _, ast::ForSugar) => false,
       _ => true
     }
diff --git a/src/libsyntax/parse/parser.rs b/src/libsyntax/parse/parser.rs
index 17590ccf52358..b4de4dabfc6d0 100644
--- a/src/libsyntax/parse/parser.rs
+++ b/src/libsyntax/parse/parser.rs
@@ -13,7 +13,7 @@
 use abi;
 use abi::AbiSet;
 use ast::{Sigil, BorrowedSigil, ManagedSigil, OwnedSigil};
-use ast::{CallSugar, NoSugar, DoSugar};
+use ast::{CallSugar, NoSugar};
 use ast::{BareFnTy, ClosureTy};
 use ast::{RegionTyParamBound, TraitTyParamBound};
 use ast::{Provided, Public, Purity};
@@ -24,7 +24,7 @@ use ast::{Crate, CrateConfig, Decl, DeclItem};
 use ast::{DeclLocal, DefaultBlock, UnDeref, BiDiv, EMPTY_CTXT, EnumDef, ExplicitSelf};
 use ast::{Expr, Expr_, ExprAddrOf, ExprMatch, ExprAgain};
 use ast::{ExprAssign, ExprAssignOp, ExprBinary, ExprBlock, ExprBox};
-use ast::{ExprBreak, ExprCall, ExprCast, ExprDoBody};
+use ast::{ExprBreak, ExprCall, ExprCast};
 use ast::{ExprField, ExprFnBlock, ExprIf, ExprIndex};
 use ast::{ExprLit, ExprLogLevel, ExprLoop, ExprMac};
 use ast::{ExprMethodCall, ExprParen, ExprPath, ExprProc};
@@ -1796,9 +1796,6 @@ impl Parser {
             return self.parse_if_expr();
         } else if self.eat_keyword(keywords::For) {
             return self.parse_for_expr(None);
-        } else if self.eat_keyword(keywords::Do) {
-            return self.parse_sugary_call_expr(lo, ~"do", DoSugar,
-                                               ExprDoBody);
         } else if self.eat_keyword(keywords::While) {
             return self.parse_while_expr();
         } else if Parser::token_is_lifetime(&self.token) {
@@ -2541,75 +2538,6 @@ impl Parser {
         self.mk_expr(lo, hi, ExprForLoop(pat, expr, loop_block, opt_ident))
     }
 
-
-    // parse a 'do'.
-    // the 'do' expression parses as a call, but looks like
-    // a function call followed by a closure expression.
-    pub fn parse_sugary_call_expr(&mut self,
-                                  lo: BytePos,
-                                  keyword: ~str,
-                                  sugar: CallSugar,
-                                  ctor: |v: @Expr| -> Expr_)
-                                  -> @Expr {
-        // Parse the callee `foo` in
-        //    do foo || {
-        //    do foo.bar || {
-        // etc, or the portion of the call expression before the lambda in
-        //    do foo() || {
-        // or
-        //    do foo.bar(a) || {
-        // Turn on the restriction to stop at | or || so we can parse
-        // them as the lambda arguments
-        let e = self.parse_expr_res(RESTRICT_NO_BAR_OR_DOUBLEBAR_OP);
-        match e.node {
-            ExprCall(f, ref args, NoSugar) => {
-                let block = self.parse_lambda_block_expr();
-                let last_arg = self.mk_expr(block.span.lo, block.span.hi,
-                                            ctor(block));
-                let args = vec::append_one((*args).clone(), last_arg);
-                self.mk_expr(lo, block.span.hi, ExprCall(f, args, sugar))
-            }
-            ExprMethodCall(_, i, ref tps, ref args, NoSugar) => {
-                let block = self.parse_lambda_block_expr();
-                let last_arg = self.mk_expr(block.span.lo, block.span.hi,
-                                            ctor(block));
-                let args = vec::append_one((*args).clone(), last_arg);
-                let method_call = self.mk_method_call(i,
-                                                      (*tps).clone(),
-                                                      args,
-                                                      sugar);
-                self.mk_expr(lo, block.span.hi, method_call)
-            }
-            ExprField(f, i, ref tps) => {
-                let block = self.parse_lambda_block_expr();
-                let last_arg = self.mk_expr(block.span.lo, block.span.hi,
-                                            ctor(block));
-                let method_call = self.mk_method_call(i,
-                                                      (*tps).clone(),
-                                                      ~[f, last_arg],
-                                                      sugar);
-                self.mk_expr(lo, block.span.hi, method_call)
-            }
-            ExprPath(..) | ExprCall(..) | ExprMethodCall(..) |
-                ExprParen(..) => {
-                let block = self.parse_lambda_block_expr();
-                let last_arg = self.mk_expr(block.span.lo, block.span.hi,
-                                            ctor(block));
-                let call = self.mk_call(e, ~[last_arg], sugar);
-                self.mk_expr(lo, last_arg.span.hi, call)
-            }
-            _ => {
-                // There may be other types of expressions that can
-                // represent the callee in `do` expressions
-                // but they aren't represented by tests
-                debug!("sugary call on {:?}", e.node);
-                self.span_fatal(
-                    e.span,
-                    format!("`{}` must be followed by a block call", keyword));
-            }
-        }
-    }
-
     pub fn parse_while_expr(&mut self) -> @Expr {
         let lo = self.last_span.lo;
         let cond = self.parse_expr();
diff --git a/src/libsyntax/parse/token.rs b/src/libsyntax/parse/token.rs
index 56681ef2def00..68e2f44ebb184 100644
--- a/src/libsyntax/parse/token.rs
+++ b/src/libsyntax/parse/token.rs
@@ -433,51 +433,50 @@ declare_special_idents_and_keywords! {
         (14,                         As,         "as");
         (15,                         Break,      "break");
         (16,                         Const,      "const");
-        (17,                         Do,         "do");
-        (18,                         Else,       "else");
-        (19,                         Enum,       "enum");
-        (20,                         Extern,     "extern");
-        (21,                         False,      "false");
-        (22,                         Fn,         "fn");
-        (23,                         For,        "for");
-        (24,                         If,         "if");
-        (25,                         Impl,       "impl");
-        (26,                         In,         "in");
-        (27,                         Let,        "let");
-        (28,                         __LogLevel, "__log_level");
-        (29,                         Loop,       "loop");
-        (30,                         Match,      "match");
-        (31,                         Mod,        "mod");
-        (32,                         Mut,        "mut");
-        (33,                         Once,       "once");
-        (34,                         Priv,       "priv");
-        (35,                         Pub,        "pub");
-        (36,                         Ref,        "ref");
-        (37,                         Return,     "return");
+        (17,                         Else,       "else");
+        (18,                         Enum,       "enum");
+        (19,                         Extern,     "extern");
+        (20,                         False,      "false");
+        (21,                         Fn,         "fn");
+        (22,                         For,        "for");
+        (23,                         If,         "if");
+        (24,                         Impl,       "impl");
+        (25,                         In,         "in");
+        (26,                         Let,        "let");
+        (27,                         __LogLevel, "__log_level");
+        (28,                         Loop,       "loop");
+        (29,                         Match,      "match");
+        (30,                         Mod,        "mod");
+        (31,                         Mut,        "mut");
+        (32,                         Once,       "once");
+        (33,                         Priv,       "priv");
+        (34,                         Pub,        "pub");
+        (35,                         Ref,        "ref");
+        (36,                         Return,     "return");
         // Static and Self are also special idents (prefill de-dupes)
         (super::STATIC_KEYWORD_NAME, Static,     "static");
         (super::SELF_KEYWORD_NAME,   Self,       "self");
-        (38,                         Struct,     "struct");
-        (39,                         Super,      "super");
-        (40,                         True,       "true");
-        (41,                         Trait,      "trait");
-        (42,                         Type,       "type");
-        (43,                         Unsafe,     "unsafe");
-        (44,                         Use,        "use");
-        (45,                         While,      "while");
-        (46,                         Continue,   "continue");
-        (47,                         Proc,       "proc");
-        (48,                         Box,        "box");
+        (37,                         Struct,     "struct");
+        (38,                         Super,      "super");
+        (39,                         True,       "true");
+        (40,                         Trait,      "trait");
+        (41,                         Type,       "type");
+        (42,                         Unsafe,     "unsafe");
+        (43,                         Use,        "use");
+        (44,                         While,      "while");
+        (45,                         Continue,   "continue");
+        (46,                         Proc,       "proc");
+        (47,                         Box,        "box");
 
         'reserved:
-        (49,                         Alignof,    "alignof");
-        (50,                         Be,         "be");
-        (51,                         Offsetof,   "offsetof");
-        (52,                         Pure,       "pure");
-        (53,                         Sizeof,     "sizeof");
-        (54,                         Typeof,     "typeof");
-        (55,                         Unsized,    "unsized");
-        (56,                         Yield,      "yield");
+        (48,                         Alignof,    "alignof");
+        (49,                         Be,         "be");
+        (50,                         Offsetof,   "offsetof");
+        (51,                         Pure,       "pure");
+        (52,                         Sizeof,     "sizeof");
+        (53,                         Typeof,     "typeof");
+        (54,                         Unsized,    "unsized");
+        (55,                         Yield,      "yield");
     }
 }
 
diff --git a/src/libsyntax/print/pprust.rs b/src/libsyntax/print/pprust.rs
index d3c194b6af67a..68efdf31e0314 100644
--- a/src/libsyntax/print/pprust.rs
+++ b/src/libsyntax/print/pprust.rs
@@ -1088,10 +1088,6 @@ pub fn print_call_pre(s: &mut State,
                       base_args: &mut ~[@ast::Expr])
                    -> Option<@ast::Expr> {
     match sugar {
-        ast::DoSugar => {
-            head(s, "do");
-            Some(base_args.pop().unwrap())
-        }
         ast::ForSugar => {
             head(s, "for");
             Some(base_args.pop().unwrap())
@@ -1111,19 +1107,8 @@ pub fn print_call_post(s: &mut State,
     }
     if sugar != ast::NoSugar {
         nbsp(s);
-        match blk.unwrap().node {
-          // need to handle closures specifically
-          ast::ExprDoBody(e) => {
-            end(s); // we close our head box; closure
-                    // will create it's own.
-            print_expr(s, e);
-            end(s); // close outer box, as closures don't
-          }
-          _ => {
-            // not sure if this can happen.
-            print_expr(s, blk.unwrap());
-          }
-        }
+        // not sure if this can happen
+        print_expr(s, blk.unwrap());
     }
 }
 
@@ -1405,9 +1390,6 @@ pub fn print_expr(s: &mut State, expr: &ast::Expr) {
         // empty box to satisfy the close.
         ibox(s, 0);
       }
-      ast::ExprDoBody(body) => {
-        print_expr(s, body);
-      }
       ast::ExprBlock(blk) => {
         // containing cbox, will be closed by print-block at }
         cbox(s, indent_unit);
diff --git a/src/libsyntax/visit.rs b/src/libsyntax/visit.rs
index 5e7ad3af526b2..7201fc3a38052 100644
--- a/src/libsyntax/visit.rs
+++ b/src/libsyntax/visit.rs
@@ -665,8 +665,7 @@ pub fn walk_expr<E: Clone, V: Visitor<E>>(visitor: &mut V, expression: &Expr, en
             visitor.visit_expr(right_expression, env.clone())
         }
         ExprAddrOf(_, subexpression) |
-        ExprUnary(_, _, subexpression) |
-        ExprDoBody(subexpression) => {
+        ExprUnary(_, _, subexpression) => {
             visitor.visit_expr(subexpression, env.clone())
         }
         ExprLit(_) => {}
diff --git a/src/test/auxiliary/cci_capture_clause.rs b/src/test/auxiliary/cci_capture_clause.rs
index ed896af69b41f..3bf084b5fdae7 100644
--- a/src/test/auxiliary/cci_capture_clause.rs
+++ b/src/test/auxiliary/cci_capture_clause.rs
@@ -12,8 +12,8 @@ use std::task;
 
 pub fn foo<T:Send + Clone>(x: T) -> Port<T> {
     let (p, c) = Chan::new();
-    do task::spawn() {
+    task::spawn(proc() {
         c.send(x.clone());
-    }
+    });
     p
 }
diff --git a/src/test/bench/msgsend-pipes-shared.rs b/src/test/bench/msgsend-pipes-shared.rs
index 50cb00b25d4b1..aa4e0f1ae5809 100644
--- a/src/test/bench/msgsend-pipes-shared.rs
+++ b/src/test/bench/msgsend-pipes-shared.rs
@@ -64,17 +64,17 @@ fn run(args: &[~str]) {
         let to_child = to_child.clone();
         let mut builder = task::task();
         worker_results.push(builder.future_result());
-        do builder.spawn {
+        builder.spawn(proc() {
             for _ in range(0u, size / workers) {
                 //error!("worker {:?}: sending {:?} bytes", i, num_bytes);
                 to_child.send(bytes(num_bytes));
             }
             //error!("worker {:?} exiting", i);
-        }
+        });
     }
-    do task::spawn || {
+    task::spawn(proc() {
         server(&from_parent, &to_parent);
-    }
+    });
 
     for r in worker_results.iter() {
         r.recv();
diff --git a/src/test/bench/msgsend-pipes.rs b/src/test/bench/msgsend-pipes.rs
index 3cf1a97a36e04..6ce0f9de8d0a2 100644
--- a/src/test/bench/msgsend-pipes.rs
+++ b/src/test/bench/msgsend-pipes.rs
@@ -58,13 +58,13 @@ fn run(args: &[~str]) {
         let (from_parent, to_child) = Chan::new();
         let mut builder = task::task();
         worker_results.push(builder.future_result());
-        do builder.spawn {
+        builder.spawn(proc() {
             for _ in range(0u, size / workers) {
                 //error!("worker {:?}: sending {:?} bytes", i, num_bytes);
                 to_child.send(bytes(num_bytes));
             }
             //error!("worker {:?} exiting", i);
-        };
+        });
         from_parent
     } else {
         let (from_parent, to_child) = SharedChan::new();
@@ -72,19 +72,19 @@ fn run(args: &[~str]) {
             let to_child = to_child.clone();
             let mut builder = task::task();
             worker_results.push(builder.future_result());
-            do builder.spawn {
+            builder.spawn(proc() {
                 for _ in range(0u, size / workers) {
                     //error!("worker {:?}: sending {:?} bytes", i, num_bytes);
                     to_child.send(bytes(num_bytes));
                 }
                 //error!("worker {:?} exiting", i);
-            };
+            });
         }
         from_parent
     };
-    do task::spawn || {
+    task::spawn(proc() {
         server(&from_parent, &to_parent);
-    }
+    });
 
     for r in worker_results.iter() {
         r.recv();
diff --git a/src/test/bench/msgsend-ring-mutex-arcs.rs b/src/test/bench/msgsend-ring-mutex-arcs.rs
index a5838f2017385..b1b2300466a5e 100644
--- a/src/test/bench/msgsend-ring-mutex-arcs.rs
+++ b/src/test/bench/msgsend-ring-mutex-arcs.rs
@@ -91,9 +91,9 @@ fn main() {
         //error!("spawning %?", i);
         let (new_chan, num_port) = init();
         let num_chan_2 = num_chan.clone();
-        let new_future = do Future::spawn() {
+        let new_future = Future::spawn(proc() {
             thread_ring(i, msg_per_task, num_chan_2, num_port)
-        };
+        });
         futures.push(new_future);
         num_chan = new_chan;
     };
diff --git a/src/test/bench/msgsend-ring-rw-arcs.rs b/src/test/bench/msgsend-ring-rw-arcs.rs
index fa7026b6569f9..d7bd0f2f6bd3d 100644
--- a/src/test/bench/msgsend-ring-rw-arcs.rs
+++ b/src/test/bench/msgsend-ring-rw-arcs.rs
@@ -87,9 +87,9 @@ fn main() {
         //error!("spawning %?", i);
         let (new_chan, num_port) = init();
         let num_chan_2 = num_chan.clone();
-        let new_future = do Future::spawn {
+        let new_future = Future::spawn(proc() {
             thread_ring(i, msg_per_task, num_chan_2, num_port)
-        };
+        });
         futures.push(new_future);
         num_chan = new_chan;
     };
diff --git a/src/test/bench/rt-messaging-ping-pong.rs b/src/test/bench/rt-messaging-ping-pong.rs
index 6eef71622c5c6..29904de897eba 100644
--- a/src/test/bench/rt-messaging-ping-pong.rs
+++ b/src/test/bench/rt-messaging-ping-pong.rs
@@ -26,23 +26,23 @@ fn ping_pong_bench(n: uint, m: uint) {
         // Create a stream B->A
         let (pb,cb) = Chan::<()>::new();
 
-        do spawn() || {
+        spawn(proc() {
             let chan = ca;
             let port = pb;
             n.times(|| {
                 chan.send(());
                 port.recv();
             })
-        }
+        });
 
-        do spawn() || {
+        spawn(proc() {
             let chan = cb;
             let port = pa;
             n.times(|| {
                 port.recv();
                 chan.send(());
             })
-        }
+        });
     }
 
     m.times(|| {
diff --git a/src/test/bench/rt-parfib.rs b/src/test/bench/rt-parfib.rs
index 6e3c42f2a4dea..59f5afa47dafd 100644
--- a/src/test/bench/rt-parfib.rs
+++ b/src/test/bench/rt-parfib.rs
@@ -23,9 +23,9 @@ fn parfib(n: uint) -> uint {
     }
 
     let (port,chan) = Chan::new();
-    do spawn {
+    spawn(proc() {
         chan.send(parfib(n-1));
-    };
+    });
     let m2 = parfib(n-2);
     return (port.recv() + m2);
 }
diff --git a/src/test/bench/rt-spawn-rate.rs b/src/test/bench/rt-spawn-rate.rs
index e057d6862e6a9..f3bb168f65117 100644
--- a/src/test/bench/rt-spawn-rate.rs
+++ b/src/test/bench/rt-spawn-rate.rs
@@ -27,7 +27,7 @@ fn main() {
     };
 
     n.times(|| {
-        do spawn || {};
+        spawn(proc() {});
     })
 
 }
diff --git a/src/test/bench/shootout-binarytrees.rs b/src/test/bench/shootout-binarytrees.rs
index 7abbbdd278cff..1a4ad2297181c 100644
--- a/src/test/bench/shootout-binarytrees.rs
+++ b/src/test/bench/shootout-binarytrees.rs
@@ -64,7 +64,7 @@ fn main() {
     let mut messages = range_step(min_depth, max_depth + 1, 2).map(|depth| {
             use std::num::pow;
             let iterations = pow(2, (max_depth - depth + min_depth) as uint);
-            do Future::spawn {
+            Future::spawn(proc() {
                 let mut chk = 0;
                 for i in range(1, iterations + 1) {
                     let arena = TypedArena::new();
@@ -74,7 +74,7 @@ fn main() {
                 }
                 format!("{}\t trees of depth {}\t check: {}",
                         iterations * 2, depth, chk)
-            }
+            })
         }).to_owned_vec();
 
     for message in messages.mut_iter() {
diff --git a/src/test/bench/shootout-chameneos-redux.rs b/src/test/bench/shootout-chameneos-redux.rs
index 2a5f7f0b87e98..7281667e6769a 100644
--- a/src/test/bench/shootout-chameneos-redux.rs
+++ b/src/test/bench/shootout-chameneos-redux.rs
@@ -152,13 +152,13 @@ fn rendezvous(nn: uint, set: ~[color]) {
             let to_rendezvous = to_rendezvous.clone();
             let to_rendezvous_log = to_rendezvous_log.clone();
             let (from_rendezvous, to_creature) = Chan::new();
-            do task::spawn {
+            task::spawn(proc() {
                 creature(ii,
                          col,
                          from_rendezvous,
                          to_rendezvous.clone(),
                          to_rendezvous_log.clone());
-            }
+            });
             to_creature
         }).collect();
 
diff --git a/src/test/bench/shootout-k-nucleotide-pipes.rs b/src/test/bench/shootout-k-nucleotide-pipes.rs
index 83eb1388c6b17..375f9154841f4 100644
--- a/src/test/bench/shootout-k-nucleotide-pipes.rs
+++ b/src/test/bench/shootout-k-nucleotide-pipes.rs
@@ -168,9 +168,9 @@ fn main() {
 
         let (from_parent, to_child) = Chan::new();
 
-        do spawn {
+        spawn(proc() {
             make_sequence_processor(sz, &from_parent, &to_parent_);
-        }
+        });
 
         to_child
     }).collect::<~[Chan<~[u8]>]>();
diff --git a/src/test/bench/shootout-pfib.rs b/src/test/bench/shootout-pfib.rs
index aa060ceb0973f..040c8526ee04f 100644
--- a/src/test/bench/shootout-pfib.rs
+++ b/src/test/bench/shootout-pfib.rs
@@ -79,9 +79,9 @@ fn stress(num_tasks: int) {
     for i in range(0, num_tasks) {
         let mut builder = task::task();
         results.push(builder.future_result());
-        do builder.spawn {
+        builder.spawn(proc() {
             stress_task(i);
-        }
+        });
     }
     for r in results.iter() {
         r.recv();
diff --git a/src/test/bench/shootout-spectralnorm.rs b/src/test/bench/shootout-spectralnorm.rs
index 8174347e3869e..d68ca4e0abbae 100644
--- a/src/test/bench/shootout-spectralnorm.rs
+++ b/src/test/bench/shootout-spectralnorm.rs
@@ -41,13 +41,13 @@ fn mult(v: RWArc<~[f64]>, out: RWArc<~[f64]>, f: fn(&~[f64], uint) -> f64) {
         let w = wait.clone();
         let v = v.clone();
         let out = out.clone();
-        do spawn {
+        spawn(proc() {
             for i in range(chk, min(len, chk + chunk)) {
                 let val = v.read(|v| f(v, i));
                 out.write(|out| out[i] = val);
             }
             let _ = w;
-        }
+        });
     }
     let _ = wait.unwrap();
 }
diff --git a/src/test/bench/shootout-threadring.rs b/src/test/bench/shootout-threadring.rs
index 862b047db22f4..7063194eab862 100644
--- a/src/test/bench/shootout-threadring.rs
+++ b/src/test/bench/shootout-threadring.rs
@@ -23,17 +23,17 @@ fn start(n_tasks: int, token: int) {
         let (next_p, ch) = Chan::new();
         let imm_i = i;
         let imm_p = p;
-        do spawn {
+        spawn(proc() {
             roundtrip(imm_i, n_tasks, &imm_p, &ch);
-        };
+        });
         p = next_p;
         i += 1;
     }
     let imm_p = p;
     let imm_ch = ch1;
-    do spawn {
+    spawn(proc() {
         roundtrip(1, n_tasks, &imm_p, &imm_ch);
-    }
+    });
 }
 
 fn roundtrip(id: int, n_tasks: int, p: &Port<int>, ch: &Chan<int>) {
diff --git a/src/test/bench/silly-test-spawn.rs b/src/test/bench/silly-test-spawn.rs
index 900796efe33d3..16a9c03225adb 100644
--- a/src/test/bench/silly-test-spawn.rs
+++ b/src/test/bench/silly-test-spawn.rs
@@ -11,6 +11,6 @@
 // Useful smoketest for scheduler performance.
 fn main() {
     for _ in range(1, 100_000) {
-        do spawn { }
+        spawn(proc() {})
     }
 }
diff --git a/src/test/bench/spawnone.rs b/src/test/bench/spawnone.rs
index 75485a7fb9ecb..b55f471bdb24d 100644
--- a/src/test/bench/spawnone.rs
+++ b/src/test/bench/spawnone.rs
@@ -10,5 +10,5 @@
 
 // Useful for checking syscall usage of baseline scheduler usage
 fn main() {
-    do spawn { }
+    spawn(proc() {});
 }
diff --git a/src/test/bench/task-perf-alloc-unwind.rs b/src/test/bench/task-perf-alloc-unwind.rs
index db46c3db439a7..58fdadc2064da 100644
--- a/src/test/bench/task-perf-alloc-unwind.rs
+++ b/src/test/bench/task-perf-alloc-unwind.rs
@@ -34,9 +34,9 @@ fn main() {
 fn run(repeat: int, depth: int) {
     for _ in range(0, repeat) {
         info!("starting {:.4f}", precise_time_s());
-        do task::try {
+        task::try(proc() {
             recurse_or_fail(depth, None)
-        };
+        });
         info!("stopping {:.4f}", precise_time_s());
     }
 }
diff --git a/src/test/bench/task-perf-jargon-metal-smoke.rs b/src/test/bench/task-perf-jargon-metal-smoke.rs
index dc31ef06fa6f2..b41f6bcc50ad8 100644
--- a/src/test/bench/task-perf-jargon-metal-smoke.rs
+++ b/src/test/bench/task-perf-jargon-metal-smoke.rs
@@ -26,7 +26,7 @@ fn child_generation(gens_left: uint, c: comm::Chan<()>) {
     // This used to be O(n^2) in the number of generations that ever existed.
     // With this code, only as many generations are alive at a time as tasks
     // alive at a time,
-    do spawn {
+    spawn(proc() {
         if gens_left & 1 == 1 {
             task::deschedule(); // shake things up a bit
         }
@@ -35,7 +35,7 @@ fn child_generation(gens_left: uint, c: comm::Chan<()>) {
         } else {
             c.send(())
         }
-    }
+    });
 }
 
 fn main() {
diff --git a/src/test/bench/task-perf-linked-failure.rs b/src/test/bench/task-perf-linked-failure.rs
index eb0e64268f351..052900102c9a2 100644
--- a/src/test/bench/task-perf-linked-failure.rs
+++ b/src/test/bench/task-perf-linked-failure.rs
@@ -36,11 +36,11 @@ fn grandchild_group(num_tasks: uint) {
     for _ in range(0, num_tasks) {
         let ch = ch.clone();
         let mut t = task::task();
-        do t.spawn { // linked
+        t.spawn(proc() { // linked
             ch.send(());
             let (p, _c) = stream::<()>();
             p.recv(); // block forever
-        }
+        });
     }
     error!("Grandchild group getting started");
     for _ in range(0, num_tasks) {
@@ -77,17 +77,17 @@ fn main() {
     // Main group #0 waits for unsupervised group #1.
     // Grandparent group #1 waits for middle group #2, then fails, killing #3.
     // Middle group #2 creates grandchild_group #3, waits for it to be ready, exits.
-    let x: result::Result<(), ~Any> = do task::try { // unlinked
-        do spawn_supervised_blocking("grandparent") {
-            do spawn_supervised_blocking("middle") {
+    let x: result::Result<(), ~Any> = task::try(proc() { // unlinked
+        spawn_supervised_blocking("grandparent", proc() {
+            spawn_supervised_blocking("middle", proc() {
                 grandchild_group(num_tasks);
-            }
+            });
             // When grandchild group is ready to go, make the middle group exit.
             error!("Middle group wakes up and exits");
-        }
+        });
         // Grandparent group waits for middle group to be gone, then fails
         error!("Grandparent group wakes up and fails");
         fail!();
-    };
+    });
     assert!(x.is_err());
 }
diff --git a/src/test/bench/task-perf-one-million.rs b/src/test/bench/task-perf-one-million.rs
index e9a9ed194749d..454c7e45cc163 100644
--- a/src/test/bench/task-perf-one-million.rs
+++ b/src/test/bench/task-perf-one-million.rs
@@ -21,9 +21,9 @@ fn calc(children: uint, parent_wait_chan: &Chan<Chan<Chan<int>>>) {
 
     let wait_ports: ~[Port<Chan<Chan<int>>>] = vec::from_fn(children, |_| {
         let (wait_port, wait_chan) = stream::<Chan<Chan<int>>>();
-        do task::spawn {
+        task::spawn(proc() {
             calc(children / 2, &wait_chan);
-        }
+        });
         wait_port
     });
 
@@ -58,9 +58,9 @@ fn main() {
 
     let children = from_str::<uint>(args[1]).unwrap();
     let (wait_port, wait_chan) = stream();
-    do task::spawn {
+    task::spawn(proc() {
         calc(children, &wait_chan);
-    };
+    });
 
     let start_chan = wait_port.recv();
     let (sum_port, sum_chan) = stream::<int>();
diff --git a/src/test/compile-fail/arc-rw-read-mode-shouldnt-escape.rs b/src/test/compile-fail/arc-rw-read-mode-shouldnt-escape.rs
index 2fe2095ca879e..716dfe2c8b5c5 100644
--- a/src/test/compile-fail/arc-rw-read-mode-shouldnt-escape.rs
+++ b/src/test/compile-fail/arc-rw-read-mode-shouldnt-escape.rs
@@ -19,5 +19,5 @@ fn main() {
     });
     y.unwrap();
     // Adding this line causes a method unification failure instead
-    // do (&option::unwrap(y)).read |state| { assert!(*state == 1); }
+    // (&option::unwrap(y)).read(|state| { assert!(*state == 1); })
 }
diff --git a/src/test/compile-fail/arc-rw-write-mode-shouldnt-escape.rs b/src/test/compile-fail/arc-rw-write-mode-shouldnt-escape.rs
index d9247ab4fc170..213bf48a08750 100644
--- a/src/test/compile-fail/arc-rw-write-mode-shouldnt-escape.rs
+++ b/src/test/compile-fail/arc-rw-write-mode-shouldnt-escape.rs
@@ -17,5 +17,5 @@ fn main() {
     x.write_downgrade(|write_mode| y = Some(write_mode));
     y.unwrap();
     // Adding this line causes a method unification failure instead
-    // do (&option::unwrap(y)).write |state| { assert!(*state == 1); }
+    // (&option::unwrap(y)).write(|state| { assert!(*state == 1); })
 }
diff --git a/src/test/compile-fail/borrowck-loan-blocks-move-cc.rs b/src/test/compile-fail/borrowck-loan-blocks-move-cc.rs
index c935c9deeac1c..c193288468a20 100644
--- a/src/test/compile-fail/borrowck-loan-blocks-move-cc.rs
+++ b/src/test/compile-fail/borrowck-loan-blocks-move-cc.rs
@@ -17,10 +17,10 @@ fn borrow(v: &int, f: |x: &int|) {
 fn box_imm() {
     let v = ~3;
     let _w = &v;
-    do task::spawn {
+    task::spawn(proc() {
         info!("v={}", *v);
         //~^ ERROR cannot move `v` into closure
-    }
+    });
 
     let v = ~3;
     let _w = &v;
diff --git a/src/test/compile-fail/do-lambda-requires-braces.rs b/src/test/compile-fail/do-lambda-requires-braces.rs
deleted file mode 100644
index a836556dff881..0000000000000
--- a/src/test/compile-fail/do-lambda-requires-braces.rs
+++ /dev/null
@@ -1,15 +0,0 @@
-// Copyright 2012 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-fn main() {
-    do something
-        |x| do somethingelse //~ ERROR: expected `{` but found `do`
-        |y| say(x, y)
-}
diff --git a/src/test/compile-fail/do1.rs b/src/test/compile-fail/do1.rs
deleted file mode 100644
index d16fa4eadd566..0000000000000
--- a/src/test/compile-fail/do1.rs
+++ /dev/null
@@ -1,13 +0,0 @@
-// Copyright 2012 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-fn main() {
-    let x = do y; //~ ERROR: expected `{` but found
-}
diff --git a/src/test/compile-fail/do2.rs b/src/test/compile-fail/do2.rs
deleted file mode 100644
index 309abe218f6f1..0000000000000
--- a/src/test/compile-fail/do2.rs
+++ /dev/null
@@ -1,16 +0,0 @@
-// Copyright 2012 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-fn f(f: proc(int) -> bool) -> bool { f(10i) }
-
-fn main() {
-    assert!(do f() |i| { i == 10i } == 10i);
-    //~^ ERROR: expected `bool` but found `int`
-}
diff --git a/src/test/compile-fail/issue-3044.rs b/src/test/compile-fail/issue-3044.rs
index 310de3657b385..5fab2ed195cec 100644
--- a/src/test/compile-fail/issue-3044.rs
+++ b/src/test/compile-fail/issue-3044.rs
@@ -10,9 +10,9 @@
 
 fn main() {
     let needlesArr: ~[char] = ~['a', 'f'];
-    do needlesArr.iter().fold() |x, y| {
-    }
-    //~^^ ERROR 1 parameter was supplied (including the closure passed by the `do` keyword)
+    needlesArr.iter().fold(|x, y| {
+    });
+    //~^^ ERROR this function takes 2 parameters but 1 parameter was supplied
     //
     // the first error is, um, non-ideal.
 }
diff --git a/src/test/compile-fail/keyword-do-as-identifier.rs b/src/test/compile-fail/keyword-do-as-identifier.rs
deleted file mode 100644
index b2a0c8a02a90d..0000000000000
--- a/src/test/compile-fail/keyword-do-as-identifier.rs
+++ /dev/null
@@ -1,15 +0,0 @@
-// Copyright 2013 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-// This file was auto-generated using 'src/etc/generate-keyword-tests.py do'
-
-fn main() {
-    let do = "foo"; //~ error: ident
-}
diff --git a/src/test/compile-fail/moves-based-on-type-capture-clause-bad.rs b/src/test/compile-fail/moves-based-on-type-capture-clause-bad.rs
index dd68cb8e994e9..fe9c7ede83a08 100644
--- a/src/test/compile-fail/moves-based-on-type-capture-clause-bad.rs
+++ b/src/test/compile-fail/moves-based-on-type-capture-clause-bad.rs
@@ -2,8 +2,8 @@ use std::task;
 
 fn main() {
     let x = ~"Hello world!";
-    do task::spawn {
+    task::spawn(proc() {
         println!("{}", x);
-    }
+    });
     println!("{}", x); //~ ERROR use of moved value
 }
diff --git a/src/test/compile-fail/mutex-arc-nested.rs b/src/test/compile-fail/mutex-arc-nested.rs
index 476b890efcd6b..24a141c4799d5 100644
--- a/src/test/compile-fail/mutex-arc-nested.rs
+++ b/src/test/compile-fail/mutex-arc-nested.rs
@@ -17,10 +17,10 @@ fn test_mutex_arc_nested() {
     let arc = ~MutexArc::new(1);
     let arc2 = ~MutexArc::new(*arc);
 
-    do task::spawn || {
+    task::spawn(proc() {
         (*arc2).access(|mutex| { //~ ERROR instantiating a type parameter with an incompatible type
         })
-    };
+    });
 }
 
 fn main() {}
diff --git a/src/test/compile-fail/no-capture-arc.rs b/src/test/compile-fail/no-capture-arc.rs
index 65e0c07b3580e..5ae38e69ec0e3 100644
--- a/src/test/compile-fail/no-capture-arc.rs
+++ b/src/test/compile-fail/no-capture-arc.rs
@@ -19,10 +19,10 @@ fn main() {
     let v = ~[1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
     let arc_v = arc::Arc::new(v);
 
-    do task::spawn() {
+    task::spawn(proc() {
         let v = arc_v.get();
         assert_eq!(v[3], 4);
-    };
+    });
 
     assert_eq!((arc_v.get())[2], 3);
 
diff --git a/src/test/compile-fail/no-reuse-move-arc.rs b/src/test/compile-fail/no-reuse-move-arc.rs
index 3cd048040c6f5..c6c0ba41ab91a 100644
--- a/src/test/compile-fail/no-reuse-move-arc.rs
+++ b/src/test/compile-fail/no-reuse-move-arc.rs
@@ -17,10 +17,10 @@ fn main() {
     let v = ~[1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
     let arc_v = arc::Arc::new(v);
 
-    do task::spawn() {
+    task::spawn(proc() {
         let v = arc_v.get();
         assert_eq!(v[3], 4);
-    };
+    });
 
     assert_eq!((arc_v.get())[2], 3); //~ ERROR use of moved value: `arc_v`
 
diff --git a/src/test/compile-fail/no-send-res-ports.rs b/src/test/compile-fail/no-send-res-ports.rs
index 87173d779240f..9e564e997e673 100644
--- a/src/test/compile-fail/no-send-res-ports.rs
+++ b/src/test/compile-fail/no-send-res-ports.rs
@@ -32,8 +32,8 @@ fn main() {
 
     let x = foo(Port(@()));
 
-    do task::spawn {
+    task::spawn(proc() {
         let y = x;   //~ ERROR does not fulfill `Send`
         error!("{:?}", y);
-    }
+    });
 }
diff --git a/src/test/compile-fail/once-cant-call-twice-on-heap.rs b/src/test/compile-fail/once-cant-call-twice-on-heap.rs
index e2220355980e7..8d5e2229b2e5d 100644
--- a/src/test/compile-fail/once-cant-call-twice-on-heap.rs
+++ b/src/test/compile-fail/once-cant-call-twice-on-heap.rs
@@ -22,8 +22,8 @@ fn foo(blk: proc()) {
 
 fn main() {
     let x = arc::Arc::new(true);
-    do foo {
+    foo(proc() {
         assert!(*x.get());
         drop(x);
-    }
+    });
 }
diff --git a/src/test/compile-fail/sync-rwlock-read-mode-shouldnt-escape.rs b/src/test/compile-fail/sync-rwlock-read-mode-shouldnt-escape.rs
index e71dfc588161f..0078841acb139 100644
--- a/src/test/compile-fail/sync-rwlock-read-mode-shouldnt-escape.rs
+++ b/src/test/compile-fail/sync-rwlock-read-mode-shouldnt-escape.rs
@@ -18,5 +18,5 @@ fn main() {
         y = Some(x.downgrade(write_mode));
     })
     // Adding this line causes a method unification failure instead
-    // do (&option::unwrap(y)).read { }
+    // (&option::unwrap(y)).read(proc() { });
 }
diff --git a/src/test/compile-fail/sync-rwlock-write-mode-shouldnt-escape.rs b/src/test/compile-fail/sync-rwlock-write-mode-shouldnt-escape.rs
index af0149182aeba..6e9216830750b 100644
--- a/src/test/compile-fail/sync-rwlock-write-mode-shouldnt-escape.rs
+++ b/src/test/compile-fail/sync-rwlock-write-mode-shouldnt-escape.rs
@@ -18,5 +18,5 @@ fn main() {
         y = Some(write_mode);
     });
     // Adding this line causes a method unification failure instead
-    // do (&option::unwrap(y)).write { }
+    // (&option::unwrap(y)).write(proc() { })
 }
diff --git a/src/test/run-fail/extern-fail.rs b/src/test/run-fail/extern-fail.rs
index ce5ea56502cc7..b998056176e39 100644
--- a/src/test/run-fail/extern-fail.rs
+++ b/src/test/run-fail/extern-fail.rs
@@ -41,11 +41,11 @@ fn count(n: uint) -> uint {
 }
 
 fn main() {
-    do 10u.times {
-        do task::spawn {
+    10u.times(proc() {
+        task::spawn(proc() {
             let result = count(5u);
             info!("result = %?", result);
             fail!();
-        };
-    }
+        });
+    });
 }
diff --git a/src/test/run-fail/fail-task-name-none.rs b/src/test/run-fail/fail-task-name-none.rs
index 9d58c18200876..3f662e6d0e3e4 100644
--- a/src/test/run-fail/fail-task-name-none.rs
+++ b/src/test/run-fail/fail-task-name-none.rs
@@ -13,8 +13,8 @@
 use std::task;
 
 fn main() {
-    do task::try {
+    task::try(proc() {
         fail!("test");
         1
-    }.unwrap()
+    }).unwrap()
 }
diff --git a/src/test/run-fail/fail-task-name-owned.rs b/src/test/run-fail/fail-task-name-owned.rs
index 9e87b59db6494..a1115a09fb176 100644
--- a/src/test/run-fail/fail-task-name-owned.rs
+++ b/src/test/run-fail/fail-task-name-owned.rs
@@ -15,8 +15,8 @@ use std::task;
 fn main() {
     let mut t = task::task();
     t.name(~"owned name");
-    do t.try {
+    t.try(proc() {
         fail!("test");
         1
-    }.unwrap()
+    }).unwrap()
 }
diff --git a/src/test/run-fail/fail-task-name-send-str.rs b/src/test/run-fail/fail-task-name-send-str.rs
index 0e3ef39cd1db3..ca2472cfa55f1 100644
--- a/src/test/run-fail/fail-task-name-send-str.rs
+++ b/src/test/run-fail/fail-task-name-send-str.rs
@@ -13,8 +13,8 @@
 fn main() {
     let mut t = ::std::task::task();
     t.name("send name".to_send_str());
-    do t.try {
+    t.try(proc() {
         fail!("test");
         3
-    }.unwrap()
+    }).unwrap()
 }
diff --git a/src/test/run-fail/fail-task-name-static.rs b/src/test/run-fail/fail-task-name-static.rs
index 4fd19fb2a6f22..2303ab102d409 100644
--- a/src/test/run-fail/fail-task-name-static.rs
+++ b/src/test/run-fail/fail-task-name-static.rs
@@ -13,7 +13,7 @@
 fn main() {
     let mut t = ::std::task::task();
     t.name("static name");
-    do t.try {
+    t.try(proc() {
         fail!("test");
-    }.unwrap()
+    }).unwrap()
 }
diff --git a/src/test/run-fail/morestack2.rs b/src/test/run-fail/morestack2.rs
index 5ac3092640038..1094227770efd 100644
--- a/src/test/run-fail/morestack2.rs
+++ b/src/test/run-fail/morestack2.rs
@@ -62,8 +62,8 @@ fn and_then_get_big_again(x:int) -> and_then_get_big_again {
 }
 
 fn main() {
-    do task::spawn {
+    task::spawn(proc() {
         let r = and_then_get_big_again(4);
         getbig_call_c_and_fail(10000);
-    };
+    });
 }
diff --git a/src/test/run-fail/morestack3.rs b/src/test/run-fail/morestack3.rs
index e6f219710b37b..6acfa0b79f410 100644
--- a/src/test/run-fail/morestack3.rs
+++ b/src/test/run-fail/morestack3.rs
@@ -48,7 +48,7 @@ fn and_then_get_big_again(x:int) -> and_then_get_big_again {
 }
 
 fn main() {
-    do task::spawn {
+    task::spawn(proc() {
         getbig_and_fail(400);
-    };
+    });
 }
diff --git a/src/test/run-fail/morestack4.rs b/src/test/run-fail/morestack4.rs
index 02a65e91d0445..8be8e6b44f6af 100644
--- a/src/test/run-fail/morestack4.rs
+++ b/src/test/run-fail/morestack4.rs
@@ -41,7 +41,7 @@ fn and_then_get_big_again(x:int) -> and_then_get_big_again {
 }
 
 fn main() {
-    do task::spawn {
+    task::spawn(proc() {
         getbig_and_fail(1);
-    };
+    });
 }
diff --git a/src/test/run-fail/native-failure.rs b/src/test/run-fail/native-failure.rs
index 807ee94ce09a4..20d8a543ae196 100644
--- a/src/test/run-fail/native-failure.rs
+++ b/src/test/run-fail/native-failure.rs
@@ -17,7 +17,7 @@ extern mod native;
 
 #[start]
 fn start(argc: int, argv: **u8) -> int {
-    do native::start(argc, argv) {
+    native::start(argc, argv, proc() {
         fail!();
-    }
+    })
 }
diff --git a/src/test/run-fail/rt-set-exit-status-fail2.rs b/src/test/run-fail/rt-set-exit-status-fail2.rs
index ea70bb0eab9a5..d19788d8b5b84 100644
--- a/src/test/run-fail/rt-set-exit-status-fail2.rs
+++ b/src/test/run-fail/rt-set-exit-status-fail2.rs
@@ -34,8 +34,8 @@ fn r(x:int) -> r {
 
 fn main() {
     error!("whatever");
-    do task::spawn {
+    task::spawn(proc() {
       let _i = r(5);
-    };
+    });
     fail!();
 }
diff --git a/src/test/run-make/bootstrap-from-c-with-green/lib.rs b/src/test/run-make/bootstrap-from-c-with-green/lib.rs
index 452ee837d1296..94119cc0278da 100644
--- a/src/test/run-make/bootstrap-from-c-with-green/lib.rs
+++ b/src/test/run-make/bootstrap-from-c-with-green/lib.rs
@@ -17,9 +17,9 @@ extern mod green;
 
 #[no_mangle] // this needs to get called from C
 pub extern "C" fn foo(argc: int, argv: **u8) -> int {
-    do green::start(argc, argv) {
-        do spawn {
+    green::start(argc, argv, proc() {
+        spawn(proc() {
             println!("hello");
-        }
-    }
+        });
+    })
 }
diff --git a/src/test/run-make/bootstrap-from-c-with-native/lib.rs b/src/test/run-make/bootstrap-from-c-with-native/lib.rs
index 4f931bdb8011e..2a783606d944a 100644
--- a/src/test/run-make/bootstrap-from-c-with-native/lib.rs
+++ b/src/test/run-make/bootstrap-from-c-with-native/lib.rs
@@ -16,9 +16,9 @@ extern mod native;
 
 #[no_mangle] // this needs to get called from C
 pub extern "C" fn foo(argc: int, argv: **u8) -> int {
-    do native::start(argc, argv) {
-        do spawn {
+    native::start(argc, argv, proc() {
+        spawn(proc() {
             println!("hello");
-        }
-    }
+        });
+    })
 }
diff --git a/src/test/run-make/static-unwinding/main.rs b/src/test/run-make/static-unwinding/main.rs
index 029933a819cc5..96dabf8f07699 100644
--- a/src/test/run-make/static-unwinding/main.rs
+++ b/src/test/run-make/static-unwinding/main.rs
@@ -12,11 +12,11 @@ impl Drop for A {
 }
 
 fn main() {
-    do task::try {
+    task::try(proc() {
         let _a = A;
         lib::callback(|| fail!());
         1
-    };
+    });
 
     unsafe {
         assert!(lib::statik == 1);
diff --git a/src/test/run-pass-fulldeps/qquote.rs b/src/test/run-pass-fulldeps/qquote.rs
index 0fcd49790e072..05225eb0e7ada 100644
--- a/src/test/run-pass-fulldeps/qquote.rs
+++ b/src/test/run-pass-fulldeps/qquote.rs
@@ -75,11 +75,11 @@ fn main() {
 
 fn check_pp<T>(cx: fake_ext_ctxt,
                expr: T, f: |pprust::ps, T|, expect: ~str) {
-    let s = do io::with_str_writer |wr| {
+    let s = io::with_str_writer(|wr| {
         let pp = pprust::rust_printer(wr, cx.parse_sess().interner);
         f(pp, expr);
         pp::eof(pp.s);
-    };
+    });
     stdout().write_line(s);
     if expect != ~"" {
         error!("expect: '%s', got: '%s'", expect, s);
diff --git a/src/test/run-pass/block-arg-can-be-followed-by-binop.rs b/src/test/run-pass/block-arg-can-be-followed-by-binop.rs
deleted file mode 100644
index f2149e23210cc..0000000000000
--- a/src/test/run-pass/block-arg-can-be-followed-by-binop.rs
+++ /dev/null
@@ -1,20 +0,0 @@
-// Copyright 2012 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-fn add(x: proc(f64) -> f64) -> f64 {
-    x(10.0)
-}
-
-pub fn main() {
-    // Trailing expressions don't require parentheses:
-    let y = do add |x| { x + 10.0 } + 10.0;
-
-    assert_eq!(y, 30.0);
-}
diff --git a/src/test/run-pass/block-arg-can-be-followed-by-block-arg.rs b/src/test/run-pass/block-arg-can-be-followed-by-block-arg.rs
deleted file mode 100644
index 2cdf0a1ffe1f1..0000000000000
--- a/src/test/run-pass/block-arg-can-be-followed-by-block-arg.rs
+++ /dev/null
@@ -1,17 +0,0 @@
-// Copyright 2012 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-fn f(_: proc()) -> proc(proc() -> uint) {
-    proc(_: proc() -> uint) {}
-}
-
-pub fn main() {
-    do do f {} { 20 };
-}
diff --git a/src/test/run-pass/block-arg-can-be-followed-by-call.rs b/src/test/run-pass/block-arg-can-be-followed-by-call.rs
deleted file mode 100644
index 544367bdfa9d5..0000000000000
--- a/src/test/run-pass/block-arg-can-be-followed-by-call.rs
+++ /dev/null
@@ -1,18 +0,0 @@
-// Copyright 2012 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-fn f(_: proc()) -> proc(uint) -> uint {
-    proc(x: uint) { x }
-}
-
-pub fn main() {
-    let z = do f {} (22u);
-    assert_eq!(z, 22u);
-}
diff --git a/src/test/run-pass/block-arg-in-parentheses.rs b/src/test/run-pass/block-arg-in-parentheses.rs
deleted file mode 100644
index 083217132de11..0000000000000
--- a/src/test/run-pass/block-arg-in-parentheses.rs
+++ /dev/null
@@ -1,38 +0,0 @@
-// Copyright 2012 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-fn f(_: proc(int, int) -> int) -> int {
-    10
-}
-
-fn w_semi() {
-    // the semicolon causes compiler not to
-    // complain about the ignored return value:
-    do f |x, y| { x+y };
-}
-
-fn w_paren1() -> int {
-    (do f |x, y| { x+y }) - 10
-}
-
-fn w_paren2() -> int {
-    (do f |x, y| { x+y } - 10)
-}
-
-fn w_ret() -> int {
-    return do f |x, y| { x+y } - 10;
-}
-
-pub fn main() {
-    w_semi();
-    w_paren1();
-    w_paren2();
-    w_ret();
-}
diff --git a/src/test/run-pass/block-arg-used-as-any.rs b/src/test/run-pass/block-arg-used-as-any.rs
deleted file mode 100644
index 87a6cbd6fc2f3..0000000000000
--- a/src/test/run-pass/block-arg-used-as-any.rs
+++ /dev/null
@@ -1,18 +0,0 @@
-// Copyright 2012 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-fn call_any(f: proc() -> uint) -> uint {
-    return f();
-}
-
-pub fn main() {
-    let x_r = do call_any { 22u };
-    assert_eq!(x_r, 22u);
-}
diff --git a/src/test/run-pass/block-arg.rs b/src/test/run-pass/block-arg.rs
index afe7747457a8c..d59804b23954e 100644
--- a/src/test/run-pass/block-arg.rs
+++ b/src/test/run-pass/block-arg.rs
@@ -25,49 +25,4 @@ pub fn main() {
         info!("{:?}", *i);
     }
 
-    // Usable at all:
-    do inty |x| { x };
-
-    // Higher precedence than assignments:
-    let result = do inty |e| { e };
-    assert_eq!(result, 100);
-
-    // Higher precedence than unary operations:
-    let stringy = do inty |e| { e }.to_str();
-    assert!(do booly |_| { true });
-    assert!(!do booly |_| { false });
-
-    // Usable in funny statement-like forms:
-    if !do booly |_| { true } {
-        assert!(false);
-    }
-    match do booly |_| { false } {
-        true => { fail!("incorrect answer."); }
-        false => { }
-    }
-    match 3 {
-      _ if do booly |_| { true } => {
-      }
-      _ => {
-        fail!("wrong answer.");
-      }
-    }
-
-
-    // Lower precedence than binary operations:
-    let w = do inty |_| { 10 } + 10;
-    let y = do inty |_| { 10 } + 10;
-    let z = 10 + do inty |_| { 10 };
-    assert_eq!(w, y);
-    assert_eq!(y, z);
-
-    // In the tail of a block
-    let w = if true {
-        do booly |_| {
-            true
-        }
-    } else {
-        false
-    };
-    assert!(w);
 }
diff --git a/src/test/run-pass/capture_nil.rs b/src/test/run-pass/capture_nil.rs
index 0d9fdea4a9d51..874075e8c1400 100644
--- a/src/test/run-pass/capture_nil.rs
+++ b/src/test/run-pass/capture_nil.rs
@@ -28,9 +28,9 @@ use std::task;
 
 fn foo(x: ()) -> Port<()> {
     let (p, c) = Chan::<()>::new();
-    do task::spawn() {
+    task::spawn(proc() {
         c.send(x);
-    }
+    });
     p
 }
 
diff --git a/src/test/run-pass/capturing-logging.rs b/src/test/run-pass/capturing-logging.rs
index b810bfd1c6b71..171424d8b3b69 100644
--- a/src/test/run-pass/capturing-logging.rs
+++ b/src/test/run-pass/capturing-logging.rs
@@ -30,18 +30,18 @@ impl Logger for MyWriter {
 
 #[start]
 fn start(argc: int, argv: **u8) -> int {
-    do native::start(argc, argv) {
+    native::start(argc, argv, proc() {
         main();
-    }
+    })
 }
 
 fn main() {
     let (p, c) = Chan::new();
     let (mut r, w) = (PortReader::new(p), ChanWriter::new(c));
-    do spawn {
+    spawn(proc() {
         set_logger(~MyWriter(w) as ~Logger);
         debug!("debug");
         info!("info");
-    }
+    });
     assert_eq!(r.read_to_str(), ~"info\n");
 }
diff --git a/src/test/run-pass/closure-bounds-can-capture-chan.rs b/src/test/run-pass/closure-bounds-can-capture-chan.rs
index 3a92f4ba3f401..66fac94ba51e1 100644
--- a/src/test/run-pass/closure-bounds-can-capture-chan.rs
+++ b/src/test/run-pass/closure-bounds-can-capture-chan.rs
@@ -16,8 +16,8 @@ fn foo(blk: proc()) {
 
 pub fn main() {
     let (p,c) = Chan::new();
-    do foo {
+    foo(proc() {
         c.send(());
-    }
+    });
     p.recv();
 }
diff --git a/src/test/run-pass/closure-reform.rs b/src/test/run-pass/closure-reform.rs
index 61175a401abe2..3ed77cd9fb767 100644
--- a/src/test/run-pass/closure-reform.rs
+++ b/src/test/run-pass/closure-reform.rs
@@ -38,11 +38,6 @@ fn call_bare_again(f: extern "Rust" fn(&str)) {
 pub fn main() {
     // Procs
 
-    let greeting = ~"Hi ";
-    do call_it |s| {
-        greeting + s
-    }
-
     let greeting = ~"Hello ";
     call_it(proc(s) {
         greeting + s
diff --git a/src/test/run-pass/do-empty-args.rs b/src/test/run-pass/do-empty-args.rs
deleted file mode 100644
index 56ba2ffddbb4b..0000000000000
--- a/src/test/run-pass/do-empty-args.rs
+++ /dev/null
@@ -1,23 +0,0 @@
-// Copyright 2012 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-// no-reformat
-// Testing various forms of `do` with empty arg lists
-
-fn f(_f: proc() -> bool) -> bool {
-    true
-}
-
-pub fn main() {
-    do f() || { true };
-    do f() { true };
-    do f || { true };
-    do f { true };
-}
diff --git a/src/test/run-pass/do-no-args.rs b/src/test/run-pass/do-no-args.rs
deleted file mode 100644
index 0df5c82ab077f..0000000000000
--- a/src/test/run-pass/do-no-args.rs
+++ /dev/null
@@ -1,19 +0,0 @@
-// Copyright 2012 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-// Testing that we can drop the || in do exprs
-
-fn f(_f: proc() -> bool) -> bool { true }
-
-fn d(_f: proc()) { }
-
-pub fn main() {
-    do d { }
-}
diff --git a/src/test/run-pass/do1.rs b/src/test/run-pass/do1.rs
deleted file mode 100644
index bdbad74b32095..0000000000000
--- a/src/test/run-pass/do1.rs
+++ /dev/null
@@ -1,15 +0,0 @@
-// Copyright 2012 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-fn f(f: proc(int)) { f(10) }
-
-pub fn main() {
-    do f() |i| { assert!(i == 10) }
-}
diff --git a/src/test/run-pass/do2.rs b/src/test/run-pass/do2.rs
deleted file mode 100644
index f509f7b454d35..0000000000000
--- a/src/test/run-pass/do2.rs
+++ /dev/null
@@ -1,15 +0,0 @@
-// Copyright 2012 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-fn f(f: proc(int) -> int) -> int { f(10) }
-
-pub fn main() {
-    assert_eq!(do f() |i| { i }, 10);
-}
diff --git a/src/test/run-pass/do3.rs b/src/test/run-pass/do3.rs
deleted file mode 100644
index cdba14f1deda4..0000000000000
--- a/src/test/run-pass/do3.rs
+++ /dev/null
@@ -1,15 +0,0 @@
-// Copyright 2012 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-fn f(f: proc(int) -> int) -> int { f(10) }
-
-pub fn main() {
-    assert_eq!(do f |i| { i }, 10);
-}
diff --git a/src/test/run-pass/extern-call-deep2.rs b/src/test/run-pass/extern-call-deep2.rs
index 00ac0bfa118eb..500ae8951ec4a 100644
--- a/src/test/run-pass/extern-call-deep2.rs
+++ b/src/test/run-pass/extern-call-deep2.rs
@@ -40,9 +40,9 @@ fn count(n: uint) -> uint {
 pub fn main() {
     // Make sure we're on a task with small Rust stacks (main currently
     // has a large stack)
-    do task::spawn {
+    task::spawn(proc() {
         let result = count(1000u);
         info!("result = {}", result);
         assert_eq!(result, 1000u);
-    };
+    });
 }
diff --git a/src/test/run-pass/extern-call-scrub.rs b/src/test/run-pass/extern-call-scrub.rs
index 0044f0f468f30..c35e84154d80b 100644
--- a/src/test/run-pass/extern-call-scrub.rs
+++ b/src/test/run-pass/extern-call-scrub.rs
@@ -44,9 +44,9 @@ fn count(n: uint) -> uint {
 pub fn main() {
     // Make sure we're on a task with small Rust stacks (main currently
     // has a large stack)
-    do task::spawn {
+    task::spawn(proc() {
         let result = count(12u);
         info!("result = {}", result);
         assert_eq!(result, 2048u);
-    };
+    });
 }
diff --git a/src/test/run-pass/extern-stress.rs b/src/test/run-pass/extern-stress.rs
index 7c16ae74c4a91..26c7e6881a6c4 100644
--- a/src/test/run-pass/extern-stress.rs
+++ b/src/test/run-pass/extern-stress.rs
@@ -42,8 +42,8 @@ fn count(n: uint) -> uint {
 
 pub fn main() {
     100u.times(|| {
-        do task::spawn {
+        task::spawn(proc() {
             assert_eq!(count(5u), 16u);
-        };
+        });
     })
 }
diff --git a/src/test/run-pass/extern-yield.rs b/src/test/run-pass/extern-yield.rs
index a4ac197ac6aed..da26f92ecdf32 100644
--- a/src/test/run-pass/extern-yield.rs
+++ b/src/test/run-pass/extern-yield.rs
@@ -39,10 +39,10 @@ fn count(n: uint) -> uint {
 
 pub fn main() {
     10u.times(|| {
-        do task::spawn {
+        task::spawn(proc() {
             let result = count(5u);
             info!("result = {}", result);
             assert_eq!(result, 16u);
-        };
+        });
     })
 }
diff --git a/src/test/run-pass/fail-in-dtor-drops-fields.rs b/src/test/run-pass/fail-in-dtor-drops-fields.rs
index 7c6bb1fa379b4..be4a497989ce8 100644
--- a/src/test/run-pass/fail-in-dtor-drops-fields.rs
+++ b/src/test/run-pass/fail-in-dtor-drops-fields.rs
@@ -33,9 +33,9 @@ impl Drop for B {
 }
 
 pub fn main() {
-    let ret = do task::try {
+    let ret = task::try(proc() {
         let _a = A { b: B { foo: 3 } };
-    };
+    });
     assert!(ret.is_err());
     unsafe { assert!(dropped); }
 }
diff --git a/src/test/run-pass/foreign-call-no-runtime.rs b/src/test/run-pass/foreign-call-no-runtime.rs
index ee54423a97d7d..daaaac93791bd 100644
--- a/src/test/run-pass/foreign-call-no-runtime.rs
+++ b/src/test/run-pass/foreign-call-no-runtime.rs
@@ -10,10 +10,10 @@ extern {
 
 pub fn main() {
     unsafe {
-        do run_in_bare_thread() {
+        run_in_bare_thread(proc() {
             let i = &100;
             rust_dbg_call(callback, cast::transmute(i));
-        }
+        });
     }
 }
 
diff --git a/src/test/run-pass/infinite-loops.rs b/src/test/run-pass/infinite-loops.rs
index dea0df2e52b34..633c096b68920 100644
--- a/src/test/run-pass/infinite-loops.rs
+++ b/src/test/run-pass/infinite-loops.rs
@@ -17,7 +17,7 @@
 extern mod extra;
 
 fn loopy(n: int) {
-    if n > 0 { do spawn { loopy(n - 1) }; do spawn { loopy(n - 1) }; }
+    if n > 0 { spawn(proc() { loopy(n - 1) }); spawn(proc() { loopy(n - 1) }); }
     loop { }
 }
 
@@ -25,5 +25,5 @@ pub fn main() {
     // Commenting this out, as this will hang forever otherwise.
     // Even after seeing the comment above, I'm not sure what the
     // intention of this test is.
-    // do spawn { loopy(5) };
+    // spawn(proc() { loopy(5) });
 }
diff --git a/src/test/run-pass/issue-2185.rs b/src/test/run-pass/issue-2185.rs
index 9ebeec092cf15..cef183e5f33c7 100644
--- a/src/test/run-pass/issue-2185.rs
+++ b/src/test/run-pass/issue-2185.rs
@@ -51,16 +51,16 @@ impl iterable<uint> for 'static ||uint|| {
 }
 
 fn filter<A,IA:iterable<A>>(self: IA, prd: 'static |A| -> bool, blk: |A|) {
-    do self.iter |a| {
+    self.iter(|a| {
         if prd(a) { blk(a) }
-    }
+    });
 }
 
 fn foldl<A,B,IA:iterable<A>>(self: IA, b0: B, blk: |B, A| -> B) -> B {
     let mut b = b0;
-    do self.iter |a| {
+    self.iter(|a| {
         b = blk(b, a);
-    }
+    });
     b
 }
 
diff --git a/src/test/run-pass/issue-3168.rs b/src/test/run-pass/issue-3168.rs
index 978cd586975f9..49b7e50c01e61 100644
--- a/src/test/run-pass/issue-3168.rs
+++ b/src/test/run-pass/issue-3168.rs
@@ -16,19 +16,19 @@ use std::task;
 
 pub fn main() {
     let (p,c) = comm::stream();
-    do task::try || {
+    task::try(|| {
         let (p2,c2) = comm::stream();
-        do task::spawn || {
+        task::spawn(|| {
             p2.recv();
             error!("sibling fails");
             fail!();
-        }
+        });
         let (p3,c3) = comm::stream();
         c.send(c3);
         c2.send(());
         error!("child blocks");
         p3.recv();
-    };
+    });
     error!("parent tries");
     assert!(!p.recv().try_send(()));
     error!("all done!");
diff --git a/src/test/run-pass/issue-3609.rs b/src/test/run-pass/issue-3609.rs
index 4922ab18f8d45..bcda2e27614c6 100644
--- a/src/test/run-pass/issue-3609.rs
+++ b/src/test/run-pass/issue-3609.rs
@@ -12,8 +12,7 @@ enum Msg
 }
 
 fn foo(name: ~str, samples_chan: Chan<Msg>) {
-    do task::spawn
-    {
+    task::spawn(proc() {
         let mut samples_chan = samples_chan;
         let callback: SamplesFn = proc(buffer) {
             for i in range(0u, buffer.len()) {
@@ -21,7 +20,7 @@ fn foo(name: ~str, samples_chan: Chan<Msg>) {
             }
         };
         samples_chan.send(GetSamples(name.clone(), callback));
-    };
+    });
 }
 
 pub fn main() {}
diff --git a/src/test/run-pass/issue-4241.rs b/src/test/run-pass/issue-4241.rs
index 4cdf7aa3dd02d..173f76434d303 100644
--- a/src/test/run-pass/issue-4241.rs
+++ b/src/test/run-pass/issue-4241.rs
@@ -45,13 +45,13 @@ priv fn parse_data(len: uint, io: @io::Reader) -> Result {
 
 priv fn parse_list(len: uint, io: @io::Reader) -> Result {
   let mut list: ~[Result] = ~[];
-    do len.times {
+    len.times(proc() {
     let v =
         match io.read_char() {
         '$' => parse_bulk(io),
         ':' => parse_int(io),
          _ => fail!()
-    };
+    });
     list.push(v);
     }
   return List(list);
@@ -119,11 +119,11 @@ fn query(cmd: ~[~str], sb: TcpSocketBuf) -> Result {
 
 fn query2(cmd: ~[~str]) -> Result {
   let _cmd = cmd_to_str(cmd);
-    do io::with_str_reader(~"$3\r\nXXX\r\n") |sb| {
+    io::with_str_reader(~"$3\r\nXXX\r\n")(|sb| {
     let res = parse_response(@sb as @io::Reader);
     println!("{:?}", res);
     res
-    }
+    });
 }
 
 
diff --git a/src/test/run-pass/issue-4446.rs b/src/test/run-pass/issue-4446.rs
index baac8d0dcd14c..8f2d9f32440bb 100644
--- a/src/test/run-pass/issue-4446.rs
+++ b/src/test/run-pass/issue-4446.rs
@@ -13,9 +13,9 @@ use std::io::println;
 pub fn main() {
     let (port, chan) = Chan::new();
 
-    do spawn {
+    spawn(proc() {
         println(port.recv());
-    }
+    });
 
     chan.send("hello, world");
 }
diff --git a/src/test/run-pass/issue-4448.rs b/src/test/run-pass/issue-4448.rs
index c3f871c79124b..8fbc35c72005a 100644
--- a/src/test/run-pass/issue-4448.rs
+++ b/src/test/run-pass/issue-4448.rs
@@ -13,9 +13,9 @@ use std::task;
 pub fn main() {
     let (port, chan) = Chan::<&'static str>::new();
 
-    do task::spawn {
+    task::spawn(proc() {
         assert_eq!(port.recv(), "hello, world");
-    }
+    });
 
     chan.send("hello, world");
 }
diff --git a/src/test/run-pass/kindck-implicit-close-over-mut-var.rs b/src/test/run-pass/kindck-implicit-close-over-mut-var.rs
index e0c1d35b3bc60..3f45e864da35a 100644
--- a/src/test/run-pass/kindck-implicit-close-over-mut-var.rs
+++ b/src/test/run-pass/kindck-implicit-close-over-mut-var.rs
@@ -16,10 +16,10 @@ fn foo() {
     // Here, i is *copied* into the proc (heap closure).
     // Requires allocation.  The proc's copy is not mutable.
     let mut i = 0;
-    do task::spawn {
+    task::spawn(proc() {
         user(i);
         println!("spawned {}", i)
-    }
+    });
     i += 1;
     println!("original {}", i)
 }
@@ -29,9 +29,9 @@ fn bar() {
     // mutable outside of the proc.
     let mut i = 0;
     while i < 10 {
-        do task::spawn {
+        task::spawn(proc() {
             user(i);
-        }
+        });
         i += 1;
     }
 }
@@ -40,11 +40,11 @@ fn car() {
     // Here, i must be shadowed in the proc to be mutable.
     let mut i = 0;
     while i < 10 {
-        do task::spawn {
+        task::spawn(proc() {
             let mut i = i;
             i += 1;
             user(i);
-        }
+        });
         i += 1;
     }
 }
diff --git a/src/test/run-pass/logging-only-prints-once.rs b/src/test/run-pass/logging-only-prints-once.rs
index a06d025f6c7a5..d81b5818d6693 100644
--- a/src/test/run-pass/logging-only-prints-once.rs
+++ b/src/test/run-pass/logging-only-prints-once.rs
@@ -26,12 +26,12 @@ impl fmt::Default for Foo {
 
 pub fn main() {
     let (p,c) = Chan::new();
-    do spawn {
+    spawn(proc() {
         let mut f = Foo(Cell::new(0));
         debug!("{}", f);
         let Foo(ref mut f) = f;
         assert!(f.get() == 1);
         c.send(());
-    }
+    });
     p.recv();
 }
diff --git a/src/test/run-pass/moves-based-on-type-capture-clause.rs b/src/test/run-pass/moves-based-on-type-capture-clause.rs
index 064fb385dccb3..eb347ab28ff97 100644
--- a/src/test/run-pass/moves-based-on-type-capture-clause.rs
+++ b/src/test/run-pass/moves-based-on-type-capture-clause.rs
@@ -2,7 +2,7 @@ use std::task;
 
 pub fn main() {
     let x = ~"Hello world!";
-    do task::spawn {
+    task::spawn(proc() {
         println!("{}", x);
-    }
+    });
 }
diff --git a/src/test/run-pass/native-always-waits.rs b/src/test/run-pass/native-always-waits.rs
index cddee0be18df0..8907db04dadc0 100644
--- a/src/test/run-pass/native-always-waits.rs
+++ b/src/test/run-pass/native-always-waits.rs
@@ -18,11 +18,11 @@ static mut set: bool = false;
 #[start]
 fn start(argc: int, argv: **u8) -> int {
     // make sure that native::start always waits for all children to finish
-    do native::start(argc, argv) {
-        do spawn {
+    native::start(argc, argv, proc() {
+        spawn(proc() {
             unsafe { set = true; }
-        }
-    };
+        });
+    });
 
     // if we didn't set the global, then return a nonzero code
     if unsafe {set} {0} else {1}
diff --git a/src/test/run-pass/no-landing-pads.rs b/src/test/run-pass/no-landing-pads.rs
index 3459f021f39bb..f9567858022b3 100644
--- a/src/test/run-pass/no-landing-pads.rs
+++ b/src/test/run-pass/no-landing-pads.rs
@@ -24,9 +24,9 @@ impl Drop for A {
 }
 
 fn main() {
-    do task::try::<()> {
+    task::try::<()>(proc() {
         let _a = A;
         fail!();
-    };
+    });
     assert!(unsafe { !HIT });
 }
diff --git a/src/test/run-pass/once-move-out-on-heap.rs b/src/test/run-pass/once-move-out-on-heap.rs
index 8c3f889c176cd..bc56712ee3bc1 100644
--- a/src/test/run-pass/once-move-out-on-heap.rs
+++ b/src/test/run-pass/once-move-out-on-heap.rs
@@ -22,8 +22,8 @@ fn foo(blk: proc()) {
 
 pub fn main() {
     let x = arc::Arc::new(true);
-    do foo {
+    foo(proc() {
         assert!(*x.get());
         drop(x);
-    }
+    });
 }
diff --git a/src/test/run-pass/preempt.rs b/src/test/run-pass/preempt.rs
index f34cc268a0c25..0527f47c112e0 100644
--- a/src/test/run-pass/preempt.rs
+++ b/src/test/run-pass/preempt.rs
@@ -29,9 +29,9 @@ pub fn main() {
     let (port, chan) = stream();
 
     info!("main started");
-    do spawn {
+    spawn(proc() {
         starve_main(port);
-    };
+    });
     let mut i: int = 0;
     info!("main waiting for alive signal");
     chan.send(i);
diff --git a/src/test/run-pass/send-resource.rs b/src/test/run-pass/send-resource.rs
index 7ede574a4d5be..474606ad347bd 100644
--- a/src/test/run-pass/send-resource.rs
+++ b/src/test/run-pass/send-resource.rs
@@ -27,12 +27,12 @@ fn test(f: int) -> test {
 pub fn main() {
     let (p, c) = Chan::new();
 
-    do task::spawn() {
+    task::spawn(proc() {
         let (pp, cc) = Chan::new();
         c.send(cc);
 
         let _r = pp.recv();
-    }
+    });
 
     p.recv().send(test(42));
 }
diff --git a/src/test/run-pass/task-comm-12.rs b/src/test/run-pass/task-comm-12.rs
index ce30071aaf445..f6f6f3ba240cf 100644
--- a/src/test/run-pass/task-comm-12.rs
+++ b/src/test/run-pass/task-comm-12.rs
@@ -20,9 +20,9 @@ fn test00() {
     let i: int = 0;
     let mut builder = task::task();
     let mut result = builder.future_result();
-    do builder.spawn {
+    builder.spawn(proc() {
         start(i)
-    }
+    });
 
     // Sleep long enough for the task to finish.
     let mut i = 0;
diff --git a/src/test/run-pass/task-comm-7.rs b/src/test/run-pass/task-comm-7.rs
index 43ac3957ae2ed..8622ff7608999 100644
--- a/src/test/run-pass/task-comm-7.rs
+++ b/src/test/run-pass/task-comm-7.rs
@@ -31,21 +31,21 @@ fn test00() {
     let number_of_messages: int = 10;
 
     let c = ch.clone();
-    do task::spawn || {
+    task::spawn(proc() {
         test00_start(&c, number_of_messages * 0, number_of_messages);
-    }
+    });
     let c = ch.clone();
-    do task::spawn || {
+    task::spawn(proc() {
         test00_start(&c, number_of_messages * 1, number_of_messages);
-    }
+    });
     let c = ch.clone();
-    do task::spawn || {
+    task::spawn(proc() {
         test00_start(&c, number_of_messages * 2, number_of_messages);
-    }
+    });
     let c = ch.clone();
-    do task::spawn || {
+    task::spawn(proc() {
         test00_start(&c, number_of_messages * 3, number_of_messages);
-    }
+    });
 
     let mut i: int = 0;
     while i < number_of_messages {
diff --git a/src/test/run-pass/task-comm-9.rs b/src/test/run-pass/task-comm-9.rs
index a2463ff76815f..feae49ffeb83c 100644
--- a/src/test/run-pass/task-comm-9.rs
+++ b/src/test/run-pass/task-comm-9.rs
@@ -29,10 +29,10 @@ fn test00() {
 
     let mut builder = task::task();
     let result = builder.future_result();
-    do builder.spawn {
+    builder.spawn(proc() {
         let mut ch = ch;
         test00_start(&mut ch, number_of_messages);
-    }
+    });
 
     let mut i: int = 0;
     while i < number_of_messages {
diff --git a/src/test/run-pass/task-killjoin-rsrc.rs b/src/test/run-pass/task-killjoin-rsrc.rs
index 16e9cb538919c..a4be47323e5b9 100644
--- a/src/test/run-pass/task-killjoin-rsrc.rs
+++ b/src/test/run-pass/task-killjoin-rsrc.rs
@@ -56,10 +56,10 @@ fn joinable(f: proc()) -> Port<bool> {
         *b = true;
     }
     let (p, c) = stream();
-    do task::spawn_unlinked {
+    task::spawn_unlinked(proc() {
         let ccc = c;
         wrapper(ccc, f)
-    }
+    });
     p
 }
 
diff --git a/src/test/run-pass/trait-bounds-in-arc.rs b/src/test/run-pass/trait-bounds-in-arc.rs
index b99e6a03bcb3b..2bf18e1ae1d5f 100644
--- a/src/test/run-pass/trait-bounds-in-arc.rs
+++ b/src/test/run-pass/trait-bounds-in-arc.rs
@@ -71,13 +71,13 @@ pub fn main() {
                          ~dogge2 as ~Pet:Freeze+Send]);
     let (p1,c1) = Chan::new();
     let arc1 = arc.clone();
-    do task::spawn { check_legs(arc1); c1.send(()); }
+    task::spawn(proc() { check_legs(arc1); c1.send(()); });
     let (p2,c2) = Chan::new();
     let arc2 = arc.clone();
-    do task::spawn { check_names(arc2); c2.send(()); }
+    task::spawn(proc() { check_names(arc2); c2.send(()); });
     let (p3,c3) = Chan::new();
     let arc3 = arc.clone();
-    do task::spawn { check_pedigree(arc3); c3.send(()); }
+    task::spawn(proc() { check_pedigree(arc3); c3.send(()); });
     p1.recv();
     p2.recv();
     p3.recv();
diff --git a/src/test/run-pass/unit-like-struct-drop-run.rs b/src/test/run-pass/unit-like-struct-drop-run.rs
index 5707406de146c..04507dd01ce5c 100644
--- a/src/test/run-pass/unit-like-struct-drop-run.rs
+++ b/src/test/run-pass/unit-like-struct-drop-run.rs
@@ -21,9 +21,9 @@ impl Drop for Foo {
 }
 
 pub fn main() {
-    let x = do task::try {
+    let x = task::try(proc() {
         let _b = Foo;
-    };
+    });
 
     let s = x.unwrap_err().move::<&'static str>().unwrap();
     assert_eq!(s.as_slice(), "This failure should happen.");